Cadenas (String) de Java

En este tutorial, aprenderemos con ejemplos cómo crear Java String y sus varios métodos.

　En Java, las cadenas son una serie de caracteres. Por ejemplo, "hello" es una cadena que contiene la secuencia de caracteres "h", "e", "l", "l" y "o".

Diferente a otros lenguajes de programación, las cadenas en Java no son tipos básicos (como int, char, etc.). Por el contrario, todas las cadenas son objetos de la clase predefinida llamada String. Por ejemplo,

//Crear una cadena
String type = "java programming";

Aquí, creamos una cadena llamada type. Aquí, inicializamos la cadena con "java programming". En Java, usamosComillas doblesRepresenta una cadena.

Esta cadena es una instancia de la clase String.

Atención：Todas las variables de cadena son instancias de la clase String.

Métodos de Java String

Java String proporciona varios métodos que nos permiten realizar diferentes operaciones de cadena. A continuación se presentan algunos métodos de cadena comunes.

Vamos a dar algunos ejemplos.

Ejemplo1：Java busca la longitud de la cadena

class Main {
　　public static void main(String[] args) {
　　　　//Crear una cadena
　　　　String greet = "Hello! World";
　　　　System.out.println("La cadena es: ");　+　greet);
　　　　//comprueba la longitud de la cadena
　　　　System.out.println("Longitud de la cadena: ");　+　greet.length());
　　}
}

Resultados de salida

La cadena es: Hello! World
Longitud de la cadena:　12

在上面的示例中，我们创建了一个名为 greet 的字符串。在这里，我们使用了 length() 方法来获取字符串的大小。

Ejemplo2：Java 使用 concat() 连接两个字符串

class Main {
　　public static void main(String[] args) {
　　　　//Crear una cadena
　　　　String greet = "Hello! ";
　　　　System.out.println("第一个字符串: ")　+　greet);
　　　　String name = "World";
　　　　System.out.println("第二个字符串: ")　+　name);
　　　　//连接两个字符串
　　　　String joinedString = greet.concat(name);
　　　　System.out.println("连接后的字符串: ")　+　joinedString);
　　}
}

Resultados de salida

第一个字符串: Hello!
第二个字符串: World
连接后的字符串: Hello! World

在上面的示例中，我们创建了2个名为 greet 和 name 的字符串。

在这里，我们使用了 concat() 方法来连接字符串。因此，我们得到一个名为 joinedString 的新字符串。

在 Java 中，我们还可以使用 + 运算符来连接两个字符串。

Ejemplo3：使用+运算符的 Java 连接字符串

class Main {
　　public static void main(String[] args) {
　　　　//Crear una cadena
　　　　String greet = "Hello! ";
　　　　System.out.println("第一个字符串: ")　+　greet);
　　　　String name = "World";
　　　　System.out.println("第二个字符串: ")　+　name);
　　　　//连接两个字符串
　　　　String joinedString = greet　+　name;
　　　　System.out.println("连接后的字符串: ")　+　joinedString);
　　}
}

Resultados de salida

第一个字符串: Hello!
第二个字符串: World
连接后的字符串: Hello! World

在这里，我们使用了+运算符来连接两个字符串。

Ejemplo4：Java比较两个字符串

class Main {
　　public static void main(String[] args) {
　　　　//创建字符串 s
　　　　String first = "java programming";
　　　　String second = "java programming";
　　　　String third = "python programming";
　　　　//比较第一个字符串和第二个字符串
　　　　boolean result1　= first.equals(second);
　　　　System.out.println("第一和第二个字符串相等: ")　+　result1;
　　　　//比较第一个和第三个字符串
　　　　boolean result2　= first.equals(third);
　　　　System.out.println("第一和第三个字符串相等: ")　+　result2;
　　}
}

Resultados de salida

第一和第二个字符串相等: true
第一和第三个字符串相等: false

在上面的示例中，我们使用了 equals() 方法来比较两个字符串的值。

如果两个字符串相同，则该方法返回 true，否则返回 false。

Atención还可以使用 == 运算符 和 compareTo() 方法比较2Una cadena.

Ejemplo5：Java obtener caracteres de una cadena

class Main {
　　public static void main(String[] args) {
　　　　//Crear una cadena utilizando el literal de cadena
　　　　String greet = "Hello! World";
　　　　System.out.println("La cadena es: ");　+　greet);
　　　　//Devolver la posición3El carácter en la posición
　　　　System.out.println("Posición3El carácter en la posición: "　+　greet.charAt(3))++;
　　　　//Devolver la posición7El carácter en la posición
　　　　System.out.println("Posición7El carácter en la posición: "　+　greet.charAt(7))++;
　　}
}

Resultados de salida

La cadena es: Hello! World
Posición3El carácter en la posición: l
Posición7El carácter en la posición: W

En el ejemplo anterior, utilizamos el método charAt() para acceder a los caracteres en una posición específica.

Ejemplo6：Otras métodos de cadenas de Java

class Main {
　　public static void main(String[] args) {
　　　　//Crear una cadena utilizando la palabra clave new
　　　　String example = new String("Hello! World");
　　　　//Devolver la subcadena World
　　　　System.out.println("Usando subString(): ");　+　example.substring(7))++;
　　　　//Convertir la cadena a minúsculas
　　　　System.out.println("Usando toLowerCase(): ");　+　example.toLowerCase());
　　　　//Convertir la cadena a mayúsculas
　　　　System.out.println("Usando toUpperCase(): ");　+　example.toUpperCase());
　　　　//Reemplazar el carácter '!' por 'o'
　　　　System.out.println("Usando replace(): ");　+　example.replace('!', 'o'));
　　}
}

Resultados de salida

Usando subString(): World
Usando toLowerCase(): hello! world
Usando toUpperCase(): HELLO! WORLD
Usando replace(): Helloo World

En el ejemplo anterior, creamos una cadena denominada example utilizando la palabra clave new.

Aquí,

• El método substring() devuelve la cadena World

• El método toLowerCase() convierte la cadena en minúsculas

• El método toUpperCase() convierte la cadena en mayúsculas

• método replace() reemplaza el carácter '!' por 'o'.

caracteres de escape en las cadenas

Las cadenas en Java se utilizanComillas doblesrepresentar.

//Crear una cadena
String example = "This is a string";

Ahora, si queremos incluirComillas dobles。 Por ejemplo,

//La cadena contiene comillas dobles
String example = "This is the "String" class";

Esto causará un error. Porque se usaComillas doblespara representar una cadena. Por lo tanto, el compilador lo "This is the " lo considera como una cadena.

Para resolver este problema, se utiliza el carácter de escape (\) en Java. Ahora podemos incluirComillas doblescomo se muestra a continuación:

//Uso de caracteres de escape
String example = "This is the \"String\" class.";

Los caracteres de escape le indican al compilador que los escape.Comillas doblesy leer todo el texto.

Las cadenas en Java son inmutables

En Java, crear una cadena significa crear un objeto de la clase string.No podemos cambiar la cadena al crearla en Java.Es por eso que en Java se llamaInmutableRazón.

Para entenderlo mejor, veamos un ejemplo:

//Crear una cadena
String example = "Hello!";

Aquí, creamos un objeto de cadena "Hello!". Después de su creación, no podremos cambiarlo.

Supongamos que queremos cambiar la cadena.

//Agregar otra cadena a esta
example = example.concat("　World");

Aquí, intentamos agregar una nueva cadena a la cadena anterior.

Dado que las cadenas sonInmutabledebiera causar un error. Pero es así.

Ahora parece que podemos cambiar la cadena. Pero, la realidad no es así. Veamos lo que realmente ocurre aquí.

Tenemos una cadena "Hello!" que es referenciada por una variable llamada example. Ahora, al ejecutar el código anterior,

• La JVM acepta la cadena "Hello!"

• Añadir la cadena "World" a la misma

• Esto creará una nueva cadena "Hello! World"

• La variable example ahora apunta a la nueva cadena

• La cadena anterior "Hello!" se mantiene inmutada

Atención：cada vez que creamos una nueva cadena y la referenciamos con una variable.

Crear una cadena utilizando la palabra clave new

Hasta ahora, hemos creado en Java una cadena similar a los tipos de datos básicos. Sin embargo, dado que las cadenas en Java son objetos, también podemos crearlas utilizando la palabra clave new. Por ejemplo,

//创建字符串使用new关键字
String　name　=　new　String("java　string");

在上面的示例中，我们使用了new关键字和构造函数String()来创建一个字符串。

String类提供各种其他构造函数创建的字符串。

现在，让我们看看创建字符串的过程与上一个过程有何不同。

使用字符串字面量和new关键字之间的区别

现在我们知道了如何使用字符串字面量和new关键字创建字符串，让我们看看它们之间的主要区别是什么。

　在Java中，JVM维护一个字符串池来将其所有字符串存储在内存中。字符串池有助于重用字符串。

　使用字符串文字创建字符串时，直接提供字符串的值。因此，编译器首先检查字符串池，看看字符串是否已经存在。

• 如果字符串已经存在，　不会创建新字符串。相反，新引用指向现有字符串。
  

• 如果字符串不存在，则创建新字符串。

　但是，在使用new关键字创建字符串时，不会直接提供字符串的值。因此，新字符串总是被创建。