Clases para procesamiento de cadenas de caracteres

Andrés camilo Sánchez campo

Presentado a: José Palacio

BARRANQUILLA ATLANTICO

octubre de 2019
Contenido
Introducción ....................................................................................................................... 3
class String ........................................................................................................................ 3
Constructores class string: ............................................................................................. 5
Métodos más utilizados class String ............................................................................... 6
Class StringBuffer .............................................................................................................. 7
Constructores class StringBuffer .................................................................................... 8
Métodos más utilizados .................................................................................................. 8
Class StringBuilder ............................................................................................................ 9
Constructores: .............................................................................................................. 10
Métodos más utilizados: ............................................................................................... 11
Class StringJoiner............................................................................................................ 12
Constructor:.................................................................................................................. 12
Métodos más usados: .................................................................................................. 12
Class StringTokenizer ...................................................................................................... 13
Constructor:.................................................................................................................. 15
Métodos mas utilizados: ............................................................................................... 15
Diferencias entre las clases String, StringBuffer y StringBuilder....................................... 16
Finalidad de las clases StringJoiner y StringTokenizer .................................................... 17
Conclusiones: .................................................................................................................. 17
Bibliografía ....................................................................................................................... 18
Introducción

A continuación, estudiaremos las clases para procesamiento de cadenas de caracteres,

Una cadena es una secuencia de caracteres, las cadenas son muy fundamentales en la

mayoría de los programas, actualmente existen varias clases para la manipulación de

cadenas por ejemplo la clase String es la representación como objeto de una matriz de

caracteres que no se puede cambiar. Hay una clase que la acompaña, llamada

StringBuffer, que se utiliza para crear cadenas que pueden ser manipuladas después de

ser creadas también veremos las clases StringBuilder, StringJoiner y la clase

StringTokenizer

class String

La Stringclase representa cadenas de caracteres. Todos los literales de cadena en

programas Java, como "abc", se implementan como instancias de esta clase.

Las cuerdas son constantes; sus valores no se pueden cambiar después de que
se crean. Los amortiguadores de cadena admiten cadenas mutables. Como los
objetos de cadena son inmutables, se pueden compartir. Por ejemplo:

String str = "abc"; // es equivalente a:

datos de char [] = {'a', 'b', 'c'};

String str = nueva cadena (datos);

Aquí hay algunos ejemplos más de cómo se pueden usar las cadenas:
 System.out.println ("abc");

Cadena cde = "cde";

System.out.println ("abc" + cde);

Cadena c = "abc" .substring (2,3);

Cadena d = cde.substring (1, 2);

La clase Stringincluye métodos para examinar caracteres individuales de la

secuencia, para comparar cadenas, para buscar cadenas, para extraer
subcadenas y para crear una copia de una cadena con todos los caracteres
traducidos a mayúsculas o minúsculas. La asignación de casos se basa en la
versión estándar Unicode especificada por la Characterclase.

El lenguaje Java proporciona soporte especial para el operador de concatenación

de cadenas (+) y para la conversión de otros objetos a cadenas. La concatenación
de cadenas se implementa a través de la clase StringBuilder(o StringBuffer) y su
appendmétodo. Las conversiones de cadenas se implementan a través del
método toString, definido Objecty heredado por todas las clases en Java. Para
obtener información adicional sobre la concatenación y conversión de cadenas,
consulte Gosling, Joy y Steele, The Java Language Specification .

A menos que se indique lo contrario, pasar un argumento nulo a un constructor o

método en esta clase hará que se arroje un NullPointerException.

A Stringrepresenta una cadena en el formato UTF-16 en el que los caracteres

suplementarios están representados por pares sustitutos (consulte la sección
Representaciones de caracteres Unicode en la Characterclase para obtener más
información). Los valores de índice se refieren a charunidades de código, por lo
que un carácter suplementario usa dos posiciones en a String.

La Stringclase proporciona métodos para tratar con puntos de código Unicode (es
decir, caracteres), además de aquellos para tratar con unidades de código
Unicode (es decir, charvalores). (docs.oracle, s.f.)
Constructores class string:

String()
Inicializa un Stringobjeto recién creado para que represente una secuencia de caracteres
vacía.

String(byte[] bytes)
Construye un nuevo String decodificando la matriz de bytes especificada usando el juego
de caracteres predeterminado de la plataforma.

String(byte[] bytes, Charset charset)

Construye un nuevo String decodificando la matriz de bytes especificada usando el juego
de caracteres especificado.

String(byte[] bytes, int offset, int length)

Construye un nuevo Stringdecodificando el subconjunto de bytes especificado usando el
juego de caracteres predeterminado de la plataforma.

String(char[] value)
Asigna un nuevo Stringpara que represente la secuencia de caracteres actualmente
contenidos en el argumento de matriz de caracteres.

String(int[] codePoints, int offset, int count)

Asigna un nuevo Stringque contiene caracteres de una submatriz del argumento de matriz
de puntos de código Unicode .

String(String original)
Inicializa un Stringobjeto recién creado para que represente la misma secuencia de
caracteres que el argumento; en otras palabras, la cadena recién creada es una copia de
la cadena de argumento.

String(StringBuffer buffer)
Asigna una nueva cadena que contiene la secuencia de caracteres actualmente
contenidos en el argumento del búfer de cadena.

String(StringBuilder builder)
Asigna una nueva cadena que contiene la secuencia de caracteres actualmente
contenidos en el argumento del generador de cadenas. (docs.oracle, s.f.)
Métodos más utilizados class String
charAt(int index)
Devuelve el charvalor en el índice especificado.

compareToIgnoreCase(String str)
Compara dos cadenas lexicográficamente, ignorando las diferencias entre mayúsculas y
minúsculas.

concat(String str)
Concatena la cadena especificada al final de esta cadena.

copyValueOf(char[] data)
Devuelve una cadena que representa la secuencia de caracteres en la matriz
especificada.

endsWith(String suffix)
Comprueba si esta cadena termina con el sufijo especificado.

equals(Object anObject)
Compara esta cadena con el objeto especificado.

format(Locale l, String format, Object... args)

Devuelve una cadena con formato utilizando la configuración regional, la cadena de
formato y los argumentos especificados.

getBytes()
Codifica esto Stringen una secuencia de bytes usando el juego de caracteres
predeterminado de la plataforma, almacenando el resultado en una nueva matriz de bytes.

indexOf(int ch)
Devuelve el índice dentro de esta cadena de la primera aparición del carácter
especificado.

isEmpty()
Devuelve verdadero si, y solo si, length()es 0 .

length()
Devuelve la longitud de esta cadena.

toString()
Este objeto (que ya es una cadena) se devuelve.

valueOf(boolean b)
Devuelve la representación de cadena del booleanargumento. (docs.oracle, s.f.)

Class StringBuffer

Una secuencia de caracteres mutable y segura para subprocesos. Un buffer de cadena es

como un String, pero puede modificarse. En cualquier momento contiene una secuencia
particular de caracteres, pero la longitud y el contenido de la secuencia se pueden
cambiar a través de ciertas llamadas a métodos.
Los buffers de cadena son seguros para su uso por múltiples hilos. Los métodos se
sincronizan cuando es necesario para que todas las operaciones en cualquier instancia
particular se comporten como si ocurrieran en algún orden en serie que sea consistente
con el orden de las llamadas a métodos realizadas por cada uno de los hilos individuales
involucrados.

Las operaciones principales en a StringBufferson los métodos appendy insert, que están
sobrecargados para aceptar datos de cualquier tipo. Cada uno convierte efectivamente un
dato dado en una cadena y luego agrega o inserta los caracteres de esa cadena en el
búfer de cadena. El appendmétodo siempre agrega estos caracteres al final del búfer; El
insertmétodo agrega los caracteres en un punto específico.

Por ejemplo, si se refiere a un objeto de búfer de cadena cuyo contenido actual es " start",
entonces la llamada al método z.append("le")provocaría que el búfer de cadena contenga
" startle", mientras z.insert(4, "le")que alteraría el búfer de cadena que contiene " starlet".

En general, si sb se refiere a una instancia de a StringBuffer, entonces sb.append(x) tiene

el mismo efecto que sb.insert(sb.length(), x).

Cuando se produce una operación que involucra una secuencia fuente (como agregar o
insertar desde una secuencia fuente), esta clase se sincroniza solo en el búfer de cadena
que realiza la operación, no en la fuente.
Cada buffer de cadena tiene una capacidad. Siempre que la longitud de la secuencia de
caracteres contenida en el búfer de cadena no exceda la capacidad, no es necesario
asignar una nueva matriz de búfer interno. Si el búfer interno se desborda, se agrandará
automáticamente. Como de la liberación de JDK 5, esta clase se ha complementado con
una clase equivalente diseñado para su uso por un solo hilo, StringBuilder. La clase
StringBuilder generalmente se debe usar con preferencia a esta, ya que admite todas las
mismas operaciones pero es más rápida, ya que no realiza sincronización. (oracle, s.f.)

Constructores class StringBuffer

StringBuffer()
Construye un búfer de cadena sin caracteres y una capacidad inicial de 16 caracteres.

StringBuffer(CharSequence seq)
Construye un búfer de cadena que contiene los mismos caracteres que el especificado

CharSequence.
StringBuffer(int capacity)
Construye un búfer de cadena sin caracteres y la capacidad inicial especificada.

StringBuffer(String str)
Construye un búfer de cadena inicializado al contenido de la cadena especificada.

Métodos más utilizados

append(boolean b)
Agrega la representación de cadena del boolean argumento a la secuencia.

capacity()
Devuelve la capacidad actual.

charAt(int index)
Devuelve el charvalor en esta secuencia en el índice especificado.

codePointAt(int index)
Devuelve el carácter (punto de código Unicode) en el índice especificado

delete(int start, int end)

Elimina los caracteres en una subcadena de esta secuencia.
ensureCapacity(int minimumCapacity)
Asegura que la capacidad sea al menos igual al mínimo especificado.

getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Los caracteres se copian de esta secuencia en la matriz de caracteres de destino dst.

indexOf(String str)
Devuelve el índice dentro de esta cadena de la primera aparición de la subcadena
especificada.

insert(int offset, boolean b)

Inserta la representación de cadena del boolean argumento en esta secuencia.

length()
Devuelve la longitud (recuento de caracteres).

reverse()
Hace que esta secuencia de caracteres se reemplace por el reverso de la secuencia.

replace(int start, int end, String str)

Reemplaza los caracteres en una subcadena de esta secuencia con caracteres en el
especificado String.

toString()
Devuelve una cadena que representa los datos en esta secuencia.

trimToSize()
Intenta reducir el almacenamiento utilizado para la secuencia de caracteres.

Class StringBuilder

Esta clase proporciona una API compatible con StringBuffer, pero sin garantía de
sincronización. Esta clase está diseñada para usarse como un reemplazo directo
StringBufferen lugares donde el subproceso de cadena estaba siendo utilizado por un solo
subproceso (como suele ser el caso). Siempre que sea posible, se recomienda utilizar esta
clase con preferencia, StringBufferya que será más rápida en la mayoría de las
implementaciones.
Las operaciones principales en a StringBuilderson los métodos appendy insert, que están
sobrecargados para aceptar datos de cualquier tipo. Cada uno convierte efectivamente un
dato dado en una cadena y luego agrega o inserta los caracteres de esa cadena en el
generador de cadenas. El appendmétodo siempre agrega estos caracteres al final del
generador; El insertmétodo agrega los caracteres en un punto específico.

Por ejemplo, si se zrefiere a un objeto generador de cadenas cuyo contenido actual es "
start", entonces la llamada al método z.append("le")provocaría que el generador de cadenas
contenga " startle", mientras z.insert(4, "le")que alteraría el generador de cadenas para que
contenga " starlet".

En general, si sb se refiere a una instancia de a StringBuilder, entonces sb.append(x)tiene el

mismo efecto que sb.insert(sb.length(), x). Cada generador de cadenas tiene una capacidad.
Siempre que la longitud de la secuencia de caracteres contenida en el generador de cadenas
no exceda la capacidad, no es necesario asignar un nuevo búfer interno. Si el búfer interno
se desborda, se agrandará automáticamente.

Las instancias de StringBuilderno son seguras para su uso por varios subprocesos. Si se
requiere dicha sincronización, se recomienda StringBuffersu uso. (oracle, s.f.)

Constructores:

StringBuilder()
Construye un generador de cadenas sin caracteres y una capacidad inicial de 16
caracteres.

StringBuilder(CharSequence seq)
Construye un generador de cadenas que contiene los mismos caracteres que los
especificados CharSequence.

StringBuilder(int capacity)
Construye un generador de cadenas sin caracteres y una capacidad inicial especificada
por el capacityargumento.

StringBuilder(String str)
Construye un generador de cadenas inicializado con el contenido de la cadena
especificada.

Métodos más utilizados:

append(boolean b)
Agrega la representación de cadena del boolean argumento a la secuencia.

capacity()
Devuelve la capacidad actual.

charAt(int index)
Devuelve el charvalor en esta secuencia en el índice especificado.

codePointAt(int index)
Devuelve el carácter (punto de código Unicode) en el índice especificado.

delete(int start, int end)

Elimina los caracteres en una subcadena de esta secuencia.

indexOf(String str, int fromIndex)

Devuelve el índice dentro de esta cadena de la primera aparición de la subcadena
especificada, comenzando en el índice especificado.

insert(int offset, boolean b)

Inserta la representación de cadena del boolean argumento en esta secuencia.

lastIndexOf(String str)
Devuelve el índice dentro de esta cadena de la aparición más a la derecha de la
subcadena especificada.

length()
Devuelve la longitud (recuento de caracteres).

replace(int start, int end, String str)

Reemplaza los caracteres en una subcadena de esta secuencia con caracteres en el
especificado String.

reverse()
Hace que esta secuencia de caracteres se reemplace por el reverso de la secuencia.

substring(int start, int end)

Devuelve un nuevo Stringque contiene una subsecuencia de caracteres actualmente
contenidos en esta secuencia.

toString()
Devuelve una cadena que representa los datos en esta secuencia.

trimToSize()
Intenta reducir el almacenamiento utilizado para la secuencia de caracteres.

Class StringJoiner

StringJoiner se utiliza para construir una secuencia de caracteres separados por un

delimitador y, opcionalmente, comenzar con un prefijo proporcionado y terminar con un
sufijo proporcionado.
Antes de agregar algo al StringJoiner, su sj.toString()método, por defecto, regresará prefix
+ suffix. Sin embargo, si setEmptyValuese llama al método, emptyValue se devolverá el
proporcionado. Esto se puede usar, por ejemplo, cuando se crea una cadena usando la
notación de conjunto para indicar un conjunto vacío, es decir "{}", dónde se ha agregado el
prefixes "{", el suffixes "}"y nada StringJoiner. (docs.oracle, s.f.)

Constructor:

StringJoiner(CharSequence delimiter)
Construye un StringJoinersin caracteres en él, con no prefixo suffix, y una copia del
suministrado delimiter.

StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

Construye un StringJoinersin caracteres en él utilizando copias de los suministrados
prefix, delimitery suffix.

Métodos más usados:

add(CharSequence newElement)
Agrega una copia del CharSequencevalor dado como el siguiente elemento del
StringJoinervalor.

length()
Devuelve la longitud de la Stringrepresentación de esto StringJoiner.

merge(StringJoiner other)
Agrega el contenido del dado StringJoinersin prefijo y sufijo como el siguiente elemento si
no está vacío.

setEmptyValue(CharSequence emptyValue)
Establece la secuencia de caracteres que se utilizará al determinar la representación de
cadena de este StringJoinery aún no se han agregado elementos, es decir, cuando está
vacío.

toString()
Devuelve el valor actual, que consiste en prefix, los valores agregados hasta ahora
separados por delimiter, y suffix, a menos que no se hayan agregado elementos en cuyo
caso, se devuelven prefix + suffixlos emptyValuecaracteres

Class StringTokenizer

La clase tokenizer de cadena permite que una aplicación divida una cadena en tokens. El
método de tokenización es mucho más simple que el utilizado por la StreamTokenizerclase.
Los StringTokenizermétodos no distinguen entre identificadores, números y cadenas entre
comillas, ni reconocen ni omiten comentarios.
El conjunto de delimitadores (los caracteres que separan los tokens) pueden especificarse
en el momento de la creación o por token.

Una instancia de se StringTokenizercomporta de una de dos maneras, dependiendo de si se

creó con el returnDelimsindicador que tiene el valor true o false:

Si la bandera es false, los caracteres delimitadores sirven para separar las fichas. Un token
es una secuencia máxima de caracteres consecutivos que no son delimitadores.
Si la bandera es true, los caracteres delimitadores se consideran fichas. Por lo tanto, un
token es un carácter delimitador o una secuencia máxima de caracteres consecutivos que no
son delimitadores.
Un objeto StringTokenizer mantiene internamente una posición actual dentro de la cadena
que se tokenizará. Algunas operaciones avanzan esta posición actual más allá de los
caracteres procesados.

Se devuelve un token tomando una subcadena de la cadena que se utilizó para crear el
objeto StringTokenizer .

El siguiente es un ejemplo del uso del tokenizer. El código:

StringTokenizer st = new StringTokenizer ("esta es una prueba");

while (st.hasMoreTokens ()) {
System.out.println (st.nextToken ());
}

imprime el siguiente resultado:

esta
es
una
prueba

StringTokenizer es una clase heredada que se retiene por razones de compatibilidad,

aunque se desaconseja su uso en nuevos códigos. Se recomienda que cualquiera que busque
esta funcionalidad use el método dividido de String o el paquete java.util.regex en su lugar.

El siguiente ejemplo ilustra cómo se puede usar el método String.split para dividir una
cadena en sus tokens básicos:

String [] result = "esta es una prueba" .split ("\\ s");

for (int x = 0; x <result.length; x ++)
System.out.println (result [x]);

imprime el siguiente resultado:

 esta
es
una
prueba

(docs.oracle, s.f.)

Constructor:

StringTokenizer(String str)
Construye un tokenizador de cadena para la cadena especificada.

StringTokenizer(String str, String delim)

Construye un tokenizador de cadena para la cadena especificada.

StringTokenizer(String str, String delim, boolean returnDelims)

Construye un tokenizador de cadena para la cadena especificada.
Métodos mas utilizados:

countTokens()
Calcula el número de veces que nextTokense puede llamar al método de este tokenizer
antes de que genere una excepción.

hasMoreElements()
Devuelve el mismo valor que el hasMoreTokens método.

hasMoreTokens()
Comprueba si hay más tokens disponibles de la cadena de este tokenizador.

nextElement()
Devuelve el mismo valor que el nextTokenmétodo, excepto que su valor de retorno
declarado es en Objectlugar de String.

nextToken()
Devuelve el siguiente token de este tokenizador de cadena.

nextToken(String delim);Devuelve el siguiente token en esta cadena del tokenizer.

Diferencias entre las clases String, StringBuffer y StringBuilder

String es un objeto inmutable (una vez creado no se puede cambiar). El objeto creado como
un String se almacena en la Constant String Pool.
Cada objeto inmutable en Java es seguro para su utilización en los hilos, que implica que el
String es thread safe. Un String no puede ser utilizado por dos hilos simultáneamente.
Una vez asignado un valor a un String este no se puede modificar.

StringBuffer es mutable significa que podemos cambiar el valor del objeto. El objeto
creado a través de StringBuffer se almacena en el Heap. StringBuffer tiene los mismos
métodos que el StringBuilder, pero cada método en el StringBuffer es sincronizado, esto
quiere decir que StringBuffer estara protegido al usarse en hilos , es thread safe.
Debido a esto no se permite que dos hilos puedan acceder simultáneamente a el mismo
método. Cada método se puede acceder por un hilo a la vez. Pero al estar protegido en los
hilos tiene desventajas en el rendimiento del StringBuffer. Así StringBuilder es más rápido
que el StringBuffer al llamar a los mismos métodos de cada clase.
En el StringBuffer el valor puede ser modificado, significa que se puede asignar un nuevo
valor. Hoy en día es una de las preguntas de entrevista más común, las diferencias entre las
clases anteriores.
StringBuffer se puede convertir a String mediante el uso del
método toString().

StringBuilder es igual que StringBuffer, se almacena el objeto en el Heap y también se

puede modificar. La principal diferencia entre el StringBuffer y el StringBuilder es que
StringBuilder no es seguro al utilizarse en hilos.
StringBuilder es rápido ya que no es seguro al utilizarse en los hilos, no es thread safe.
(ingenieroperales, 2015)
Finalidad de las clases StringJoiner y StringTokenizer

La clase StringTokenizer nos ayuda a dividir un string en substrings o tokens, en base a

otro string (normalmente un carácter) separador entre ellos denominado delimitador.
Supongamos un string consistente en el nombre, y los dos apellidos de una persona
separados por espacios en blanco. La clase StringTokenizer nos ayuda a romper dicho
string en tres substrings basado en que el carácter delimitador es un espacio en blanco.
clase StringJoiner. Para que sirve? como su nombre lo indica se utiliza para construir una
secuencia de caracteres separados por delimitadores, es decir, puede crear cadenas
utilizando algunos delimitadores como "," (coma) y "-" (guión), etc. También podemos usar
prefijos y sufijos para la secuencia de caracteres.
StringJoiner se encuentra en el paquete java.util y es una clase que es final y extiende de
object. (emanuelpeg, 2017)

Conclusiones:

Al considerar las cadenas como un tipo de datos, hay que definir (o conocer) cuales son

las operaciones que podemos hacer con ellas, en principio éstas podrían ser muchas y

llegar a ser muy sofisticadas. Una cadena suele ser representada entre comillas dobles

superiores ("palabra"), mientras que un carácter de esa cadena (un char en inglés) suele

ser representado entre comillas simples ('p')..

Bibliografía

docs.oracle. (s.f.). docs.oracle. Obtenido de docs.oracle:

https://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html
docs.oracle. (s.f.). docs.oracle. Obtenido de docs.oracle:
https://docs.oracle.com/javase/7/docs/api/java/lang/String.html
docs.oracle. (s.f.). docs.oracle. Obtenido de docs.oracle:
https://docs.oracle.com/javase/7/docs/api/java/util/StringTokenizer.html
emanuelpeg. (30 de 12 de 2017). Obtenido de
https://emanuelpeg.blogspot.com/2017/12/stringjoiner-la-nueva-clase-en-java-
8.html
Goette, E. (12 de 2017). emanuelpeg. Obtenido de emanuelpeg.
ingenieroperales. (30 de 08 de 2015). ingenieroperales. Obtenido de ingenieroperales:
https://www.ingenieroperales.com/diferencias-entre-string-stringbuffer-y-
stringbuilder-java/
oracle. (s.f.). docs.oracle. Obtenido de
https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html
oracle. (s.f.). docs.oracle.com. Obtenido de
https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html
Smith, S. (s.f.). techlandia.com. Obtenido de https://techlandia.com/clase-string-java-
info_372525/