Tutorial Java - StringBuffer

Introdução

Uma vez criado um objeto String, seu conteúdo nunca é alterado. A classe StringBuffer cria e manipula informações em Strings dinâmicos, ou seja, Strings que podem ser modificados. Se a capacidade de um StringBuffer for excedida, a capacidade automaticamente é expandida para acomodar os caracteres adicionais.

Roteiro

StringBuffer;
Métodos length, capacity, setLength e ensureCapacity de StringBuffer;
Métodos SetCharAt, getChars e reverse de StringBuffer;
Métodos append da classe StringBuffer;
Métodos de inserção e de exclusão de StringBuffer;
Classes para tipos primitivos;
Classe StringTokenizer.

1. StringBuffer

A classe StringBuffer também é utilizada na implementação de operadores + e += para concatenação de Strings. O construtor default StringBuffer para criar um StringBuffer sem nenhum caracter e com uma capacidade inicial de 16 caracteres; o construtor StringBuffer que recebe um argumento inteiro para criar um StringBuffer sem caracteres e com a capacidade inicial especificada no argumento inteiro e o construtor StringBuffer que recebe um String como argumento, para criar um StringBuffer que contem os caracteres do argumento String

A capacidade inicial é o número de caracteres no argumento String mais 16. O programa a seguir, demonstra os três construtores e utiliza o método toString de StringBuffer para converter os StringBuffers em objetos String que podem ser exibidos com drawString.

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

String

O 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.

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

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.

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:

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:

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

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

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

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

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

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