Clases auxiliares para trabajar con cadenas en Java

1. StringTokenizerclase

Y ahora algunos escenarios más comunes que implican trabajar con cadenas. ¿Cómo se divide una cadena en varias partes? Hay varias formas de hacer esto.

split()método

La primera forma de dividir una cadena en varias partes es usar el split()método. Se debe pasar como argumento una expresión regular que defina una cadena delimitadora especial. Aprenderá qué es una expresión regular en la búsqueda Java Multithreading .

Ejemplo:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Simple, pero a veces este enfoque es excesivo. Si hay muchos delimitadores (por ejemplo, espacios, caracteres de nueva línea, tabulaciones, puntos), entonces debe construir una expresión regular bastante compleja. Es difícil de leer y por lo tanto difícil de modificar.

StringTokenizerclase

Java tiene una clase especial cuyo trabajo completo es dividir una cadena en subcadenas.

Esta clase no usa expresiones regulares: en su lugar, simplemente pasa una cadena que consta de delimitadores. La ventaja de este enfoque es que no rompe toda la cadena en pedazos de una sola vez, sino que se mueve de principio a fin un paso a la vez.

La clase tiene un constructor y dos métodos importantes. Pasamos al constructor una cadena que dividimos en partes y una cadena compuesta por un conjunto de caracteres delimitadores.

String nextToken()

boolean hasMoreTokens()

Esta clase recuerda de alguna manera a la clase Scanner, que también tiene nextLine()y hasNextLine()métodos.

Puede crear un StringTokenizerobjeto con este comando:

StringTokenizer name = new StringTokenizer(string, delimiters);

¿ Dónde stringse va a dividir la cuerda en partes? Y delimiterses una cadena, y cada carácter que contiene se trata como un delimitador. Ejemplo:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Tenga en cuenta que cada carácter de la cadena que se pasa como la segunda cadena al StringTokenizerconstructor se considera un separador.

2. String.format()método y StringFormatterclase

Otro método interesante de la clase String es format().

Digamos que tiene varias variables almacenando datos. ¿Cómo los muestra en la pantalla en una línea? Por ejemplo, tenemos algunos datos (columna izquierda) y el resultado deseado (columna derecha):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Su código probablemente se verá así:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Tal código no es muy legible. Y si los nombres de las variables fueran más largos, el código sería aún más difícil:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

No es muy legible, ¿verdad?

Pero esta es una situación común en los programas del mundo real, así que quiero contarles una forma de escribir este código de manera más simple y concisa.

String.format

La clase String tiene un método estático format(): le permite especificar un patrón para ensamblar una cadena con datos. La apariencia general del comando es la siguiente:

String name = String.format(pattern, parameters);

Ejemplo:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

El format()primer parámetro del método es una cadena de formato que contiene todo el texto deseado junto con caracteres especiales llamados especificadores de formato (como %dy %s) en los lugares donde necesita insertar datos.

El format()método reemplaza estos %sy %dlos especificadores de formato con los parámetros que siguen a la cadena de formato en la lista de parámetros. Si queremos insertar una cadena, entonces escribimos %s. Si queremos insertar un número, entonces el especificador de formato es %d. Ejemplo:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Aquí hay una breve lista de especificadores de formato que se pueden usar dentro de la cadena de formato:

%s

%d

%f

%b

%c

%t

%%

Estos especificadores indican el tipo de datos, pero también hay especificadores que indican el orden de los datos. Para obtener un argumento por su número (la numeración comienza desde uno), debe escribir " " en lugar de " ". Ejemplo:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$dobtendrá el tercer argumento, %2$dobtendrá el segundo argumento y %dobtendrá el primer argumento. Los especificadores de formato %sy %dse refieren a argumentos independientemente de los especificadores como %3$do%2$s

3. Piscina de cuerdas

Cada cadena especificada en el código como un literal de cadena se almacena en un área de memoria llamada StringPoolmientras se ejecuta el programa. StringPooles una matriz especial para almacenar cadenas. Su propósito es optimizar el almacenamiento de cadenas:

Primero, las cadenas especificadas en el código deben almacenarse en algún lugar, ¿verdad? El código consta de comandos, pero los datos (especialmente las cadenas grandes) deben almacenarse en la memoria por separado del código. Solo las referencias a objetos de cadena aparecen en el código.

En segundo lugar, todos los literales de cadena idénticos deben almacenarse en la memoria solo una vez. Y así es como funciona. Cuando la máquina Java carga su código de clase, todos los literales de cadena se agregan a StringPoolsi aún no están allí. Si ya están allí, simplemente usamos una referencia de cadena del archivo StringPool.

En consecuencia, si asigna el mismo literal a varias Stringvariables en su código, estas variables contendrán la misma referencia. Se agregará un literal a la StringPoolúnica vez. En todos los demás casos, el código obtendrá una referencia a la cadena ya cargada en el archivo StringPool.

Así es más o menos cómo funciona:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

Es por eso que las variables ay balmacenarán las mismas referencias.

intern()método

Y la mejor parte es que puede agregar mediante programación cualquier cadena al archivo StringPool. Para hacer esto, solo necesita llamar al método Stringde la variable intern().

El intern()método agregará la cadena a StringPoolsi aún no está allí y devolverá una referencia a la cadena en el StringPool.

Si se agregan dos cadenas idénticas usando StringPoolel intern()método, el método devuelve la misma referencia. Esto se puede usar para comparar cadenas por referencia. Ejemplo:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Es poco probable que utilice este método con frecuencia, pero a la gente le encanta preguntar al respecto en las entrevistas . Así que es mejor saberlo que no saberlo.