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:
ilustração da listagem 1

Listagem 2:
ilustração da listagem 2

Listagem 3:
ilustração da listagem 3

Listagem 4:
ilustração da 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:
ilustração da listagem 1

Listagem 2:
ilustração da listagem 2

Listagem 3:
ilustração da listagem 3

Listagem 4:
ilustração da listagem 4

Referência:
Peter Jandl Junior. Introdução ao Java. São Paulo: Berkeley - 2002.