Cadena de Java

Tutoriales

Java

La clase String de Java es una de las más ampliamente utilizadas. La clase String de Java está definida en el paquete java.lang.

Clase String de Java

Básicamente, una cadena es una secuencia de caracteres, pero no es un tipo primitivo.
Cuando creamos una cadena en Java, en realidad creamos un objeto del tipo String.
String es un objeto inmutable, lo que significa que no puede cambiarse una vez que se ha creado.
String es la única clase en la que se admite la sobrecarga de operadores en Java. Podemos concatenar dos cadenas usando el operador +. Por ejemplo, "a" + "b" = "ab".
Java proporciona dos clases útiles para la manipulación de cadenas: StringBuffer y StringBuilder.

Avancemos y aprendamos más sobre la clase String de Java.

Diferentes Formas de Crear Cadenas

Existen muchas formas de crear un objeto de cadena en Java; algunas de las más populares se presentan a continuación.

Usando literales de cadena

Esta es la forma más común de crear una cadena. En este caso, un literal de cadena está encerrado entre comillas dobles.
```
String str = "abc"; 
```
Cuando creamos una cadena usando comillas dobles, la JVM busca en el pool de cadenas para ver si alguna otra cadena se almacena con el mismo valor. Si se encuentra, simplemente devuelve la referencia a ese objeto String; de lo contrario, crea un nuevo objeto String con el valor dado y lo almacena en el pool de cadenas.
Usando la palabra clave new

Podemos crear un objeto String usando el operador new, al igual que cualquier clase normal de Java. Hay varios constructores disponibles en la clase String para obtener una cadena a partir de una matriz de caracteres, una matriz de bytes, StringBuffer y StringBuilder.
```
String str  =  new String("abc");
char[] a = {'a', 'b', 'c'};
String str2  =  new String(a);
```

Comparación de cadenas en Java

La clase String proporciona los métodos equals() y equalsIgnoreCase() para comparar dos cadenas. Estos métodos comparan el valor de la cadena para verificar si dos cadenas son iguales o no. Devuelven true si las dos cadenas son iguales y false si no lo son.

package com.journaldev.string.examples;

/**
 * Java String Example
 * 
 * @author pankaj
 *
 */
public class StringEqualExample {

	public static void main(String[] args) {
		//creando dos objetos de cadena
		String s1 = "abc";
		String s2 = "abc";
		String s3 = "def";
		String s4 = "ABC";
		
		System.out.println(s1.equals(s2));//true
		System.out.println(s2.equals(s3));//false
		
		System.out.println(s1.equals(s4));//false;
		System.out.println(s1.equalsIgnoreCase(s4));//true
	}

}

La salida del programa anterior es:

true
false
false
true

La clase String implementa la interfaz Comparable, que proporciona los métodos compareTo() y compareToIgnoreCase() y compara dos cadenas lexicográficamente. Ambas cadenas se convierten en valor Unicode para la comparación y devuelven un valor entero que puede ser mayor que, menor que o igual a cero. Si las cadenas son iguales, entonces devuelve cero o, de lo contrario, devuelve un valor mayor o menor que cero.

package com.journaldev.examples;

/**
 * Java String compareTo Example
 * 
 * @author pankaj
 *
 */
public class StringCompareToExample {

	public static void main(String[] args) {
		
		String a1 = "abc";
		String a2 = "abc";
		String a3 = "def";
		String a4 = "ABC";
		
		System.out.println(a1.compareTo(a2));//0
		System.out.println(a2.compareTo(a3));//less than 0
		System.out.println(a1.compareTo(a4));//greater than 0
		System.out.println(a1.compareToIgnoreCase(a4));//0
	}

}

La salida del programa anterior es:

Por favor, lee esto con más detalle en el ejemplo String compareTo.

Métodos de la cadena Java

Vamos a echar un vistazo a algunos de los métodos de la clase String más populares con un programa de ejemplo.

split()

El método split() de Java String se utiliza para dividir la cadena utilizando la expresión dada. Hay dos variantes del método split().

split(String regex): Este método divide la cadena utilizando la expresión regex dada y devuelve un array de cadenas.
split(String regex, int limit): Este método divide la cadena utilizando la expresión regex dada y devuelve un array de cadenas, pero el elemento del array está limitado por el límite especificado. Si el límite especificado es 2, entonces el método devuelve un array de tamaño 2.

package com.journaldev.examples;

/**
 * Ejemplo de división de cadenas en Java
 * 
 * @author pankaj
 *
 */
public class StringSplitExample {

	public static void main(String[] args) {
		
		String s = "a/b/c/d";
		String[] a1 = s.split("/");
		System.out.println("cadena dividida usando solo regex:");
		for (String string : a1) {
			System.out.println(string);
		}
		System.out.println("cadena dividida usando regex con límite:");
		String[] a2 = s.split("/", 2);
		for (String string : a2) {
			System.out.println(string);
		}
	}

}

La salida del programa anterior es:

cadena dividida usando solo regex:
a
b
c
d
cadena dividida usando regex con límite:
a
b/c/d

contains(CharSequence s)

Los métodos contains() de Java String verifican si una cadena contiene una secuencia específica de caracteres o no. Este método devuelve true si la cadena contiene la secuencia de caracteres especificada, de lo contrario, devuelve false.

package com.journaldev.examples;

/**
 * Ejemplo de Java String contains()
 * 
 * @author pankaj
 *
 */
public class StringContainsExample {

	public static void main(String[] args) {
		String s = "Hola Mundo";
		
		System.out.println(s.contains("W"));//true
		System.out.println(s.contains("X"));//false
	}

}

La salida del programa anterior es:

true
false

length()

El método length() de Java String devuelve la longitud de la cadena.

package com.journaldev.examples;

/**
 * Longitud de cadena de Java
 * 
 * @author pankaj
 *
 */
public class StringLengthExample {

	public static void main(String[] args) {
		
		String s1 = "abc";
		String s2 = "abcdef";
		String s3 = "abcdefghi";
		
		System.out.println(s1.length());//3
		System.out.println(s2.length());//6
		System.out.println(s3.length());//9

	}

}

replace()

El método replace() de Java String se utiliza para reemplazar una parte específica de la cadena con otra cadena. Hay cuatro variantes del método replace().

replace(char oldChar, char newChar): Este método reemplaza todas las ocurrencias de oldChar con newChar en la cadena.
replace(CharSequence target, CharSequence replacement): Este método reemplaza cada literal target con el literal replacement en la cadena.
replaceAll(String regex, String replacement): Este método reemplaza todas las ocurrencias de subcadenas que coinciden con el regex especificado con el reemplazo especificado en la cadena.
replaceFirst(String regex, String replacement): Este método reemplaza la primera ocurrencia de la subcadena que coincide con el regex especificado con el reemplazo especificado en la cadena.

package com.journaldev.examples;

/**
 * Java String replace
 * 
 * @author pankaj
 *
 */
public class StringReplaceExample {

	public static void main(String[] args) {
		
		//replace(char oldChar,  char newChar)
		String s = "Hello World";
		s = s.replace('l', 'm');
		System.out.println("Después de reemplazar l con m :");
		System.out.println(s);
		
		//replaceAll(String regex, String replacement)
		String s1 = "Hello journaldev, Hello pankaj";
		s1 = s1.replaceAll("Hello", "Hi");
		System.out.println("Después de reemplazar :");
		System.out.println(s1);
		
		//replaceFirst(String regex, String replacement) 
		String s2 = "Hello guys, Hello world";
		s2 = s2.replaceFirst("Hello", "Hi");
		System.out.println("Después de reemplazar :");
		System.out.println(s2);

	}

}

La salida del programa anterior es:

Después de reemplazar l con m :
Hemmo Wormd
Después de reemplazar :
Hi journaldev, Hi pankaj
Después de reemplazar :
Hi guys, Hello world

formato()

El método format() de Java Sting se utiliza para formatear la cadena. Hay dos variantes del método format() de String en Java.

format(Locale l, String format, Object… args): Este método formatea la cadena usando la configuración regional especificada, el formato de cadena y los argumentos.
format(String format, Object… args): Este método formatea la cadena usando el formato de cadena y los argumentos especificados.

paquete com.journaldev.examples;

import java.util.Locale;

/**
 * Formato de cadena de Java
 * 
 * @author pankaj
 *
 */
public class EjemploDeFormatoDeCadena {

	public static void main(String[] args) {
		
		String s = "journaldev.com";
		// %s se utiliza para agregar la cadena
		System.out.println(String.format("Esto es %s", s));
		
		// utilizando la configuración regional como Locale.US
		System.out.println(String.format(Locale.US, "%f", 3.14));
	}
}

La salida del programa anterior es:

Esto es journaldev.com
3.140000

substring()

Este método devuelve una parte de la cadena basada en índices especificados.

package com.journaldev.examples;

/**
 * Java String substring
 *
 */
public class StringSubStringExample {

	public static void main(String[] args) {
		
		String s = "Esto es journaldev.com";
		s = s.substring(8,18);
		System.out.println(s);
	}
}

Concatenación de Cadenas

La concatenación de cadenas es una operación muy básica en java. Las cadenas pueden concatenarse utilizando el operador “+” o utilizando el método concat().

package com.journaldev.examples;

/**
 * Java String concatenation
 * 
 * @author pankaj
 *
 */
public class StringConcatExample {

	public static void main(String[] args) {
		
		String s1 = "Hello";
		String s2 = "World";
		String s3 = s1 + s2;
		//utilizando el operador +
		System.out.println("Using + operator: ");
		System.out.println(s3);
		
		//utilizando el método concat
		System.out.println("Using concat method: ");
		System.out.println(s1.concat(s2));

	}

}

La salida del programa anterior es:

Using + operator: 
HelloWorld
Using concat method: 
HelloWorld

Consulte esta publicación para obtener más información sobre la Concatenación de Cadenas en Java.

Java String Pool

La gestión de memoria es el aspecto más importante de cualquier lenguaje de programación. La gestión de memoria en el caso de las cadenas de texto en Java es un poco diferente que en cualquier otra clase. Para hacer que Java sea más eficiente en cuanto a memoria, la JVM introdujo un área de memoria especial para la cadena de texto llamada Pool de Constantes de Cadena. Cuando creamos una cadena de texto literal, verifica si ya existe una cadena idéntica en el pool de cadenas o no. Si está allí, devolverá la referencia de la cadena existente en el pool de cadenas. Veamos el siguiente programa de ejemplo.

package com.journaldev.examples;

/**
 * Java String Pool Example
 * 
 */
public class StringPoolExample {

	public static void main(String[] args) {
		
		String a = "abc";
		String b = "abc";
		String c = "def";
		
		 // misma referencia 
		if (a==b) {
			System.out.println("Both string refer to the same object");
		}
		
		 // diferente referencia 
		if (a==c) {
			System.out.println("Both strings refer to the same object");
		}else {
			System.out.println("Both strings refer to the different object");
		}

	}

}

La salida del programa anterior es:

Both string refer to the same object
Both strings refer to the different object

Consulta esta publicación para obtener más información sobre el Pool de Cadenas de Java.

Método intern() de String

Cuando creamos una cadena de texto usando un literal de cadena, se creará en el pool de cadenas, pero ¿qué pasa si creamos una cadena de texto usando la palabra clave new con el mismo valor que existe en el pool de cadenas? ¿Podemos mover la cadena de texto de la memoria heap al pool de cadenas? Para esto se utiliza el método intern() y devuelve una representación canónica del objeto cadena. Cuando llamamos al método intern() en un objeto cadena creado usando la palabra clave new, ¿verifica si ya hay una cadena con el mismo valor en el pool? Si es así, devuelve la referencia de ese objeto cadena desde el pool. Si no, entonces crea una nueva cadena con el mismo contenido en el pool y devuelve la referencia.

package com.journaldev.examples;

/**
 * Java String intern
 * 
 * @author pankaj
 *
 */
public class StringInternExample {

	public static void main(String[] args) {
		
		String s1 = "pankaj";
		String s2 = "pankaj";
		String s3 = new String("pankaj");
		
		System.out.println(s1==s2);//true
		System.out.println(s2==s3);//false
		
		String s4 = s3.intern();
		System.out.println(s1==s4);//true

	}

}

Comprueba esta publicación para obtener más información sobre el método Java String intern.

Beneficios de la Inmutabilidad de la Cadena de Texto en Java

Algunos de los beneficios de la clase String siendo inmutable son:

Pool Constante de Cadenas, por lo tanto, ahorra memoria.
Seguridad ya que no se puede cambiar.
Seguro para hilos
Seguridad en la carga de clases

Consulta esta publicación para obtener más información sobre Beneficios de la Inmutabilidad de las Cadenas.

Java 8 String join()

A new static method join() has been added in String class in Java 8. This method returns a new String composed of copies of the CharSequence elements joined together with a copy of the specified delimiter. Let’s look at an example to understand it easily.

List<String> words = Arrays.asList(new String[]{"Hello", "World", "2019"});
String msg = String.join(" ", words);
System.out.println(msg);

Salida: Hola Mundo 2019

Métodos de Cadena de Texto en Java 9

Se han añadido dos métodos a la clase String en la versión Java 9. Son: codePoints() y chars(). Ambos métodos devuelven un objeto IntStream en el que podemos realizar algunas operaciones. Echemos un vistazo rápido a estos métodos.

String s = "abc";

s.codePoints().forEach(x -> System.out.println(x));

s.chars().forEach(x -> System.out.println(x));

Salida:

Nuevos Métodos de la Clase String en Java 11

Se han agregado muchos nuevos métodos a la clase String en la versión 11 de Java.

isBlank() – devuelve true si la cadena está vacía o contiene solo puntos de código de espacio en blanco, de lo contrario devuelve false.
lines() – devuelve un flujo de líneas extraídas de esta cadena, separadas por terminadores de línea.
strip(), stripLeading(), stripTrailing() – para eliminar espacios en blanco iniciales y finales de la cadena.
repeat() – devuelve una cadena cuyo valor es la concatenación de esta cadena repetida un número dado de veces.

Veamos un programa de ejemplo para estos métodos.

package com.journaldev.strings;

import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK 11 New Functions in String class
 * 
 * @author pankaj
 *
 */
public class JDK11StringFunctions {

	public static void main(String[] args) {
		// isBlank()
		String s = "abc";
		System.out.println(s.isBlank());
		s = "";
		System.out.println(s.isBlank());

		// lines()
		String s1 = "Hi\nHello\rHowdy";
		System.out.println(s1);
		List lines = s1.lines().collect(Collectors.toList());
		System.out.println(lines);

		// strip(), stripLeading(), stripTrailing()
		String s2 = "  Java,  \tPython\t ";
		System.out.println("#" + s2 + "#");
		System.out.println("#" + s2.strip() + "#");
		System.out.println("#" + s2.stripLeading() + "#");
		System.out.println("#" + s2.stripTrailing() + "#");

		// repeat()
		String s3 = "Hello\n";
		System.out.println(s3.repeat(3));
		s3 = "Co";
		System.out.println(s3.repeat(2));

	}

}

Salida:

false
true
Hi
Hello
Howdy
[Hi, Hello, Howdy]
#  Java,  	Python	 #
#Java,  	Python#
#Java,  	Python	 #
#  Java,  	Python#
Hello
Hello
Hello

CoCo

Eso es todo acerca de la clase String en Java, sus métodos y ejemplos de manipulación de cadenas.

Puedes revisar más ejemplos de cadenas en nuestro Repositorio de GitHub.

Referencia: Documentación de la API

Source:
https://www.digitalocean.com/community/tutorials/java-string

Usando literales de cadena

Usando la palabra clave new

split()

contains(CharSequence s)

length()

replace()

formato()

substring()