SEGUNDA SESIÓN CADENAS Y CARACTERES 2019

LA CLASE STRINGBUILDER

Una vez que se crea un objeto String, su contenido ya no puede variar. Ahora hablaremos sobre las
características de la clase StringBuilder para crear y manipular información de cadenas dinámicas;
es decir, cadenas que pueden modificarse. Cada objeto StringBuilder es capaz de almacenar varios
caracteres especificados por su capacidad. Si se excede la capacidad de un objeto StringBuilder, ésta
se expande de manera automática para dar cabida a los caracteres adicionales. La clase
StringBuilder también se utiliza para implementar los operadores + y += para la concatenación de
objetos String.

MÉTODOS LENGTH, CAPACITY, SETLENGTH Y ENSURECAPACITY DE STRINGBUILDER

El método ensureCapacity se usa para expandir la capacidad del objeto StringBuilder a un mínimo
de 75 caracteres. En realidad, si la capacidad original es menor que el argumento, este método
asegura una capacidad que sea el valor mayor entre el número especificado como argumento, y el
doble de la capacidad original más 2. Si la capacidad actual del objeto StringBuilder es más que la
capacidad especificada, la capacidad del objeto StringBuilder permanece sin cambios.

public class Cadenas_StringBuilder {

public static void main(String[] args) {

StringBuilder bufer = new StringBuilder("Hola, como estas?");

StringBuilder bufer1=new StringBuilder();

String cadena="Java";

//length: devuelve el número actual de caracteres en un objeto StringBuilder

//capacity para devuelve el número de caracteres que pueden almacenarse en un objeto

StringBuilder sin necesidad de asignar más memoria

//el constructor de StringBuilder que recibe un argumento String inicializa la capacidad con la
longitud de la cadena que se le pasa como argumento, más 16.

System.out.println("bufer = " + bufer.toString() + "\n" + "Longitud = " + bufer.length() + "\n" +

"Capacidad = " + bufer.capacity());

//ensureCapacity: garantiza que un StringBuilder tenga, cuando menos, la capacidad

especificada. Expande la capacidad del objeto StringBuilder a un mínimo de 75 caracteres.

bufer.ensureCapacity(75);

System.out.println("Nueva capacidad = " + bufer.capacity());

//se utiliza el método setLength para establecer la longitud del objeto StringBuilder en 10

1
 //El método setCharAt() recibe un entero y un carácter como argumentos y asigna al carácter
en la posición especifi cada

//en el objeto StringBuilder el carácter que recibe como argumento.

bufer.setCharAt(16, '!');

bufer.setCharAt(4, '.');

System.out.println("setCharAt():" + bufer.toString());

bufer.setLength(10);

System.out.println("Nueva longitud = " + bufer.length() + "\n" + bufer.toString());

//El método reverse invierte el contenido del objeto StringBuilder.

bufer.reverse();

System.out.println("reverse= " + bufer.toString());

//La clase StringBuilder proporciona métodos append sobrecargados, Cada uno de los métodos
recibe su argumento, lo convierte en una cadena y lo anexa al objeto String-

//Builder

bufer1.append(cadena);

System.out.println( "bufer1 contiene = "+ bufer1.toString() );

//El método delete recibe dos argumentos: el índice inicial y el índice

//que se encuentra una posición más allá del último de los caracteres que se van a eliminar. Se
eliminan todos los

//caracteres que empiezan en el índice inicial hasta, pero sin incluir al índice final.

bufer.delete( 6, 10 );

System.out.println("delete= " + bufer.toString());

//El método deleteCharAt recibe un argumento: el índice del carácter a eliminar.

bufer.deleteCharAt( 5 );

System.out.println("reverse= " + bufer.toString());

SALIDA:

bufer = Hola, como estas?

Longitud = 17
Capacidad = 33
Nueva capacidad = 75

2
setCharAt():Hola. como estas!
Nueva longitud = 10
Hola. como
reverse= omoc .aloH
bufer1 contiene = Java
delete= omoc .
reverse= omoc

LA CLASE STRINGTOKENIZER

Cuando usted lee una oración, su mente la divide en tokens (palabras individuales y signos de
puntuación, cada uno de los cuales transfiere a usted su significado). Los compiladores también
llevan a cabo la descomposición de instrucciones en piezas individuales tales como palabras clave,
identificadores, operadores y demás elementos de un lenguaje de programación. Ahora
estudiaremos la clase StringTokenizer de Java (del paquete java.util), la cual descompone una
cadena en los tokens que la componen. Los tokens se separan unos de otros mediante
delimitadores, que generalmente son caracteres de espacio en blanco tales como los espacios,
tabuladores, nuevas líneas y retornos de carro. También pueden utilizarse otros caracteres como
delimitadores para separar tokens.

Cuando el usuario oprime Intro, el enunciado de entrada se almacena en la variable enunciado. En

la línea 17 se crea un objeto StringTokenizer para enunciado. El constructor de StringTokenizer
recibe un argumento de cadena y crea un objeto StringTokenizer para esa cadena, utilizando la
cadena delimitadora predeterminada "\t\n\r\f" que consiste en un espacio, un tabulador, un
retorno de carro y una nueva línea, para la descomposición en tokens.

Hay otros dos constructores para la clase StringTokenizer. En la versión que recibe los argumentos
String, el segundo String es la cadena delimitadora. En la versión que recibe tres argumentos, el
segundo String es la cadena delimitadora y el tercer argumento (boolean) determina si los
delimitadores también se devuelven como tokens (sólo si este argumento es true). Esto es útil si
usted necesita saber cuáles son los delimitadores.

El método countTokens de StringTokenizer para determinar el número de tokens en la cadena que

se va a descomponer en tokens. La condición con el método hasMoreTokens de StringTokenizer
para determinar si hay más tokens en la cadena que va a descomponerse. De ser así, se imprime el
siguiente token en el objeto String. El siguiente token se obtiene mediante una llamada al método
nextToken de StringTokenizer, el cual devuelve un objeto String. El token se imprime mediante el
uso de println, de manera que los siguientes tokens aparezcan en líneas separadas.

Si desea cambiar la cadena delimitadora mientras descompone una cadena en tokens, puede
hacerlo especificando una nueva cadena delimitadora en una llamada a nextToken, como se
muestra a continuación:

tokens.nextToken( nuevaCadenaDelimitadora );

import java.util.Scanner;

3
import java.util.StringTokenizer;

public class cadenas_StringTokenizer {

public static void main(String[] args) {

// obtiene el enunciado:

Scanner scanner = new Scanner(System.in);

System.out.println("Escriba un enunciado y oprima Intro");

//Cuando el usuario oprime Intro, el enunciado de entrada se almacena en la variable

enunciado.

String enunciado = scanner.nextLine();

// Procesa el enunciado del usuario

StringTokenizer tokens = new StringTokenizer(enunciado);

//el método countTokens de StringTokenizer para determinar el número de tokens en la

cadena que se va a descomponer en tokens

System.out.println("Numero de elementos: Los tokens son: "+ tokens.countTokens());

//método hasMoreTokens de StringTokenizer se usa para determinar si hay más tokens en la

cadena que va a descomponerse.

//El siguiente token se obtiene mediante una llamada al método nextToken de

StringTokenizer, el cual devuelve un objeto String

while (tokens.hasMoreTokens()) {

System.out.println(tokens.nextToken());

SALIDA:

Escriba un enunciado y oprima Intro

Hola como estas
Numero de elementos: Los tokens son: 3
Hola
como
4
estas