Todos os tipos utilizados na linguagem Java, com exceção dos tipos primitivos (int, double, char e boolean), são "objetos". O tipo String, com S maiúsculo, é um dos objetos mais utilizados.
Ao contrário que ocorre em C e C++, strings em Java não são tratadas como sequências de caracteres terminadas por NULL. São objetos ou instâncias da classe java.lang.String, portanto, devem ser declarados e instanciados. Por exemplo:
// declaração
String ola;
// instanciação
ola = new String(Alô Mundo Java !");
// declaração e instanciação (mais prático)
String ola = "Alô Mundo Java !";
String nome = "Prof. Omero Francisco Bertol.";
// concatenação (\n = pula linha)
String aula = ola + "\nby " + nome;
System.out.println(aula);
// resultado
Alô Mundo Java !
by Prof. Omero Francisco Bertol.
Em resumo, as strings correspondem a uma sequência (ou cadeia) de caracteres ASCII delimitados por aspas duplas, que são armazenadas em "instâncias" da classe String. A Tabela ASCII (American Standard Code for Information Interchange) é usada pela maior parte da indústria de computadores para a troca de informações.
Cada caractere na tabela ASCII estendida é representado por um código de 8 bits. Um byte = 28 = 256 caracteres, assim distribuídos: | ||
0 | 31 | Caracteres de Controle (esc e enter, por exemplo) |
32 | 127 | ASCII Normal (caracteres numéricos e alfabéticos, por exemplo) |
128 | 255 | ASCII Estendida |
Decimal |
Caractere |
Decimal |
Caractere |
Decimal |
Caractere |
48 |
0 |
65 |
A |
97 |
a |
49 |
1 |
66 |
B |
98 |
b |
50 |
2 |
67 |
C |
99 |
c |
51 |
3 |
68 |
D |
100 |
d |
52 |
4 |
69 |
E |
101 |
e |
53 |
5 |
70 |
F |
102 |
f |
54 |
6 |
71 |
G |
103 |
g |
55 |
7 |
72 |
H |
104 |
h |
56 |
8 |
73 |
I |
105 |
i |
57 |
9 |
74 |
J |
106 |
j |
|
|
75 |
K |
107 |
k |
Observação: a posição de qualquer caractere alfabético subtraída pela posição do seu respectivo caractere alfabético maiúsculo ou minúsculo sempre resulta no valor ±32. |
76 |
L |
108 |
l |
|
77 |
M |
109 |
m |
||
78 |
N |
110 |
n |
||
79 |
O |
111 |
o |
||
80 |
P |
112 |
p |
||
81 |
Q |
113 |
q |
||
82 |
R |
114 |
r |
||
83 |
S |
115 |
s |
||
84 |
T |
116 |
t |
||
85 |
U |
117 |
u |
||
86 |
V |
118 |
v |
||
87 |
W |
119 |
w |
||
88 |
X |
120 |
x |
||
89 |
Y |
121 |
y |
||
90 |
Z |
122 |
z |
Usando a posição de um determinado caractere na tabela ASCII é possível realizar algumas implementações importantes, por exemplo:
a) caractere alfabético maiúsculo + 32, expressão que define como resultado o respectivo caractere minúsculo: 'A' + 32 ---> 'a'
b) caractere alfabético minúsculo - 32, expressão que define como resultado o respectivo caractere maiúsculo: 'a' - 32 ---> 'A'
c) caractere numérico - 48, expressão que define como resultado o respectivo valor inteiro: '0' - 48 ---> 0
d) os caracteres numéricos e alfabéticos estão colocados em ordem na tabela e portanto pode-se usar esta relação em instruções de repetição como é desmonstrado na aplicação Java da Listagem 1:
public class String1 {
public static void main(String[] args) {
int i;
// o especificador de formato para caractere (%c)
// mostra o i-ésimo caractere da tabela ASCII
System.out.printf("Caracteres numéricos:\n");
for (i=48; i<=57; i++) {
System.out.printf("%c", i);
}
System.out.printf("\n\nCaracteres alfabéticos maiúsculos:\n");
for (i=65; i<=90; i++) {
System.out.printf("%c", i);
}
System.out.printf("\n\nCaracteres alfabéticos minúsculos:\n");
for (i=97; i<=122; i++) {
System.out.printf("%c", i);
}
System.out.printf("\n");
}
}
Listagem 1 - Mostrando os caracteres numéricos e alfabéticos usando a posição do caractere na tabela ASCII.
d) operações matemáticas com os caracteres numéricos são exemplificadas na aplicação Java da Listagem 2:
public class String2 {
public static void main(String[] args) {
char c;
int n;
// os caracteres são tipos ordinais, portanto, podem
// ser usados no controle de instruções de repetição
for (c='0'; c<='9'; c++) {
// converte o caractere numérico no respectivo valor inteiro
n = c - 48;
System.out.printf("%d X 10 = %d\n", n, (n * 10));
}
}
}
Listagem 2 - Realizando operações matemáticas com os caracteres numéricos.
Para obter uma String deve-se utilizar o método "nextLine" da classe Scanner. Já para efetuar a leitura de um caractere, delimitado entre aspas simples, deve-se utilizar o método "read" do pacote de classes System.in como pode ser observado na aplicação Java da Listagem 3:
import java.io.IOException;
import java.util.Scanner;
public class String3 {
// através da claúsula throws indicamos que não iremos
// tratar possíveis erros na entrada de dados realizada
// através do método "read" do pacote de classes System.in
public static void main(String[] args) throws IOException {
Scanner ler = new Scanner(System.in);
String nome;
char sexo;
System.out.printf("Informe um nome:\n");
nome = ler.nextLine();
System.out.printf("\nInforme o sexo (M/F):\n");
sexo = (char)System.in.read();
if ((sexo == 'M') || (sexo == 'm'))
System.out.printf("\nSeja bem-vindo Sr. %s.\n", nome);
else System.out.printf("\nSeja bem-vinda Sra. %s.\n", nome);
}
}
Listagem 3 - Efetuando a entrada de dados de tipos String e caractere.
A classe String em Java possui mais de 50 métodos que serão principalmente abordados no próximo artigo. Agora será apresentada a utilização dos métodos:
- int length(): Retorna o tamanho da string, ou seja, a quantidade de caracteres da string;
- char charAt(int i): Retorna o i-ésimo caractere da string. Obs: assim como nos vetores a posição do primeiro caractere de uma string é igual a 0 (zero).
Processando um caractere de uma String:
variável String e contadores:
String s;
int ctmaius = 0, ctminus = 0, ctalfa = 0;
int ctnum = 0, cta = 0, ctbit = 0, ctespaco = 0;
int cta = 0, cte = 0, cti = 0, cto = 0, ctu = 0;
int ctcons = 0;
s.charAt(i) ---> indica o i-ésimo caractere da cadeia "s".
1) verificando se é um caractere alfabético maiúsculo:
if ((s.charAt(i) >= 'A') && (s.charAt(i) <= 'Z'))
ctmaius = ctmaius + 1;
2) verificando se é um caractere alfabético minúsculo:
if ((s.charAt(i) >= 'a') && (s.charAt(i) <= 'z'))
ctminus = ctminus + 1;
3) verificando se é um caractere alfabético:
if (((s.charAt(i) >= 'A') && (s.charAt(i) <= 'Z')) ||
((s.charAt(i) >= 'a') && (s.charAt(i) <= 'z')))
ctalfa = ctalfa + 1;
4) verificando se é um caractere numérico:
if ((s.charAt(i) >= '0') && (s.charAt(i) <= '9'))
ctnum = ctnum + 1;
5) verificando se é a vogal 'a':
if ((s.charAt(i) == 'A') || (s.charAt(i) == 'a'))
cta = cta + 1;
6) verificando se é um bit ('0' ou '1'):
if ((s.charAt(i) == '0') || (s.charAt(i) == '1'))
ctbit = ctbit + 1;
7) verificando se é o espaço em branco:
if (s.charAt(i) == ' ')
ctespaco = ctespaco + 1;
8) verificando as vogais separadamente:
if ((s.charAt(i) == 'A') || (s.charAt(i) == 'a'))
cta = cta + 1;
else if ((s.charAt(i) == 'E') || (s.charAt(i) == 'e'))
cte = cte + 1;
else if ((s.charAt(i) == 'I') || (s.charAt(i) == 'i'))
cti = cti + 1;
else if ((s.charAt(i) == 'O') || (s.charAt(i) == 'o'))
cto = cto + 1;
else if ((s.charAt(i) == 'U') || (s.charAt(i) == 'u'))
ctu = ctu + 1;
9) verificando se é uma consoante (caractere alfabético que não é vogal):
if (((s.charAt(i) >= 'A') && (s.charAt(i) <= 'Z')) ||
((s.charAt(i) >= 'a') && (s.charAt(i) <= 'z'))) {
if ((s.charAt(i) != 'A') && (s.charAt(i) != 'a') &&
(s.charAt(i) != 'E') && (s.charAt(i) != 'e') &&
(s.charAt(i) != 'I') && (s.charAt(i) != 'i') &&
(s.charAt(i) != 'O') && (s.charAt(i) != 'o') &&
(s.charAt(i) != 'U') && (s.charAt(i) != 'u')) {
ctcons = ctcons + 1;
}
}
Algumas destas nove operações com caracteres de uma string poderão ser simplificadas utilizando os métodos da classe Character que serão abordados no próximo artigo. Na Listagem 4 pode-se observar uma aplicação Java que processa os caracteres de uma string:
import java.util.Scanner;
public class String4 {
public static void main(String[] args) {
Scanner ler = new Scanner(System.in);
String s;
int i, n, cta = 0;
System.out.printf("Informe uma string:\n");
s = ler.nextLine();
System.out.println();
n = s.length(); // tamanho da string
for (i=0; i<n; i++) {
// verifica se o i-ésimo caractere é a vogal 'a'
if ((s.charAt(i) == 'A') || (s.charAt(i) == 'a')) {
cta = cta + 1;
System.out.printf("%c ---> %do. caractere 'a'\n", s.charAt(i), cta);
}
else System.out.printf("%c\n", s.charAt(i));
}
}
}
Listagem 4 - Contando o número de vezes que vogal 'a' foi encontrada na string.
Ilustrando a execução das aplicações:
Listagem 1:
Listagem 2:
Listagem 3:
Listagem 4:
Parte 2 - Métodos da classe String
A aplicação Java apresentada na Listagem 1 mostra como converter os caracteres de uma string para maiúsculos e minúsculos realizando estas operações usando a relação existente entre os caracteres alfabéticos na tabela ASCII:
a) caractere alfabético maiúsculo + 32, expressão que define como resultado o respectivo caractere minúsculo;
b) caractere alfabético minúsculo - 32, expressão que define como resultado o respectivo caractere maiúsculo.
import java.util.Scanner;
public class String5 {
public static void main(String[] args) {
Scanner ler = new Scanner(System.in);
String s, maius, minus;
char c;
int i, n;
System.out.printf("Informe uma string:\n");
s = ler.nextLine();
n = s.length(); // tamanho da string
maius = ""; // string convertida em maiúsculas
minus = ""; // string convertida em minúsculas
for (i=0; i<n; i++) {
c = s.charAt(i);
// verifica se o i-ésimo caractere é alfabético minúsculo
if ((c >= 'a') && (c <= 'z'))
// converte o i-ésimo caractere no correspondente maiúsculo
maius = maius + (char)(c - 32);
else maius = maius + c;
// verifica se o i-ésimo caractere é alfabético maiúsculo
if ((s.charAt(i) >= 'A') && (s.charAt(i) <= 'Z'))
// converte o i-ésimo caractere no correspondente minúsculo
minus = minus + (char)(c + 32);
else minus = minus + c;
}
System.out.printf("\nResultado:\n");
System.out.printf("%s\n%s\n", maius, minus);
}
}
Listagem 1 - Convertendo uma string em maiúsculas e minúsculas caractere por caractere.
A classe String em Java possui mais de 50 métodos que simplificam a programação demonstrada na Listagem 1, entre eles destancam-se:
char |
charAt(inti) |
Retorna o i-ésimo caractere da string.Obs:assim como nos vetores a posição do primeiro caractere de uma string é igual a 0 (zero). |
|
String |
concat(Strings) |
Retorna uma string com os caracteres deste objeto concatenados (no final) com os caracteres do argumento "s". |
|
boolean |
contains(Strings) |
Retorna verdadeiro se a sequência de caracteres do argumento "s" existe no objeto e falso caso contrário. |
|
boolean |
equal(Strings) |
Retorna true se as strings forem "exatamente" iguais. |
|
boolean |
equalIgnoreCase(Strings) |
Retorna true se as strings forem iguais (ignorando na comparação se os caracteres são maiúsculos ou minúsculos). |
|
int |
indexOf(intch) |
Retorna o índice dentro da sequência de caracteres da primeira ocorrência do caractere especificado (ch). O valor -1 como retorno indica que não existe uma ocorrência. |
|
int |
indexOf(Strings) |
Retorna o índice dentro da sequência de caracteres da primeira ocorrência da substring especificada (s). O valor -1 como retorno indica que não existe uma ocorrência. |
|
int |
lastIndexOf(intch) |
Retorna o índice dentro da sequência de caracteres da última ocorrência do caractere especificado (ch). O valor -1 como retorno indica que não existe uma ocorrência. |
|
int |
lastIndexOf(Strings) |
Retorna o índice dentro da sequência de caracteres da última ocorrência da substring especificada (s). O valor -1 como retorno indica que não existe uma ocorrência. |
|
int |
length() |
Retorna o tamanho da string, ou seja, a quantidade de caracteres da string. |
|
String |
toLowerCase() |
Retorna a string com os caracteres convertidos em "minúsculos". |
|
String |
toUpperCase() |
Retorna a string com os caracteres convertidos em "maiúsculas". |
|
String |
trim() |
Retorna a string com os espaços em branco do início e do final da cadeia removidos. |
|
String |
replace(charoldChar,charnewChar) |
Retorna a string resultante da troca de "todas" as ocorrências do caractere "oldChar" pelo caractere "newChar". |
|
String |
substring(intini,intfim) |
Retorna a "substring" da string definida a partir da posição "ini" até a posição "fim-1". |
|
staticString |
valueOf(doubled) |
Retorna a representação string do argumento double. |
|
staticString |
valueOf(floatf) |
Retorna a representação string do argumento float. |
|
staticString |
valueOf(inti) |
Retorna a representação string do argumento int. |
|
staticString |
valueOf(longl) |
Retorna a representação string do argumento long. |
Veja a documentação completa da classe String em: http://download.oracle.com/javase/1.5.0/docs/api/java/lang/String.html
A aplicação Java apresentada na Listagem 2 mostra como converter os caracteres de uma string para maiúsculos e minúsculos usando os método toUpperCase() e toLowerCase(), respectivamente.
import java.util.Scanner;
public class String6 {
public static void main(String[] args) {
Scanner ler = new Scanner(System.in);
String s, maius, minus;
System.out.printf("Informe uma string:\n");
s = ler.nextLine();
maius = s.toUpperCase(); // string convertida em maiúsculas
minus = s.toLowerCase(); // string convertida em minúsculas
System.out.printf("\nResultado:\n");
System.out.printf("%s\n%s\n", maius, minus);
}
}
Listagem 2 - Convertendo uma string em maiúsculas e minúsculas usando os métodos da classe String.
A aplicação Java apresentada na Listagem 3 exemplifica a utilização dos métodos length(), equalsIgnoreCase() e charAt().
import java.util.Scanner;
public class String7 {
public static void main(String[] args) {
Scanner ler = new Scanner(System.in);
String s;
int i, j, n;
while (true) {
System.out.printf("Informe uma String, FIM para encerrar:\n");
s = ler.nextLine();
// compara a string informada pelo usuário com a palavra FIM ignorando
// na comparação se os caracteres são maiúsculos ou minúsculos
if (s.equalsIgnoreCase("FIM"))
break;
System.out.printf("\n");
n = s.length(); // tamanho da string (qtde de caracteres)
for (i=0; i<n; i++) {
// a cada linha mostra 'i' caracteres
for (j=0; j<=i; j++) {
// mostra o j-ésimo caractere de 's'
System.out.printf("%c", s.charAt(j));
}
System.out.printf("\n");
}
System.out.printf("\n");
}
}
}
Listagem 3 - Exibindo os caracteres de uma string.
A aplicação Java apresentada na Listagem 4 exemplifica a utilização dos métodos lastIndexOf() e substring().
import java.util.Scanner;
public class String8 {
public static void main(String[] args) {
Scanner ler = new Scanner(System.in);
String nome, sobrenome;
int i;
System.out.printf("Informe um nome:\n");
nome = ler.nextLine();
// retorna a posição da última ocorrência do espaço em branco
// na string 'nome', ou seja, o sobrenome é a última parte de um nome
i = nome.lastIndexOf(' ');
sobrenome = nome.substring(i+1, nome.length());
System.out.printf("\nSobrenome:\n%s\n", sobrenome);
}
}
Listagem 4 - Fornecendo como resultado o sobrenome de uma pessoa.
Ilustrando a execução das aplicações:
Listagem 1:
Listagem 2:
Listagem 3:
Listagem 4:
Referência:
Peter Jandl Junior. Introdução ao Java. São Paulo: Berkeley - 2002.