C # - Tratando com Strings e Chars e Fernando Pessoa

Já tratei do assunto strings com foco para linguagem VB .NET e hoje volto ao assunto com um enfoque mais prático desta vez usando a linguagem C#.

Antes de iniciar com os exemplos práticos existem algumas coisas que você deve conhecer sobre strings e chars...

Teoria sobre Chars e Strings

1 - Chars

Uma string é uma sequência de caracteres enquanto um char representa um único caractere mas o mais importante não é isso.

A palavra-chave char é usada para declarar um caractere Unicode no intervalo indicado na tabela a seguir:

Tipo Intervalo Tamanho tipo .NET Framework
char U+0000 to U+ffff Unicode 16-bit character System.Char

Constantes do tipo char pode ser escritas como literais de caracteres, seqüência de escape hexadecimal, ou representação Unicode. Você também pode converter os códigos de caráter integral. No exemplo a seguir quatro variáveis char são inicializados com o mesmo caractere X:

char[] chars = new char[4];

chars[0] = 'X';           // Character literal
chars[1] = '\x0058';   // Hexadecimal
chars[2] = (char)88;  // Conversão a partir de tipo integral
chars[3] = '\u0058';   // Unicode

foreach (char c in chars)
{
    Console.Write(c + " ");
}
//  Resultado: X X X X

Um char pode ser convertido implicitamente em ushort, int, uint, long, float, ulong, double ou decimal.

2- Strings

O tipo string representa uma seqüência de zero ou mais caracteres Unicode. string é um alias para String no .NET Framework.

Embora string seja um tipo de referência, os operadores de igualdade ( == e != ) são definidos para comparar os valores dos objetos string, e não as referências. Isso faz com que os testes para a verificação de igualdade de uma seqüência de caracteres seja mais intuitiva. Por exemplo:

string a = "hello";
string b = "h";
// Anexa o contéudo de 'b'
b += "ello";
Console.WriteLine(a == b);
Console.WriteLine((object)a == (object)b);

O resultado acima será True e a seguir False pois o conteúdo das strings são
equivalentes mas a e b não referenciam a mesma instância de string.

O tipo System.String é um tipo de referência, ao contrário do tipo System.Char, que tipo de valor e, portanto, deriva de System.ValueType. O alias string é construído em C # e pode ser usado em vez de o nome completo.

A classe string possui uma diversos métodos estáticos e não estáticos que são usados para formatação, concatenação, desmembramento e tratamento de strings em geral que são muitos usados.

Ao trabalho

Vamos agora mostrar alguns exemplos práticos de como usar strings e chars e seus métodos.

1 - Determinar o tipo de caractere(Char) que uma String contém

Neste exemplo temos o seguinte cenário : Você possui uma variável do tipo Char e deseja determinar o tipo de caractere que a variável contém : se é uma letra, dígito, número, caractere de pontuação, caractere de controle, símbolo, espaço em branco, etc.

Vamos criar um projeto do tipo Windows Forms Application usando o Visual C# 2010 Express Edition com o nome tratandoStringsChars;

Inclua uma classe no projeto através do menu Project clicando em Add Class e informando o nome MacStrings.cs:

A seguir digite o código abaixo nesta classe:

using System;

namespace Macoratti
{
    public enum CharTipo
    {
        Digito,
        Letra,
        Numero,
        Pontuacao,
        Simbolo,
        Espaço,
        Separador,
        Desconhecido
    }
    static class MacStrings
    {
        public static CharTipo GetTipoCharNaString(this char _Char)
        {
            if (Char.IsLetter(_Char))
            {
                return CharTipo.Letra;
            }
            else if (Char.IsNumber(_Char))
            {
                return CharTipo.Numero;
            }
            else if (Char.IsPunctuation(_Char))
            {
                return CharTipo.Pontuacao;
            }
            else if (Char.IsSymbol(_Char))
            {
                return CharTipo.Simbolo;
            }
            else if (Char.IsWhiteSpace(_Char))
            {
                return CharTipo.Espaço;
            }
            else if (Char.IsSeparator(_Char))
            {
                return CharTipo.Separador;
            }
            else
            {
                return CharTipo.Desconhecido;
            }
        }
        public static CharTipo GetTipoCharNaString(string _strg, int charPosicao)
        {
            if (Char.IsLetter(_strg, charPosicao))
            {
                return CharTipo.Letra;
            }
            else if (Char.IsNumber(_strg, charPosicao))
            {
                return CharTipo.Numero;
            }
            else if (Char.IsPunctuation(_strg, charPosicao))
            {
                return CharTipo.Pontuacao;
            }
            else if (Char.IsSymbol( _strg, charPosicao))
            {
                return CharTipo.Simbolo;
            }
            else if (Char.IsWhiteSpace(_strg, charPosicao))
            {
                return CharTipo.Espaço;
            }
            else if (Char.IsSeparator( _strg,charPosicao))
            {
                return CharTipo.Separador;
            }
            else
            {
                return CharTipo.Desconhecido;
            }
        }
    }
}
 A classe MacStrings é uma classe estática que possui uma enumeração:

public enum CharTipo
{
   Digito,
   Letra,
   Numero,
   Pontuacao,
   Simbolo,
   Espaço,
   Separador,
   Desconhecido
}

e dois métodos estáticos sobrecarregados:

  • GetTipoCharNaString(this char _Char)
  • GetTipoCharNaString(string _strg, int charPosicao)

O primeiro retorna o tipo do caractere avaliado;

O segundo retorna o tipo do caractere na posição especificada;

O tipo de caractere é determinado pela enumeração definida na classe com base nos métodos
estáticos da classe Char conforme tabela abaixo:

Método Char Descrição
IsDigit Qualquer digito decimal no intervalo de 0-9 em todos os locale Unicode
IsLetter Qualquer letra
IsNumber Qualquer dígito decimal ou hexadecimal (superscripts,subscripts)
IsPontuaction Qualquer caractere de pontuação
IsSeparator Um espaço separando palavras, uma linha , ou separador de parágrafo
IsSurrogate Qualquer caractere surrogate no intervalo \UD800–\UDFFF
IsSymbol Qualquer símbolo matemático, de moeda ou outro símbolo.
IsWhiteSpace Qualquer caractere de espaço e dos seguintes caracteres:

\U0009
\U000A
\U000B
\U000C
\U000D
\U0085
\U2028
\U2029

Nota: Surrogate(Substituto)- Alguns personagens não têm uma representação
válida em Unicode. Estas caracteres têm alguns valores especiais, eles são
compostos de dois caracteres Unicode em dois intervalos específicos de tal
forma que o primeiro caractere Unicode está em um intervalo
(por exemplo 0xD800-0xD8FF) eo segundo caractere Unicode é na segunda faixa
(por exemplo 0xDC00 -0xDCFF).

Agora vamos definir uma interface bem simples no formulário form1.cs incluindo os controles:

Conforme o leiaute abaixo:

Agora vamos definir no evento Click do primeiro o botão o código que irá retornar o tipo de caractere percorrendo toda a string:

     private void btnVerificaString_Click(object sender, EventArgs e)
          {
              lstResultado.Items.Clear();
              lstResultado.Items.Add(" Verificando caracteres na string: " + txtString.Text);
              foreach (char _char in txtString.Text)
              {
                  lstResultado.Items.Add( _char + " => " + Macoratti.MacStrings.GetTipoCharNaString(_char));
              }
          }

Abaixo vemos o resultado do projeto em execução:

No evento Click do segundo botão temos abaixo o código que irá retornar o tipo de caractere para uma posição especifica na string:

   private void btnVerificaPosicao_Click(object sender, EventArgs e)
          {
              string texto = txtString.Text.Trim();
              int posicao = Convert.ToInt32(txtPosicao.Text);
              if (posicao > texto.Length)
              {
                  MessageBox.Show("Posição indicada excede tamanho da string.");
                  return;
              }
              char[] array = txtString.Text.ToCharArray();
              lstResultado.Items.Clear();
              lstResultado.Items.Add(" Verificando caracteres na string: " + texto);
              lstResultado.Items.Add(array[posicao-1] + " => " + Macoratti.MacStrings.GetTipoCharNaString(texto, posicao-1));
          }

Executando o projeto teremos o seguinte resultado:

2 - Encontrar a localização de todas as ocorrências de uma string(char) em outra string

Você precisa pesquisar em uma string por cada ocorrência de uma string específica e saber a localização específica da ocorrência na string.

Vamos definir um novo método estático na nossa classe chamado EncontrarTudo() com a seguinte assinatura:

EncontrarTudo(this string strPesquisada, string strProcurada, int posicaoInicial) onde :

O código completo é o seguinte:

        public static int[] EncontrarTudo(this string strPesquisada, string strProcurada, int posicaoInicial)
        {
            int posicaoEncontrada = -1; // -1 representa não encontrada
            int count = 0;
            List<int> itemsEncontrados = new List<int>();
           
            do
            {
                posicaoEncontrada = strPesquisada.IndexOf(strProcurada, posicaoInicial, StringComparison.Ordinal);

                if (posicaoEncontrada > -1)
                {
                    posicaoInicial = posicaoEncontrada + 1;
                    count++;
                    itemsEncontrados.Add(posicaoEncontrada);
                    //Console.WriteLine("Found item at position: " + posicaoEncontrada.ToString());
                }
            }
            while (posicaoEncontrada > -1 && posicaoInicial < strPesquisada.Length);

            return ((int[])itemsEncontrados.ToArray());
        }

Para verificar a ocorrência estamos usando o método IndexOf da classe String.

Usando um loop Do/While contamos as ocorrências e armazenamos o resultado em um array.

O código do evento Click do botão Iniciar Pesquisar é dado abaixo:

        private void btnIniciar_Click(object sender, EventArgs e)
        {
            string textoPesquisado = txtStringPesquisada.Text.Trim();
            string textoProcurado = txtStringProcurada.Text.Trim();

            int[] ocorrencias = Macoratti.MacStrings.EncontrarTudo(textoPesquisado, textoProcurado, 0);

            lstResultados.Items.Add("Foram encontrados " + ocorrencias.Length + " ocorrências da string '" + textoProcurado + "' no texto ");
            lstResultados.Items.Add("Nas seguintes posições do texto : ");
            foreach (int i in ocorrencias)
            {
                lstResultados.Items.Add(i);
            }
        }

Para testarmos o método vamos incluir um novo formulário no projeto com o nome padrão form2.cs e definir o seguinte leiaute no formulário:

Executando o projeto e procurando as ocorrências para a string 'cor' no poema de Fernando Pessoa ("Guardador de Rebanhos" - Alberto Caieiro) iremos obter:

Obs: Para relaxar coloquei ao lado mais dois trechos de poemas de Fernando Pessoa (Alberto Caeiro) - "A origem mental dos meus heterônimos está na minha tendência orgânica para a despersonalização e para a simulação"

(Alberto Caeiro)
O Universo não é uma idéia minha.
A minha idéia do Universo é que é uma idéia minha.
A noite não anoitece pelos meus olhos,
A minha idéia da noite é que anoitece por meus olhos.
Fora de eu pensar e de haver quaisquer pensamentos
A noite anoitece concretamente
E o fulgor das estrelas existe como se tivesse peso.

(Alberto Caeiro)
Não basta abrir a janela
Para ver os campos e o rio.
Não é bastante não ser cego
Para ver as árvores e as flores.
É preciso também não ter filosofia nenhuma.
Com filosofia não há árvores: há idéias apenas.
Há só cada um de nós, como uma cave.
Há só uma janela fechada, e todo o mundo lá fora;
E um sonho do que se poderia ver se a janela se abrisse,
Que nunca é o que se vê quando se abre a janela

Com estes exemplos lembramos alguns conceitos básicos sobre strings e chars e vimos como podemos retornar o tipo de um char em uma string e como encontrar ocorrências de strings em outra string.

Pegue o projeto completo aqui: UsandoStrings1.zip

"Está alguém entre vós aflito ? Ore. Está alguém contente ? Cante Louvores." Tiago 5:13

Referências:

José Carlos Macoratti