Tutorial Java - Caracter e Strings

Objetivo
    Criar e manipular, objetos não-modificáveis do tipo string de caracteres da classe String e objetos da classe Character (todos do pacote java.lang).
    Estes recursos são apropriados para validar os dados de entrada de programas, exibir informações para usuários e outras manipulações baseadas em texto, bem como para desenvolver editores e processadores de texto, software de layout de página, sistemas computadorizados de composição e outros tipos de software de processamento de textos. 

Roteiro

  1. Caracteres;
  2. Tipos de dados primitivos na linguagem Java;
  3. String;
  4. Construtores da classe String;
  5. Métodos de Strings: length, charAt e getChars;
  6. Comparando Strings;
  7. Localizando caracteres e substrings em Strings;
  8. Extraindo substrings a partir de Strings;
  9. Concatenando Strings;
  10. Métodos replace, toUpperCase, toLowerCase, trim, toString e toCharArray de String;
  11. Utilizando o método valueOf de String.

1. Caracteres
    Os caracteres são blocos de construção, que são interpretados pelo computador como uma série de instruções utilizadas para realizar tarefas. O programa pode conter caracteres constantes, sendo o valor inteiro do caracter no conjunto de caracteres Unicode (ASCII), representado entre aspas simples. 
Tabela de caracteres ASCII

0

1

2

3

4

5

6

7

8

0

null

soh

stx

etx

eot

enq

ack

bel

bs

1

nl

vt

ff

cr

so

si

dle

dc1

dc2

2

dc4

nak

syn

etb

can

em

sub

esc

fs

3

rs

us

sp

!

“

#

$

%

&

4

(

)

*

+

,

-

.

/

0

5

2

3

4

5

6

7

8

9

:

6

<

'='

>

?

@

A

B

C

D

7

F

G

H

I

J

K

L

M

N

8

P

Q

R

S

T

U

V

W

X

9

Z

[

\

]

^

_

í

a

b

10

d

e

f

g

h

i

j

k

l

11

n

o

p

q

r

s

t

u

v

12

x

y

z

{

|

}

~

del



    Os dígitos à esquerda da tabela são os dígitos mais à esquerda do equivalente em decimal (0-12) do código do caracter e os dígitos na parte superior da tabela são os dígitos na parte superior da tabela são os dígitos à direita do equivalente em unidade (0-8) do código de caracter. Por exemplo, 'z' representa o valor inteiro de z, ou seja, 122.


2. Tipos de dados primitivos na linguagem Java
    Ao contrário das linguagens de programação C e C++, os tipos primitivos em Java são portáveis entre todas as plataformas de computador que suportam Java. Este e muitos outros recursos de portabilidade de Java permitem que os programadores escrevam programas uma só vez, sem saber qual a plataforma de computador em que o programa será  excecutado. Esse atributo é às vezes conhecido como “WORA(Witre Once, Run Anywhere – escreva uma vez, rode em qualquer lugar)”.


Tipo Tamanho em bits Valores
boolean 8 True ou false
char 16 \'u000' a '\uFFFF' (0 a 65535) (conj. De caracteres Unicode ISO)
byte 8 -128 a +127
short 16 -32768 a +32767
int 32 -2.147.483.648 a +2.147.483.647
long 64 -9.223.372.036.854.775.808 a +9.223.372.036.854.775.807
float Intervalonegativo -3,40282346638552886E+38 a -1,40129846432481707E-45 Intervalo positivo 1,40129846432481707E-45 a 3,40282346638552886E+38 (Ponto flutuante IEEE 754)
double Intervalo negativo: -1,7976931348623157E+308  a -4,94065645841246544E-324  Intervalo positivo: 4,94065645841246544E-324 a 1,7976931348623157E+308 (Ponto flutuante IEEE 754)

Para byte short char    int long float    double
De
byte - (char) Implícito Implícito Implícito Implícito
short (byte) - (char) Implícito Implícito Implícito Implícito
char (byte) (short - Implícito Implícito Implícito Implícito
int (byte) (short (char) - Implícito Implícito Implícito
long (byte) (short (char) (int) - Implícito Implícito
float (byte) (short (char) (int) (long) - Implícito
double (byte) (short (char) (int) (long) (double) -

Para um char alguns valores UNICODE
'\u0030' é 0

'\u0039' é 9

'\u0041' é A

'\u005A' é Z

'\u0061' é a

'\u007A' é z

3. String
    A string é uma sequência de caracteres tratada como uma só unidade, incluindo letras, dígitos e vários caracteres especiais, como +, -, *, /, $ e outros. Os literais string ou constantes string, também chamados de objetos anônimos String, são escritos como uma sequência de caracteres entre aspas duplas como segue:
“João da Silva” (nome)
“Rua 13 de maio, 754” (endereço em uma rua) “São Paulo, SP” (cidade e estado)
“(11) 3551-2142” (número de telefone)
O String pode ser atribuído em uma declaração a uma referência de String. A declaração
                        String color = “blue”;

inicializa a referência String color para fazer referência ao objeto anônimo String “blue”. Desta forma, Java trata todos os Strings anônimos que tenham o mesmo conteúdo como um objeto anônimo String que tem muitas referências, fazendo com que se economize memória.
    4. Construtores da classe String
    A classe String fornece nove construtores para inicializar objetos String de diferentes maneiras. O programa abaixo demonstra sete destes construtores:

  // ConstrutoresString.java
  // Este programa demonstra os construtores da classe String.

 // Pacote de extensão de Java
 import javax.swing.*;

 public class ConstrutoresString {

 // testa os construtores de String
 public static void main( String args[] ) {

 char charArray [] = {'f', 'e', 'l', 'i', 'z', ' ', 'a', 'n', 'i', 'v', 'e', 'r', 's', 'a', 'r', 'i', 'o' };

 byte byteArray [] = { ( byte ) 'a', ( byte ) 'n', ( byte ) 'o', ( byte ) ' ',
 ( byte ) 'n', ( byte ) 'o', ( byte ) 'v', ( byte ) 'o' };


 StringBuffer buffer;
 String s, s1, s2, s3, s4, s5, s6, s7, output;

 s = new String( "Ola" );
 buffer = new StringBuffer( "Benvindo a programacao Java!" );

 // usa os construtores de String
 s1 = new String();
 s2 = new String ( s );
 s3 = new String( charArray );
 s4 = new String( charArray, 6, 11 );
 s5 = new String( byteArray, 4, 4 );
 s6 = new String( byteArray );
 s7 = new String( buffer );

 // acrescenta os Strings à saída
 output = "s1 = " + s1 + "\ns2 = " + s2 + "\ns3 = " + s3 + "\ns4 = " + s4 +
 "\ns5 = " + s5 + "\ns6 = " + s6 + "\ns7 = " + s7;


 JOptionPane.showMessageDialog( null, output,
 "Demonstrando Classe ConstrutoresString",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

 } // fim da classe ConstrutoresString

Resultado da execução do programa ContrutoresString.java:
Construtores da classe String



5. Métodos de Strings: length, charAt e getChars
No exemplo abaixo estaremos estudando os métodos length, charAt e getChars, que determinam o comprimento de um String, obtem o caracter em uma localização específica em um String e obtem todo o conjunto de caracteres em um String, respectivamente. 

 // DiversosString.java
 // Este programa demonstra os métodos length,
 // charAt e getChars da classe String.
 //
 // Nota: o método getChars requer uma posição inicial e uma posição final no String. O primeiro
 // argumento corresponde a posição inicial, é o subscrito de onde a cópia realmente inicia.
 // O segundo argumento corresponde a posição final, que é uma posição após o subscrito no
 // qual a cópia termina. O terceiro argumento corresponde ao array que será transportado os caracteres.
 // O último argumento corresponde ao índice inicial no array de caracteres, onde serão transportados.

 // Pacotes de extensão Java
 import javax.swing.*;



 public class DiversosString {

 // testa os diversos métodos de String
 public static void main( String args[] )
 {
 String s1, output;
 char charArray [] ;

 s1 = new String ( "Estou aqui" );
 charArray = new char [ 5 ];

 // gera o string como saída
 output = "s1 = "+ s1;

 // testa o método length
 output +="\nTamanho de s1 = " + s1.length();

 // percorre com um laço os caracteres em s1 e os exibe na ordem inversa
 output += "\nA string reversa é = ";

 for ( int count = s1.length() - 1; count >= 0; count -- )
 output += s1.charAt( count ) + " ";

 // copia os caracteres do string para um array de caracteres
 s1.getChars( 0, 5, charArray, 0 );
 output += "\nO caracter array é = ";

 for ( int count = 0; count < charArray.length; count ++ )
 output += charArray [ count ] ;

 JOptionPane.showMessageDialog( null, output,
 "Demonstrando Classe DiversosString ",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

 } // fim da classe DiversosString

Resultado da execução do programa DiversosString.java:
Diversos

Nota sobre o método getChars.     Este método, requer uma posição inicial e uma posição final no String. O primeiro argumento corresponde a posição inicial, é o subscrito de onde a cópia realmente inicia. O segundo argumento corresponde a posição final, que é uma posição após o subscrito no  qual a cópia termina. O terceiro argumento corresponde ao array que será transportado os caracteres. O último argumento corresponde ao índice inicial no array de caracteres, onde serão transportados.
    6. Comparação em String
Java fornece diversos métodos para comparar objetos String. Esses métodos são demonstrados nos dois exemplos a seguir. Para entender exatamente o que significa um string ser “maior que” ou “menor que” um outro string, pense no processo de colocar em ordem         alfabética uma série de nomes. O alfabeto é uma lista ordenada de caracteres. Cada letra ocupa uma posição específica dentro da lista. Por exemplo, o “Z” é a vigésima sexta letra do alfabeto.     Todos os caracteres são representados dentro do computador como códigos numéricos, conforme visto anteriormente -  Tabela Conjunto de caracteres ASCII. Quando o computador compara dois strings, ele compara os códigos numéricos dos caracteres strings.     No exemplo a seguir demonstra os métodos equals, equalsIgnoreCase, compareTo e regionMatches de String e a utilização do operador de igualdade = = para comparar objetos String. 

 // ComparaString.java
 // Este programa demonstra os métodos equals, equalsIgnoreCase, compareTo e
 // regionMatches da classe String.
 // Pacote de extensão de Java
 import javax.swing.JOptionPane;

 public class ComparaString {

 // testa os métodos de comparação da classe String
 public static void main( String args[ ] )
 {
 String s, s1, s2, s3, s4, output;

 s1 = new String( "ola" );
 s2 = new String ( "tchau" );
 s3 = new String( "Feliz Aniversario" );
 s4 = new String( "feliz aniversario" );

 output = "s1 = " + s1 + "\ns2 = " + s2 + "\ns3 = " + s3 + "\ns4 = " + s4 + "\n\n";

 // testa igualdade com equals (utilizado para utilização de mesmo objeto na memória.)
 // A instrução s1 = new String( “ola” ); cria um novo objeto String com uma cópia do
 // String anônimo “alo” e atribui o novo objeto à referência s1. Assim, aplica-se esta.
 if ( s1. equals( "ola" ) )
 output += "s1 igual a \"ola\"\n";
 else
 output += "s1 não igual a \"ola\"\n";

 // testa igualdade com = = (tem funciona// diferente qdo. é utilizado para comparar
 // referências e quando é utilizado para comparar valores de tipos primitivos de dados.)
 // Se s1 tivesse sido inicializada com a instrução s1 = “alo”; aplicaria-se esta função.
 if ( s1 == "ola" )
 output += "s1 igual a \"ola\"\n";
 else
 output += "s1 não igual a \"ola\"\n";

 // testa igualdade (ignora case de maiúsculas/minúsculas)
 if ( s3. equalsIgnoreCase( s4 ) )
 output += "s3 igual s4\n";
 else
 output += "s3 não igual a s4\n";

 // testa comparação
 output +=
 "\ns1.compareTo( s2 ) eh " + s1.compareTo( s2 ) +
 "\ns2.compareTo( s1 ) eh " + s2.compareTo( s1 ) +
 "\ns1.compareTo( s1 ) eh " + s1.compareTo( s1 ) +
 "\ns3.compareTo( s4 ) eh" + s3.compareTo( s4 ) +
 "\ns4.compareTo( s3 ) eh " + s4.compareTo( s3 ) +
 "\n\n";

 // testa comparação em parte de string (diferencia maiúsculas de minúsculas)
 if ( s3.regionMatches( 0, s4, 0, 5 ) )
 output += "Os primeiros 5 caracteres de s3 e s4 são iguais\n";
 else
 output += "Os primeiros 5 caracteres de s3 e s4 são diferentes\n";

 // testa comparação em parte de string (ignora case de maiúsculas e minúsculas)
 if ( s3.regionMatches( true, 0, s4, 0, 5 ) )
 output += "Os primeiros 5 caracteres de s3 e s4 são iguais\n";
 else
 output += "Os primeiros 5 caracteres de s3 e s4 são diferentes\n";

 JOptionPane.showMessageDialog( null, output,
 "Demonstrando Classe ComparaString",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

 } // fim da classe ComparaString

Resultado da execução do programa ComparaString.java:
Compara String
No segundo exemplo a seguir, demonstra os métodos startsWith e endWith da classe String< para compara início e fim de um String
// Extensão pacote Java
import javax.swing.*;

public class StringStartEnd {

 // método de teste de comparação String para início e fim
 // de uma String
 public static void main( String args[] )
 {
 String strings[] = 
 { "started", "starting", "ended", "ending" };
 String output = "";

 // método de teste startsWith
 for ( int count = 0; count < strings.length; count++ )

 if ( strings[ count ].startsWith( "st" ) )
 output += "\"" + strings[ count ] +
 "\" starts with \"st\"\n";

 output += "\n";

 // método de teste startsWith início de uma posição
 // 2 de uma string
 for ( int count = 0; count < strings.length; count++ )

 if ( strings[ count ].startsWith( "art", 2 ) ) 
 output += "\"" + strings[ count ] +
 "\" starts with \"art\" at position 2\n";

 output += "\n";

 // método de teste endsWith
 for ( int count = 0; count < strings.length; count++ )

 if ( strings[ count ].endsWith( "ed" ) )
 output += "\"" + strings[ count ] + 
 "\" ends with \"ed\"\n";

 JOptionPane.showMessageDialog( null, output,
 "Demonstrating String Class Comparisons",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

} // fim da classe StringStartEnd


Resultado da execução do programa ComparaString.java:

Compara String
   

7. Localizando caracteres e substrings em Strings 
    Em geral, é útil procurar um caracter ou um conjunto de caracteres em um String. Por exemplo, se estiver criando seu próprio processador de texto, você pode querer fornecer um recurso para pesquisar ao longo do documento. O programa abaixo demonstra as muitas versões dos métodos indexOf e lastIndexOf de String que procuram um caracter ou um substring especificado em um String.
    Todas as pesquisas no exemplo a seguir, são feitas no String letters (inicializado com “abcdefghijklmabcdefghijklm”) no método main da classe StringIndexMethods.

// MetodosIndexString.java
// Este programa demonstra os métodos
// "index" da classe String.

// Pacotes de extensão de Java
import javax.swing.*;

public class MetodosIndexString {

 // Métodos de pesquisa em Strings
 public static void main( String args[] )
 {
 String letters = "abcdefghijklmabcdefghijklm";

 // testa indexOf para encontrar o próximo, a partir da posição indicada, caracter em um string
 String output = "'c' esta alocado no indice " +
 letters.indexOf( 'c' );

 output += "\n'a' esta alocado no indice " +
 letters.indexOf( 'a', 1 );

 output += "\n'$' esta alocado no indice " +
 letters.indexOf( '$' );

 // testa lastIndexOf para encontrar o último caracter em um string
 output += "\n\nUltimo 'c' esta alocado no indice " +
 letters.lastIndexOf( 'c' );

 output += "\nUltimo 'a' esta alocado no indice " +
 letters.lastIndexOf( 'a', 25 );

 output += "\nUltimo '$' esta alocado no indice " +
 letters.lastIndexOf( '$' );

 // testa indexOf para localizar o próximo, a partir da posição indicada, substring em um string
 output += "\n\n\"def\" esta alocado no indice " +
 letters.indexOf( "def" );

 output += "\n\"def\" esta alocado no indice " +
 letters.indexOf( "def", 7 );

 output += "\n\"alo\" is esta alocado no indice" +
 letters.indexOf( "alo" );

 // testa (lastIndexOf) para localizar o último substring em um string
 output += "\n\nUltimo \"def\" esta alocado no indice " +
 letters.lastIndexOf( "def" );

 output += "\nUltimo \"def\" esta alocado no indice " +
 letters.lastIndexOf( "def", 25 );

 output += "\nUltimo \"alo\" esta alocado no indice " +
 letters.lastIndexOf( "alo" );

 JOptionPane.showMessageDialog( null, output,
 "Demonstrando classe String Métodos \"index\" ",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

} // fim da classe MetodosIndexString

Método index

   

8. Extraindo substrings a partir de Strings
  
    A classe String fornece dois métodos substring para permitir que um novo objeto String     seja criado copiando parte de um objeto String existente.
    Cada método retorna um novo String  e ambos são demonstrados no programa a seguir.

// MetodoSubStringString.java
// Este programa demonstra os métodos
// substring da classe String.

// Pacotes de extensão de Java
import javax.swing.*;

public class MetodoSubStringString {

 // Métodos substring de Strings
 public static void main( String args[] )
 {
 String letters = "abcdefghijklmabcdefghijklm";

 // testa métodos substring
 String output = "Substring de índice 20 para o fim é " +
 "\"" + letters.substring( 20 ) + "\"\n";

 output += "Substring de índice 0 até 5 é " +
 "\"" + letters.substring( 0, 6 ) + "\"";

 JOptionPane.showMessageDialog( null, output,
 "Demonstrando MetodoSubStringString",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

} // Fim da classe MetodoSubStringString

Método substring

9. Concatenando Strings

    O método concat de String concatena dois objetos String e retorna um novo objeto String, que contém caracteres de ambos os Strings originais, sem que as mesmas sejam modificadas.
    O programa a seguir, demonstra o método concat, mostrando que a expressão     s1.concat( s2 ) acrescenta os caracteres do String s2 ao final do String s1. 

// MetodoConcatenaString.java
// Este programa demonstra o método concat da classe String.
// Note que o método concat retorna um objeto String novo.
// Ele não modifica o objeto que invocou o método concat.

// Pacotes de extensão de Java
import javax.swing.*;

public class MetodoConcatenaString {

 // testa o método concat da String
 public static void main( String args[] )
 {
 String s1 = new String( "Feliz " ),
 s2 = new String( "Aniversário" );

 String output = "s1 = " + s1 + "\ns2 = " + s2;

 output += "\n\nResultado de s1.concat( s2 ) = " +
 s1.concat( s2 ) ;

 output += "\n\ns1 depois de concatenado = " + s1;

 output += "\ns2 depois de concatenado = " + s2;

 JOptionPane.showMessageDialog( null, output,
 "Demonstrando o MetodoConcatenaString",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

} // fim da classe MetodoConcatenaString
Método concatena


    10. Métodos replace, toUpperCase, toLowerCase, trim, toString e toCharArray de String
    A classe String fornece vários métodos que retornam cópias modificadas de Strings ou que retornam um array de caracteres, permanecendo desta forma inalterado os Strings originais.
    Os métodos da classe String:

  • replace de String que retorna um novo objeto String no qual o método substitui cada ocorrência do caracter, primeiro parâmetro pelo segundo parâmetro;
  • toUpperCase de String que gera um novo objeto String, transformando as  letras minúsculas em letras maiúsculas; toLowerCase de String que gera um novo objeto String, transformando as letras maiúsculas em letras minúsculas;
  • trim de String que retorna um novo objeto String que contém o String sem caracteres de espaço em branco iniciais ou finais;
  • toString de String é fornecido na classe String para assegurar que o valor String adequado seja devolvido. Normalmente usa-se o método toString para representar o conteúdo de um objeto como texto;
  • toCharArray que contem uma cópia dos caracteres do String s1, criado em um novo array de caracteres e o atribui a charArray.
// MaiusMinusTrimString.java
// Este programa demonstra os métodos replace, toLowerCase,
// toUpperCase, trim, toStringe toCharArray de String

// Pacotes de extensão de Java
import javax.swing.*;

public class MaiusMinusTrimString {

 // testa os diversos métodos de String
 public static void main( String args[] )
 {
 String s1 = new String( "alo" ),
 s2 = new String( "TCHAU" ),
 s3 = new String( " espaços " );

 String output = "s1 = " + s1 + "\ns2 = " + s2 +
 "\ns3 = " + s3;

 // testa o método replace
 output += "\n\nTroca 'l' por 'L' em s1: " +
 s1.replace( 'l', 'L' );

 // testa os métodos toLowerCase e toUpperCase
 output +=
 "\n\ns1.toUpperCase() = " + s1.toUpperCase() +
 "\ns2.toLowerCase() = " + s2.toLowerCase();

 // testa o método trim
 output += "\n\ns3 after trim = \"" + s3.trim() + "\"";

 // testa o método toString
 output += "\n\ns1 = " + s1.toString();

 // testa o método toCharArray
 char charArray[] = s1.toCharArray();

 output += "\n\ns1 como um caracter array = ";

 for ( int count = 0; count < charArray.length; ++count )
 output += charArray[ count ];

 JOptionPane.showMessageDialog( null, output,
 "Demonstrando Diversos Metodos String",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

} // fim da classe MaiusMinusTrimString


Métodos maiusculo, minusculo e trim    

11. Utilizando o método valueOf de String
    A classe String fornece um conjunto de métodos de classe static que recebem argumentos de vários tipos, convertem esses argumentos em strings e os devolvem como objetos String. O exemplo de programa a seguir demonstra os métodos valueOf da classe String.

// MetodoValueOfString.java
// Este programa demonstra os métodos valueOf da classe String.

// Pacotes de extensão de Java
import javax.swing.*;

public class MetodoValueOfString {

 // testa métodoValueOf de String
 public static void main( String args[] )
 {
 char charArray[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
 boolean b = true;
 char c = 'Z';
 int i = 7;
 long l = 10000000;
 float f = 2.5f;
 double d = 33.333;

 Object o = "alo"; // atribui uma referência para Object
 String output;

 output = "char array = " + String.valueOf( charArray ) +
 "\nparte de char array = " +
 String.valueOf( charArray, 3, 3 ) +
 "\nboolean = " + String.valueOf( b ) +
 "\nchar = " + String.valueOf( c ) +
 "\nint = " + String.valueOf( i ) +
 "\nlong = " + String.valueOf( l ) +
 "\nfloat = " + String.valueOf( f ) +
 "\ndouble = " + String.valueOf( d ) +
 "\nObject = " + String.valueOf( o );

 JOptionPane.showMessageDialog( null, output,
 "Demonstrando MetodoValueOfString ",
 JOptionPane.INFORMATION_MESSAGE );

 System.exit( 0 );
 }

} // fim da classe MetodoValueOfString

Métodos valueOf


Autores: Carlos Fernando Gonçalves e Marli Esprega Gonçalves (Antares Information Systems)