Aula 3

Cadeias de caráteres ("Strings")
Listas ("Arrays")

• Cadeias de caráteres são objetos, instâncias da classe String do pacote java.lang. Para declarar uma cadeia de caráteres e atribuir à mesma um valor literal, coloca-se este valor entre aspas:
     String s = "Olá!";

• Pode-se também criar explicitamente um novo objeto, chamando-se o método construtor da classe:
     String s = new String( "Olá!" );

  O método construtor pode receber outros tipos de argumentos, por exemplo uma lista dos caráteres que vão constituir a cadeia. Veja os detalhes na documentação.

• Uma vez a cadeia criada, o seu conteudo não pode mudar. Se percisarmos de uma cadeia de caráteres cujo conteudo possa mudar, precisamos usar a classe StringBuffer do pacote java.lang, que não será discutida nestas notas.

• Obviamente, uma dada referência do tipo String não precisa apontar sempre para o mesmo objeto. Assim, se tivermos
     String s = new String( "Olá!" );
     s = "Olá Mundo!";
  a referência s
deixa de referir-se ao primeiro objeto criado (cujo conteudo erá "Olá!") e passa a referir-se ao objeto cujo conteudo é "Olá Mundo!"). Se não houver mais nenhuma referência apontando para o primeiro objeto, este estará marcado para ser varrido pelo coletor de lixo tão logo este resolver entrar em ação.

• O método length permite descobrir o número de caráteres contidos numa String
. Por exemplo:
   String s = new String( "Olá!" );
   int nuhmero = s.length();
resulta no valor 4 para o inteiro chamado nuhmero.
• Há outros métodos que permitem obter informação a respeito de uma String, por exemplo, descobrir qual o caráter numa dada posição. Veja a documentação.

• Para determinar se duas cadeias de caráteres possuem o mesmo conteudo, usa-se o método equals. Este método considera maiúsculas e minúsculas como diferentes. Se não desejamos fazer esta distinção, devemos usar o método equalsIgnoreCase.

• É importante não confundir estas comparações de conteudo com o uso do operador ==, que, quando usado entre duas variáveis que são referências a objetos, serve para determinar se as duas variáveis apontam para o mesmo objeto.

• Como ilustração, considere o seguinte trecho de código:
    String s1, s2, s3, s4, s5, s6;
    s1 = "Olá!";
    s2 = "Olá!";
    s3 = "olá!":
    s4 = new String( "Olá!" );
    s5 = s4;
    s6 = new String( "Olá!" );
    boolean b1, b2, b3, b4, b5, b6, b7, b8;
    b1 = s2.equals( s1 );
    b2 = s3.equals( s1 );
    b3 = s3.equalsIgnoreCase( s1 );
    b4 = s4.equals( s1 );
    b5 = ( s2 == s1 );
    b6 = ( s4 == s1 );
    b7 = ( s4 == s5 );
    b8 = ( s4 == s6 );
    b9 = s4.equals( s6 );
  
  Convença-se de que, após execução deste código, os seguintes booleanos possuem o valor true: b1, b3, b4, b5, b7 e b9. Já b2, b6 e b8 possuem o valor false.

• Consulte a documentação para obter informação sobre métodos que permitem comparar pedaços de cadeias de caráteres e também determinar qual de duas cadeias vem primeira na ordem alfabética.

• Para concatenar duas String, usa-se o método concat. Note que, já que o tamanho de uma String não pode mudar, a concatenação resulta na criação de um novo objeto.

• Também pode-se usar o operador + para a concatenação. Por exemplo, no trecho de código abaixo, a mesma linha é impressa duas vezes:
     String s1 = "Olá ";
     String s2 = "Mundo!";
     System.out.println( s1.concat( s2 ) );
     System.out.println( s1 + s2 );

• Consulte a documentação para obter informação sobre métodos que permitem modificar cadeias de caráteres, por exemplo alterando um caráter ou passando de minúsculas para maiúsculas. Lembre-se de que, na verdade, estes métodos criam uma nova cadeia.

• O método estático valueOf da classe String permite obter uma cadeia de caráter que representa um dado tipo numérico. Um método estático está associado à classe, e não a uma instância particular da mesma. É fácil entender que o método em questão deve ser estático, pois quando resolvemos expressar um número na forma de caráteres, ainda não temos uma String. O método a ser chamado é que vai criá-la. Por exemplo:
     double a = 3.1415927;
     int i = 123;
     System.out.println( "a = " + String.valueOf( a ) );
     System.out.println( "i = " + String.valueOf( i ) );
  Este código resulta na impressão de a = 3.1415927 seguido de i = 123 na saida padrão. Na verdade, o mesmo resultado pode ser obtido com uma sintaxe simplificada, pois numa concatenação, números são transformados automaticamente em caráteres. Assim, as dua últimas linhas acima podem ser substituidas por
     System.out.println( "a = " + a );
     System.out.println( "i = " + i );

• Para realizar a operação inversa, ou seja transformar caráteres em tipos numéricos, é de se esperar que precisamos utilizar um método estático associado ao tipo numérico em questão. Porém, como um tipo primitivo em si não é um objeto, precisamos primeiro descobrir como associar uma classe a um tipo primitivo. As classes adequadas são chamadas de classes de embrulhamento (("wrapper classes") e podem ser encontradas no pacote java.lang. Por exemplo, a classe de embrulhamento de um tipo double é Double. Portanto, precisamos primeiro traduzir a nossa cadeia de caráteres num objeto Double. Para tanto, chamamos o método estático valueOf desta classe. Ainda precisaremos "desembrulhar" o nosso número, ou seja traduzir o nosso objeto Double num tipo primitivo double. Isto é feito chamando o método doubleValue da classe Double. O trecho de código abaixo ilustra este procedimento, assim como o semelhante para o caso de um tipo inteiro. (Outros tipos podem ser tratados também da mesma maneira.)
     String atxt = "3.1415927";
     String itxt = "123";
     double a = Double.valueOf( atxt ).doubleValue();
     int i = Integer.valueOf( itxt ).intValue();
  Após execução, o valor da variável de precisão dupla a é 3.1415927 e o valor da variável inteira i é 123. Num exemplo mais realístico, os valores expressos na forma de caráteres poderiam ser lidos de um arquivo ou digitados pelo usuário.

• No caso de inteiros, há uma maneira mais simples de realizar a operação acima: o método parseInt da classe Integer transforma diretamente uma cadeia de caráteres num tipo int. Portanto, o comando
     int i = Integer.parseInt( itxt );
  pode ser usado em vez da última linha do trecho de código anterior.

• A transformação de números em caráteres descrita na seção anterior resulta numa representação completa do número, sem arredondamento nem controle do formato pelo programador. Recursos para formatar texto, e em especial números, podem ser encontrados no pacote java.text. Como é de se esperar, formatos são objetos em Java. Como ilustração, o trecho de código abaixo resulta na impressão de a = 3.1416 na saida padrão:
     double a = 3.1415927;
     DecimaFormat meuFormato = new DecimalFormat( "0.####" );
     System.out.println( "a = " + meuFormato.format( a ) );
  
  O formato desejado é especificado pelo argumento do método construtor (veja os detalhes na documentação). O método format transforma o número (neste caso, de precisão dupla) numa cadeia da caráteres, respeitando este formato.

• Se uma cadeia de caráteres representa uma sucessão de palavras chaves, pode ser necessário decompô-la em palavras individuais. Semelhantemente, se dados númericos foram armazenados num arquivo na forma de uma tabela com várias colunas e estamos lendo linha por linha, precisamos decompor cada linha em números individuais. A classe StringTokenizer do pacote java.util permite realizar este tipo de operação. Cria-se um objeto StringTokenizer associado à cadeia de caráteres a ser decomposta. O método countTokens conta o número de palavras (ou outros elementos) da cadeia. As palavras podem ser extraidas sucessivamente com o método nextToken. O método hasMoreTokens testa a presença de palavras ainda não separadas. Por exemplo:
     String linhaDeDados = "0.225 4.32 6.17";
     StringTokenizer separador = new StringTokenizer( linhaDeDados );
     int i = separador.countTokens();
     String n1 = separador.nextToken();
     String n2 = separador.nextToken();
     boolean b = separador.hasMoreTokens();
  
  Após execução, o inteiro i vale 3; as cadeias de caráteres n1 e n2 contém "0.225" e "4.32", respectivamente. O booleano b possui o valor true, pois há ainda um número que não foi separado.

• Listas ("Arrays") são utilizadas para agrupar variáveis do mesmo tipo. O tipo pode ser qualquer tipo primitivo ou qualquer classe de objetos. Para declarar que uma variável representa uma lista, acrescenta-se colchetes após o nome da variável. A lista é criada utilizando-se a palavra-chave new e indicando o número de elementos entre colchetes:
     int c[];
     c = new int[ 12 ];
     double d[] = new double[ 30 ];

• No caso de uma lista de tipos primitivos, a lista pode ser criada e inicializada através de uma lista de valores entre chaves:
     int b[] = { 3, 5, 7, 9 };

• O índice especificando um elemento de uma lista é contado a partir de 0. Por exemplo, o comando acima é equivalente ao seguinte:
     int b[] = new int[ 4 ];
     b[ 0 ] = 3;
     b[ 1 ] = 5;
     b[ 2 ] = 7;
     b[ 3 ] = 9;

• No caso de uma lista de objetos, deve-se notar que a criação da lista não cria os objetos. Cria simplesmente uma lista de referências que ainda não apontam para nada (null). Os objetos ainda precisam ser criados e as suas referências atribuidas aos elementos da lista. Por exemplo, o código abaixo cria 3 rótulos organizados numa lista:
     Label llb[] = new Label[ 3 ];
     llb[ 0 ] = new Label( "Vetor a" );
     llb[ 1 ] = new Label( "Vetor b" );
     llb[ 2 ] = new Label( "Produto" );

• Qualquer lista possui uma variável inteira length que fornece o número de elementos da lista. Como exemplo de uso desta variável, podemos acrescentar ao trecho de código acima um laço que faz com que a cor de fundo dos três rótulos seja azul:
     for( int i = 0; i < llb.length; i++){
       llb[ i ].setBackground( Color.blue );
     }

• Uma lista pode ser passada como argumento a um método. Deve-se notar que listas são objetos e, na linguagem Java, objetos são sempre passados aos métodos por referência, ao passo que tipos primitivos são sempre passados por valor. Isto quer dizer que uma modificação à lista realizada no método chamado implicará na mesma modificação à lista definida no programa que chamou o método em questão.

• Listas de múltiplos indices podem ser definidas, sendo consideradas como listas de listas. Os seguintes exemplos criam objetos que são essencialmente matrizes:
     int b[][];
     b = new int[ 2 ][ 3 ];
     int c[][] = { { 1, 2, 3 }, { 4, 5, 6} };

• Porém, listas de listas podem ser mais gerais de que matrizes, pois as "linhas" podem ter tamanhos diferentes:
     int b[][];
     b = int[ 2 ][ ];
     b[ 0 ] = new int[ 2 ];
     b[ 1 ] = new int[ 3 ];
     int c[][] = { { 1, 2 }, { 3, 4, 5} };