INSTITUTO SUPERIOR DE TRANSPORTES E

COMUNICAÇÕES

LICENCIATURA EM ENGENHARIA INFORMÁTICA E DE

TELECOMUNICAÇÕES

LEIT 23

PROGRAMAÇÃO II

TEMA: STRING BUFFER & STRING TOKENIZER

Discentes:

Inácio Banyankindagiye
Shelcia Cindy da Ana Afonso Mathlombe
Yula da Nurcia Abel Muhal

Docente: Mujhahid Karim

Maputo, Maio 2023

Índice
1. Introdução ................................................................................................................. 3

2. String Buffer ............................................................................................................. 3

2.1. Construtores importantes da classe StringBuffer ............................................. 3

3. String Tokenizer ........................................................................................................ 5

3.1. Construtores da String Tokenizer ..................................................................... 5

3.2. Métodos da classe StringTokenizer ....................................................................... 6

4. Exercício de aplicação usando as classes String Buffer e String Tokenizer ............ 6

4.1. Método PalavraCapitalizada() ............................................................................ 7

4.2. Método main() .................................................................................................... 8

5. Conclusão .................................................................................................................. 9
1. Introdução
Neste presente trabalho de investigação, iremos abordar os conceitos de StringBuffer e
StringTokenizer, que são classes do Java usados para armazenar e manipular Strings e
quebrar as Strings em Tokens.

Além de abordar os conceitos de StringBuffer e StringTokenizer, faremos um exercício de

aplicação que envolve as classes StringBuffer e StringTokenizer em Java.

2. String Buffer
StringBuffer é uma classe em Java que representa uma sequência mutável de caracteres. Ele
fornece uma alternativa para a classe String imutável, permitindo que você modifique o
conteúdo de uma string sem criar um novo objeto toda vez.

Aqui estão alguns recursos e métodos importantes da classe StringBuffer:

A capacidade inicial de um StringBuffer pode ser especificada quando ele é criado ou pode
ser definida posteriormente com o método ensureCapacity().

O método append() é usado para adicionar caracteres, strings ou outros objetos ao final do
buffer.

O método insert() é usado para inserir caracteres, strings ou outros objetos em uma posição
especificada no buffer.

O método delete() é usado para remover caracteres do buffer.

O método reverse() é usado para inverter a ordem dos caracteres no buffer.

2.1. Construtores importantes da classe StringBuffer

StringBuffer(): cria um buffer de string vazio com capacidade inicial de 16.

StringBuffer(String str): cria um buffer de string com a string especificada.

StringBuffer (capacidade int): cria um buffer de string vazio com a capacidade

especificada como comprimento.
  Método append(): O método append() concatena o argumento dado com esta
string.
 Método replace(): O método replace() substitui a string fornecida do beginIndex e
endIndex-1 especificados.
 Método delete(): O método delete() da classe StringBuffer exclui a string do
beginIndex especificado para o endIndex-1.
 Método reverse(): O método reverse() da classe StringBuilder inverte a string
atual.
 Método capacidade(): O método capacidade() da classe StringBuffer retorna a
capacidade atual do buffer. A capacidade padrão do buffer é 16. Se o número de
caracteres aumentar de sua capacidade atual, ele aumentará a capacidade em
(oldcapacity*2)+2.

Por exemplo, se sua capacidade atual for 16, será (16*2)+2=34.

O java.lang.StringBuffer estende (ou herda) a classe Object .

Todas as interfaces implementadas da classe StringBuffer: Serializable, Appendable,

CharSequence.

public final class StringBuffer extends Object implementa Serializable, CharSequence,

Appendable.

Os buffers de string são seguros para uso por vários threads. Os métodos podem ser
sincronizados sempre que necessário para que todas as operações em qualquer instância
particular se comportem como se ocorressem em alguma ordem serial.

Sempre que ocorre uma operação envolvendo uma sequência de origem (como anexar ou
inserir de uma sequência de origem), essa classe sincroniza apenas no buffer de string que
executa a operação, não na origem.

Ele herda alguns dos métodos da classe Object, como clone(), equals(), finalize(),
getClass(), hashCode(), notifications() , notifyAll().
3. String Tokenizer

Classe StringTokenizer em Java é usado para quebrar uma string em tokens. Um objeto
StringTokenizer mantém internamente uma posição atual dentro da string a ser tokenizada.

Algumas operações avançam esta posição atual além dos caracteres processados. Um token
é retornado tomando uma substring da string que foi usada para criar o objeto
StringTokenizer.

Ele fornece a primeira etapa no processo de análise, muitas vezes chamado de lexer ou
scanner. A classe String Tokenizer permite que um aplicativo divida strings em tokens. Ele
implementa a interface Enumeration.

Essa classe é usada para analisar dados. Para usar a classe String Tokenizer, temos que
especificar uma string de entrada e uma string que contém delimitadores. Os delimitadores
são os caracteres que separam os tokens.

Cada caractere na string delimitadora é considerado um delimitador válido. Os

delimitadores padrão são espaços em branco, nova linha, espaço e tabulação.

Ilustração:

3.1. Construtores da String Tokenizer

Vamos considerar “str” como a string a ser tokenizada.

StringTokenizer(String str): É o delimitador padrão como nova linha, espaço, tabulação,

retorno de carro e alimentação de formulário.

StringTokenizer(String str, String delim): O delim é um conjunto de delimitadores que

são usados para tokenizar a string fornecida.

StringTokenizer(String str, String delim, boolean flag): Os dois primeiros parâmetros

têm o mesmo significado em que o sinalizador serve para o seguinte propósito.

Se o sinalizador for falso, os caracteres delimitadores servem para separar os tokens

Exemplo:
Entrada: se string  "hello world" e Delimiter for " ", então

Output: os tokens serão "hello" e "world".

Se o sinalizador for verdadeiro, os caracteres delimitadores são considerados tokens.

Exemplo 2:

Entrada: String  é "hello world " e Delimiter é " ", então

Output: Tokens  "hello", " " e "world".

Múltiplos delimitadores podem ser escolhidos para uma única string.

Exemplo 3:

Sintaxe:

StringTokenizer st1 = new StringTokenizer( "2+3-1*8/4", "+*-/");

Entrada: String  é "2+3-1*8/4" e os Delimitadores são “+”, “*”, “-” , “/” .

Saída: Tokens  "2","3","1","8", "4".

3.2. Métodos da classe StringTokenizer

 countTokens(): Retorna o número total de tokens presentes.

 hasMoreToken(): Testa se os tokens estão presentes para a string do
StringTokenizer.
 NextElement(): Retorna um Object em vez de String.
 hasMoreElements(): Retorna o mesmo valor que hasMoreToken.
 nextToken(): Retorna o próximo token do StringTokenizer fornecido.

4. Exercício de aplicação usando as classes String Buffer e

String Tokenizer
1. Escreva um método chamado PalavraCapitalizada() que irá imprimir a versão
capitalizada de uma frase que está em um ficheiro.
 Teste o seu método com o método main().

4.1. Método PalavraCapitalizada()

package Trabalho;

import java.util.StringTokenizer;

import java.io.*;

public class PalavraCapitalizada {

public static void capitalize(String nomeficheiro) {

try {

File file = new File(nomeficheiro);

if (!file.exists()) {

System.out.println("Ficheiro não existe!");

return;

BufferedReader reader = new BufferedReader(new FileReader(nomeficheiro));

String line = null;

String textoFinal = "";

while ((line = reader.readLine()) != null) {

StringTokenizer tokenizer = new StringTokenizer(line);

StringBuffer buffer = new StringBuffer();

while (tokenizer.hasMoreTokens()) {

String word = tokenizer.nextToken();

buffer.append(Character.toUpperCase(word.charAt(0)))

.append(word.substring(1))
 .append(" ");

System.out.println(buffer.toString().trim());

textoFinal = buffer.toString();

reader.close();

BufferedWriter writer = new BufferedWriter(new FileWriter(nomeficheiro));

writer.write(textoFinal);

writer.close();

} catch (Exception e) {

e.printStackTrace();

4.2. Método main()

package Executar;

import Trabalho.PalavraCatalizada;

public class Executar extends PalavraCatalizada {

public static void main(String[] args) {

capitalize("test.txt");

}
 Figura 1: A frase sem ser capitalizada.

Figura 2: A frase após ser capitalizada.

5. Conclusão
Neste presente trabalho de investigação concluímos que o StringBuffer e o String Tokenizer
são os métodos mais adequados para a manipulação das Strings, uma vez que elas possuem
a facilidade de armazenar Strings e quebrar as Strings em Tokens.

Fazendo assim com que o programador na hora de criar um código, não gaste nenhum
esforço para criar métodos e vetores para guardar enormes quantidades de Strings e separar
as Strings em Tokens.