Java Strings: ¿qué son y para qué se utilizan?

8min

Los Java Strings en son esenciales para la programación de cualquier aplicación. Si eres programador en Java los usas constantemente, pero incluso así puedes desconocer cosas importantes sobre ellos. Si quieres mejorar tu manejo de Strings y hacer que tu código sea más limpio y eficiente, sigue leyendo este post.

Índice

¿Qué son los Strings de Java y para qué se utilizan?

Cuando trabajamos con Java, y con la mayoría de los lenguajes de programación, una de las cosas con las que más usamos son los String. En esencia todos sabemos lo que son: cadenas de texto que nos permiten almacenar y manipular secuencias de caracteres. Son esenciales porque una gran parte de los datos que se manejan en las aplicaciones son justamente eso, información textual.

Características de los Strings en Java

Es difícil encontrar una persona con unos mínimos conocimientos de programación que no sepa lo que son los strings, pero vamos a ver las características definitorias de las cadenas de caracteres de Java.

Inmutabilidad de los Strings

¿Sabías que los String en Java son inmutables? Esto significa que, una vez creado, su contenido no puede cambiar a lo largo de la ejecución de los programas. Por tanto, por mucho que asignes una nueva cadena a una variable, cada modificación genera un nuevo objeto.

Comparación entre String y StringBuilder

Sin embargo, hay veces que necesitamos modificar un String con frecuencia. En estos casos su inmutabilidad puede volverse un problema. Es por ello que existe el StringBuilder.

StringBuilder es una clase en Java que permite la manipulación de cadenas de texto mutables. La diferencia que tiene con respecto a String es que permite modificar el contenido de la cadena sin crear nuevos objetos en memoria. Esto tiene como resultado una mejora del rendimiento en casos en los que tengamos que realizar muchas modificaciones, porque no genera nuevos objetos en memoria. 

Gestión de memoria en Strings en Java

En Java, los Strings se almacenan en lo que se conoce como pool de Strings. Esta estrategia optimiza el uso de memoria evitando duplicaciones innecesarias. Así que, cuando creamos un String de manera literal, el lenguaje revisa si ya existe. Si es así, lo reutiliza en lugar de generar un nuevo objeto.

¿Cómo se crean y se manipulan los Strings en Java?

Vamos a ver las operaciones más básicas sobre Strings en Java, por si alguien no las conoce todavía.

Declaración y asignación de un String en Java

El primer paso para trabajar con Strings es declararlos. Podemos hacerlo de las dos maneras que vemos a continuación:

String texto = 'Hola, mundo';
String otroTexto = new String('Hola, mundo');

En la práctica produce el mismo resultado, sin embargo hay una diferencia en el modo de funcionamiento. La primera permite reutilizar Strings en el pool y ahorrar memoria, por lo que es más recomendable.

Métodos básicos para manipular Strings

Los String son objetos y por lo tanto tienen métodos que podemos invocar sobre ellos para conseguir cosas con ellos. Por si no lo sabes, los métodos son funcionalidades que se ejecutan sobre los objetos.

Vamos a introducir algunos métodos que necesitaremos un poco más adelante en los primeros ejemplos en este artículo.

  • charAt(int index): Se usa para obtener el carácter en la posición indicada.
  • substring(int beginIndex, int endIndex): Se usa para extraer una subcadena.
  • replace(char oldChar, char newChar): En este caso sustituye caracteres dentro del String.
  • isEmpty(): Indica si una cadena está vacía.

Concatenación de Strings en Java

La concatenación consiste en unir cadenas a otras cadenas. Cada vez que concatenamos Strings, Java crea nuevos objetos en memoria. 

String saludo = 'Hola' + ' ' + 'Mundo';

También se puede usar un método para concatenar:

String saludo2 = 'Hola'.concat(' Mundo');

Casos de uso comunes de String en Java

Los String se usan constantemente, por lo que los casos de uso serían innumerables. Vamos a ver algunos ejemplos clásicos.

Validación de entradas del usuario con Strings

Uno de los usos más prácticos de los String es la validación de datos. Existen muchos métodos que pueden permitir validar los datos de unas u otras maneras. Por ejemplo:

if (input.isEmpty()) {
    System.out.println('El campo no puede estar vacío.');
}

Almacenamiento de textos en aplicaciones Java

Cada vez que tenemos un texto compuesto por caracteres en las aplicaciones, se usan Strings para almacenarlos.

Operaciones de búsqueda y reemplazo en Strings

Operaciones muy frecuentes son las de búsqueda de la existencia, o no, de ciertas cadenas en otras cadenas. Por ejemplo, podemos comprobar si un correo electrónico pertenece a un dominio dado.

String email = 'usuario@example.com';
String dominio = 'example.com';

if (email.endsWith('@' + dominio)) {
    System.out.println('El correo pertenece al dominio dado.');
} else {
    System.out.println('El correo NO pertenece al dominio dado.');
}

Por otra parte, los reemplazos son otra de las operaciones típicas. Por ejemplo el código siguiente reemplaza todas las apariciones de «java» por Java».

String texto = 'java es genial. Me gusta java.';
String resultado = texto.replace('java', 'Java');
System.out.println(resultado);

Métodos útiles para los Strings en Java

Ahora vamos a mostrar otros de los métodos más útiles que puedes utilizar en el día a día con los strings.:

length()

Con el método length() conseguimos el entero que indica cuántos caracteres tiene un String de longitud.

String mensaje = 'Hola';
System.out.println(mensaje.length()); // 4

indexOf()

Podemos usar indexOf para encontrar la posición de una subcadena dentro del texto.

String texto = 'Hola mundo';
System.out.println(texto.indexOf('mundo'));

El código anterior mostraría el valor 5 por pantalla.

concat()

Este método ya lo hemos introducido antes y permite unir dos Strings en uno solo.

String parte1 = 'Hola';
String parte2 = ' Arsys';
System.out.println(parte1.concat(parte2));

toUpperCase() y toLowerCase()

Si tenemos que cambiar el «tamaño de caja» (entre mayúsculas y minúsculas) podemos usar toUpperCase() y toLowerCase().

String texto = 'Java';
System.out.println(texto.toUpperCase()); // muestra JAVA
System.out.println(texto.toLowerCase()); // muestra java

equals()

Este método nos permite comparar Strings y saber si tienen los valores iguales.

String a = 'Hola';
String b = 'hola';

Ante estas dos cadenas podríamos ejecutar este método así:

a.equals(b);

Tendría como resultado false. Ten en cuenta que equals() mirará si son mayúsculas y minúsculas también. Por ello podemos usar también equalsIgnoreCase(), que hace lo mismo pero ignorando el tamaño de caja.

a.equalsIgnoreCase(b); 

En este segundo caso devolvería true.

Buenas prácticas al trabajar con Strings en Java

Si queremos usar Strings con soltura y eficiencia debemos tener en cuenta estas buenas prácticas.

Evitar la concatenación excesiva de Strings

Como dijimos anteriormente, en Java, los objetos de tipo String son inmutables. Es por ello que si hacemos muchas concatenaciones puede bajar el rendimiento.

Este ejemplo de código sería poco recomendable:

String resultado = '';
for (int i = 0; i < 1000; i++) {
    resultado += i;
}

Usar StringBuilder para manipulación eficiente de texto

Para evitar el problema anterior podemos usar la clase StringBuilder, que permite modificar Strings de forma eficiente sin crear nuevos objetos en cada operación.

StringBuilder resultado = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    resultado.append(i);
}
String textoFinal = resultado.toString();

Manejo adecuado de excepciones al trabajar con Strings

En nuestro día a día como programadores podemos realizar operaciones que lancen excepciones, ya sea por descuido o por no validar ciertas entradas de datos. 

Por ejemplo, cuando trabajamos con Strings en Java, pueden producirse excepciones al realizar operaciones como convertir Strings en números. Vamos a ver un código de tratamiento de excepciones.

try {
    int numero = Integer.parseInt('abc');
} catch (NumberFormatException e) {
    System.out.println('Error: el String no es un número válido.');
}

¿Cuáles son los errores comunes al trabajar con Strings en Java?

Ya para acabar vamos a ver algunos errores comunes que debemos evitar al trabajar con Strings en Java.

Comparación incorrecta de Strings

En Java, los Strings deben compararse con el método equals(). Un error común consiste en usar el operador ==. Sin embargo, este lo que hace es comprobar las referencias a los objetos y no las cadenas en sí.

Uso inadecuado de la concatenación de Strings

Como ya mencionamos antes, usar el operador «+» repetidamente en un bucle no sería adecuado, ya que obligas a la máquina virtual de Java a crear constantemente objetos nuevos de tipo String. En lugar de ello es más adecuado usar StringBuilder, tal como ya te explicamos.

Problemas de memoria con Strings grandes

En Java trabajar con Strings muy grandes puede causar problemas de rendimiento y consumo excesivo de memoria. Si necesitamos manipular grandes volúmenes de texto, es recomendable utilizar StringBuilder o Streams.

Por ejemplo, si necesitas manipular un archivo de texto grande podrías hacer un tratamiento de Streams como puedes ver en el siguiente código.

Path archivo = Path.of('archivo_grande.txt'); 

try (Stream<String> lineas = Files.lines(archivo)) {
    lineas.map(linea -> linea.replace('java', 'Java')).forEach(System.out::println); 
} catch (IOException e) {
    e.printStackTrace();
}
Fernán García de Zúñiga

Artículos relacionados

Productos relacionados: