El objeto String de Java se explica en detalle, y nunca tendré miedo de que otros me pregunten sobre el objeto String en el futuro.

Enterprise 2023-08-01 20:38:08 views: null

1. Introducción a la clase String

Definición y características de la clase String

La clase String es una clase central proporcionada en Java para representar una secuencia inmutable de cadenas. Forma parte de la biblioteca estándar de Java, definida en el paquete java.lang, y es una clase final, es decir, no se puede heredar. La definición y características de la clase String se presentan en detalle a continuación:

  1. Definición:
    La clase String es un tipo de referencia (Reference Type), que se utiliza para representar una cadena compuesta por caracteres. En Java, una cadena se trata como un objeto en lugar de un tipo de datos primitivo. Cada instancia de objeto String contiene una secuencia de caracteres, la secuencia tiene una longitud y un contenido fijos.

  2. Inmutabilidad:
    los objetos de cadena son inmutables, es decir, una vez creados, su valor no se puede cambiar. Esto significa que el contenido de un objeto String no se puede cambiar después de crearlo. Para cualquier operación en un objeto String, se devuelve un nuevo objeto String y el objeto original permanece sin cambios. Esta inmutabilidad hace que los objetos String sean seguros para subprocesos y memoria.

  3. Conjunto de constantes de cadenas:
    El conjunto de constantes de cadenas (String Pool) en Java es un área de memoria especial que se utiliza para almacenar constantes de cadenas. El objeto String creado por el literal de cadena se buscará primero en el grupo de constantes de cadena. Si hay una cadena con el mismo valor, la referencia correspondiente en el grupo de constantes se devolverá directamente. Este mecanismo puede ahorrar espacio en la memoria y mejorar la reutilización de cadenas.

  4. Métodos y operaciones:
    la clase String proporciona una gran cantidad de métodos y operaciones para procesar cadenas. Las operaciones comúnmente utilizadas incluyen la concatenación de cadenas, la extracción de subcadenas, la búsqueda de caracteres, el reemplazo y la comparación. La clase String también proporciona soporte para operaciones comunes como longitud de cadena, conversión de mayúsculas y minúsculas y conversión de codificación de caracteres.

  5. Otras características:

    • Los objetos de cadena son inmutables y, por lo tanto, se pueden compartir de forma segura en un entorno de subprocesos múltiples.
    • La clase String implementa la interfaz Comparable, por lo que se pueden realizar operaciones de clasificación y comparación de cadenas.
    • La clase String se usa ampliamente en varios escenarios en Java, como procesamiento de archivos, comunicación de red, operaciones de bases de datos, etc.

Cabe señalar que debido a la inmutabilidad del objeto String, se generará un nuevo objeto String cada vez que se modifique la cadena, lo que puede causar problemas de rendimiento cuando se manipula con frecuencia una gran cantidad de cadenas. Para evitar esta situación, puede usar la clase StringBuilder o StringBuffer para realizar operaciones de cadena y convertirla en un objeto String al final.

La forma de crear un objeto String

  1. Creado usando literales de cadena:
    esta es la forma más común y simple de crear objetos de cadena. Al incluir un literal de cadena entre comillas, el compilador de Java lo convierte automáticamente en un objeto de cadena. Por ejemplo:

    String str1 = "Hello, World!";

    El objeto String creado con el literal de cadena primero verificará si hay una cadena con el mismo valor en el grupo de constantes de cadenas y, si existe, devolverá la referencia en el grupo de constantes; si no existe, se generará una nueva. Se creará un objeto de cadena y se agregará al grupo de constantes de cadena.

  2. Crear con la nueva palabra clave:
    al usar la nueva palabra clave y el constructor de la clase String, puede crear explícitamente un nuevo objeto String. Por ejemplo:

    String str2 = new String("Hello");

    Al crear un objeto String de esta manera, se creará un nuevo objeto String independientemente de si ya existe una cadena con el mismo valor en el conjunto de constantes de cadena. Por lo tanto, los objetos de cadena creados con la nueva palabra clave no utilizarán el conjunto de constantes de cadena.

  3. Creado usando una matriz de caracteres:
    también puede usar una matriz de caracteres para crear un objeto String. Puede crear un objeto String que contenga el contenido de una matriz de caracteres pasando la matriz de caracteres como parámetro al constructor de la clase String. Por ejemplo:

    char[] chars = {
      
      'H', 'e', 'l', 'l', 'o'};
String str3 = new String(chars);

    Puede pasar la matriz de caracteres completa o un subconjunto de la matriz para crear un objeto String.

  4. Uso de la concatenación de cadenas:
    utilice el operador de concatenación de cadenas (+) para concatenar varias cadenas y crear un nuevo objeto de cadena. Por ejemplo:

    String str4 = "Hello" + ", " + "World!";

    En este caso, el compilador convertirá automáticamente la operación de concatenación de cadenas para usar la clase StringBuilder o StringBuffer, y finalmente convertirá el resultado en un objeto String.

Cabe señalar que los objetos de cadena creados con literales de cadena se agregarán automáticamente al grupo de constantes de cadena, mientras que los objetos de cadena creados mediante la nueva palabra clave no se agregarán al grupo de constantes de cadena. Además, los objetos de cadena en el conjunto de constantes de cadena son inmutables en tiempo de ejecución, mientras que los objetos de cadena creados con la nueva palabra clave se pueden modificar.

Inmutabilidad y el concepto del conjunto de constantes de cadenas

  1. Inmutabilidad:
    los objetos de cadena son inmutables, lo que significa que una vez que se crea un objeto de cadena, su valor no se puede cambiar. Esta inmutabilidad se materializa en los siguientes aspectos:

    • Modificación de Strings: El contenido de un objeto String es fijo y no se permite su modificación. Cualquier operación de modificación en un objeto String en realidad devolverá un nuevo objeto String, dejando el objeto original sin cambios. Por ejemplo:

      String str = "Hello";
str = str + ", World!";

      En el ejemplo anterior, str + ", World!"en realidad se crea un nuevo objeto String, mientras que el objeto String "Hola" original no se modifica.

    • Concatenación de cadenas: para las operaciones de concatenación de cadenas, también se devuelve un nuevo objeto String. Por ejemplo:

      String str1 = "Hello";
String str2 = " World!";
String result = str1 + str2;

      En el código anterior, str1 + str2se creará un nuevo objeto String.

    • Reemplazar caracteres: los caracteres del objeto String no se pueden reemplazar directamente, debe realizarse empalmando cadenas o usando la clase StringBuilder/StringBuffer. Por ejemplo:

      String str = "Hello";
str = str.replace('H', 'W');  // 无法直接替换，需要重新赋值

    La ventaja de la inmutabilidad se refleja en un entorno de subprocesos múltiples, varios subprocesos pueden compartir de forma segura objetos String sin preocuparse por modificarlos. Además, la inmutabilidad también facilita la implementación del conjunto de constantes de cadena.

  2. Conjunto de constantes de cadenas (String Pool):
    El conjunto de constantes de cadenas es un área de memoria especial en Java para almacenar constantes de cadenas. Tiene las siguientes características:

    • El conjunto de constantes de cadena se encuentra en la memoria del montón, que es diferente del montón normal.
    • El objeto String creado por el literal de cadena primero verifica si hay una cadena con el mismo valor en el conjunto de constantes de cadena. Si existe, devolverá directamente la referencia en el grupo de constantes sin crear un nuevo objeto; si no existe, creará un nuevo objeto String en el grupo de constantes.
    • El propósito del grupo de constantes de cadenas es ahorrar espacio en la memoria y mejorar la reutilización de las cadenas. Debido a la inmutabilidad de los objetos String, el mismo valor se puede compartir de forma segura entre varios objetos String, lo que reduce la sobrecarga de memoria.

    El uso del grupo de constantes de cadena puede evitar la creación repetida de objetos de cadena con el mismo valor en la memoria, lo que mejora el rendimiento y la eficiencia del programa. Esta es la razón por la cual el uso de literales de cadena para crear objetos de cadena es una de las formas más comunes.

En resumen, la inmutabilidad de un objeto String significa que una vez creado, su valor no se puede cambiar. El grupo de constantes de cadena es un área de memoria especial que se utiliza para almacenar constantes de cadena, lo que ahorra espacio en la memoria y mejora el rendimiento al reutilizar objetos String del mismo valor.

En segundo lugar, el funcionamiento básico de la cadena.

Concatenación de cadenas y concatenación

  1. Use el operador "+":
    use el operador "+" para concatenar varias cadenas para generar una nueva cadena. Por ejemplo:

    String str1 = "Hello";
String str2 = " World!";
String result = str1 + str2;

    str1En este ejemplo, la concatenación y el uso del operador "+" str2produce una nueva cadena resultcuyo valor es "Hello World!". Este método es muy conciso y fácil de entender, y es adecuado para la conexión de un pequeño número de cadenas.

  2. Use el método concat():
    concat()el método se usa para concatenar la cadena especificada al final de la cadena. Por ejemplo:

    String str1 = "Hello";
String str2 = " World!";
String result = str1.concat(str2);

    En el ejemplo anterior, str1.concat(str2)concatenaría str2hasta str1el final de y asignaría el resultado a result. De manera similar, este método también es adecuado para la concatenación de un pequeño número de cadenas.

  3. Use la clase StringBuilder o StringBuffer:
    si necesita realizar una gran cantidad de operaciones de concatenación de cadenas o realizar operaciones de cadena en un entorno de subprocesos múltiples, se recomienda usar la clase StringBuilder o StringBuffer, que proporciona métodos de operación de cadena más eficientes y variables . Por ejemplo:

    StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" World!");
String result = sb.toString();

    En este ejemplo, use append()el método de StringBuilder para agregar varias cadenas al objeto StringBuilder una por una y, finalmente, toString()convierta el objeto StringBuilder en un objeto String a través del método.

    Cabe señalar que la clase StringBuilder no es segura para subprocesos, mientras que la clase StringBuffer sí lo es. Por lo tanto, en un entorno de subproceso único, se recomienda utilizar la clase StringBuilder para realizar operaciones de concatenación de cadenas.

No importa qué método se use para concatenar y concatenar cadenas, se generará un nuevo objeto de cadena. Esto se debe a que en Java, los objetos String son inmutables y no se pueden modificar en el lugar. Por lo tanto, cada operación de concatenación o concatenación de cadenas crea un nuevo objeto String.

comparación de cadenas

En Java, la comparación de cadenas es una operación común e importante para determinar si dos cadenas son iguales o para determinar su orden. Java proporciona varios métodos para comparar cadenas:

  1. Use el método equals():
    equals()el método se usa para determinar si el contenido de dos cadenas es el mismo. Por ejemplo:

    String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equals(str2);

    En el ejemplo anterior, str1.equals(str2)devolverá false, porque el contenido de las dos cadenas no es exactamente el mismo. Tenga en cuenta que equals()los métodos distinguen entre mayúsculas y minúsculas.

  2. Use el método equalsIgnoreCase():
    equalsIgnoreCase()el método se usa para ignorar el caso de la cadena para determinar si el contenido de las dos cadenas es el mismo. Por ejemplo:

    String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equalsIgnoreCase(str2);

    En este ejemplo, str1.equalsIgnoreCase(str2)devolverá trueporque ignora mayúsculas y minúsculas.

  3. Use el método compareTo():
    compareTo()​​el método se usa para comparar cadenas en orden lexicográfico. Devuelve un entero que representa la relación entre dos cadenas. Las reglas específicas son las siguientes:

    • Devuelve 0 si las cadenas son iguales.
    • Devuelve un número negativo si la cadena actual es menor que la cadena del argumento.
    • Devuelve un número positivo si la cadena actual es mayor que la cadena del argumento.

    Por ejemplo:

    String str1 = "apple";
String str2 = "banana";
int result = str1.compareTo(str2);

    En el ejemplo anterior, str1.compareTo(str2)se devolvería un número negativo, indicando str1lexicográficamente antes de str2.

  4. Use el método compareToIgnoreCase():
    compareToIgnoreCase()el método es similar al compareTo()método, pero ignora el caso de la cadena. Por ejemplo:

    String str1 = "Apple";
String str2 = "banana";
int result = str1.compareToIgnoreCase(str2);

    En este ejemplo, str1.compareToIgnoreCase(str2)se devolverá un número negativo, es decir, antes str1en orden lexicográfico str2(ignorando mayúsculas y minúsculas).

Cabe señalar que todos los métodos de comparación de cadenas se basan en valores Unicode. Además, puede usar ==el operador para comparar si las referencias de dos cadenas son iguales, pero no compara el contenido de las cadenas, solo juzga si los dos objetos de cadena apuntan a la misma dirección de memoria.

Extracción e interceptación de cadenas

En Java, las cadenas se pueden extraer y truncar utilizando diferentes métodos. Estas operaciones le permiten seleccionar partes específicas de una cadena original y crear una nueva cadena.

  1. Use el método substring():
    substring()el método se usa para extraer una subcadena de la cadena original. Toma uno o dos parámetros, el primer parámetro especifica el índice inicial de la subcadena (inclusivo) y el segundo parámetro (opcional) especifica el índice final de la subcadena (exclusivo). Por ejemplo:

    String str = "Hello World";
String substring1 = str.substring(6); // 从索引6开始截取到字符串末尾
String substring2 = str.substring(0, 5); // 从索引0开始截取到索引5（不包括）

    En el ejemplo anterior, substring1el valor de "World"y substring2el valor de "Hello".

  2. Utilice el método split():
    split()el método se utiliza para dividir la cadena en varias subcadenas de acuerdo con el delimitador especificado y devolver una matriz de cadenas. Por ejemplo:

    String str = "apple,banana,orange";
String[] substrings = str.split(",");

    En este ejemplo, split(",")la cadena se strdivide en tres subcadenas según el separador de coma y se almacena en la matriz de cadenas substrings. substrings[0]Es decir "apple", substrings[1]por "banana", substrings[2]para "orange".

  3. Utilice el método charAt():
    charAt()el método se utiliza para devolver el carácter en la posición de índice especificada en la cadena. Los índices comienzan desde 0. Por ejemplo:

    String str = "Hello";
char ch = str.charAt(1); // 获取索引为1的字符，即"e"

    En el ejemplo anterior, chel valor de 'e'.

  4. Usando el método substring() y el método indexOf():
    al usar substring()el método y indexOf()el método en combinación, puede extraer una parte específica en una cadena. Por ejemplo:

    String str = "The quick brown fox";
int startIndex = str.indexOf("quick"); // 获取子字符串"quick"的起始索引
int endIndex = str.indexOf("fox"); // 获取子字符串"fox"的起始索引
String result = str.substring(startIndex, endIndex);

    En este ejemplo, startIndexel valor de 4 endIndexes 16, por lo que resultel valor de "quick brown".

Cabe señalar que las operaciones de extracción e interceptación de cadenas generarán un nuevo objeto de cadena.

Buscar y reemplazar cadenas

En Java, puede usar diferentes métodos para realizar operaciones de búsqueda y reemplazo de cadenas. Estas operaciones le permiten encontrar un carácter específico o una subcadena en una cadena y reemplazarlo con un nuevo carácter o cadena.

  1. Use el método indexOf():
    indexOf()el método se usa para encontrar el índice de posición de la primera aparición del carácter o subcadena especificado en la cadena original. Si se encuentra una coincidencia, se devuelve el índice de la primera coincidencia; si no se encuentra ninguna coincidencia, se devuelve -1. Por ejemplo:

    String str = "Hello World";
int index = str.indexOf("o"); // 查找字符"o"在字符串中的位置

    En el ejemplo anterior, indexel valor de es 4 porque el primer carácter "o" está en el índice 4.

  2. Use el método lastIndexOf():
    lastIndexOf()el método es similar al indexOf()método, pero comienza desde el final de la cadena para encontrar el índice de posición de la última aparición del carácter o subcadena especificado. Por ejemplo:

    String str = "Hello World";
int lastIndex = str.lastIndexOf("o"); // 查找字符"o"在字符串中最后一次出现的位置

    En este ejemplo, lastIndexel valor de es 7 porque el último carácter "o" está en el índice 7.

  3. Use el método contains():
    contains()el método se usa para verificar si el carácter o la subcadena especificados están contenidos en la cadena. El valor de retorno es booleano. Por ejemplo:

    String str = "Hello World";
boolean contains = str.contains("World"); // 检查字符串中是否包含子字符串"World"

    En el ejemplo anterior, containsel valor es trueporque la cadena contiene la subcadena "Mundo".

  4. Use el método replace():
    replace()el método se usa para reemplazar el carácter o la subcadena especificados con un nuevo carácter o cadena. Por ejemplo:

    String str = "Hello World";
String newStr = str.replace("World", "Universe"); // 将字符串中的"World"替换为"Universe"

    En este ejemplo, newStrel valor es "Hello Universe".

  5. Use el método replaceAll ():
    replaceAll()el método replace()es similar al método, pero usa expresiones regulares para la coincidencia y el reemplazo de patrones. Por ejemplo:

    String str = "Hello123World456";
String newStr = str.replaceAll("\\d+", ""); // 用空字符串替换所有的数字

    En este ejemplo, newStrel valor es "HelloWorld"porque todos los números se reemplazan con cadenas vacías.

Cabe señalar que las operaciones de búsqueda y reemplazo de cadenas generarán un nuevo objeto de cadena, y la cadena original en sí no se modificará.

Tres, el método común de cadena

Obtener la longitud de la cadena

En Java, puede usar length()el método para obtener la longitud de una cadena. Este método devuelve la cantidad de caracteres (incluidos espacios y caracteres especiales) en la cadena.

Aquí hay un ejemplo simple:

String str = "Hello World!";
int length = str.length();

En este ejemplo, length()se llama al método y el valor de retorno se almacena en una variable entera length. En última instancia, lengthel valor de , es 12 porque la cadena "¡Hola mundo!" consta de 12 caracteres.

Cabe señalar que length()el método es un método del objeto de cadena, por lo que debe usar el operador de punto después de la variable de cadena para llamar al método. Esto significa que debe crear un objeto de cadena antes de poder llamar length()al método.

Además, length()el método también funciona con cadenas vacías, que devolverán 0:

String emptyStr = "";
int emptyLength = emptyStr.length(); // 结果为0

Para las cadenas que contienen caracteres Unicode, length()el método devuelve el número de unidades de código, no el número de caracteres Unicode. Java usa la codificación UTF-16 para representar cadenas, donde algunos caracteres deben representarse usando más de una unidad de código. Por lo tanto, si la cadena contiene dichos caracteres, la longitud devuelta puede ser mayor que el número real de caracteres Unicode.

convertir caso

En Java, puede usar toUpperCase()el método y toLowerCase()para convertir una cadena a mayúsculas o minúsculas.

  1. toUpperCase()Método: este método convierte todos los caracteres de la cadena a mayúsculas y devuelve una nueva cadena. Por ejemplo:
String str = "Hello World!";
String upperCaseStr = str.toUpperCase();

En este ejemplo, toUpperCase()se llama al método y la cadena en mayúsculas devuelta se almacena en upperCaseStruna variable. En última instancia, upperCaseStrel valor de es "¡HOLA MUNDO!".

  1. toLowerCase()Método: este método convierte todos los caracteres de la cadena en letras minúsculas y devuelve una nueva cadena. Por ejemplo:
String str = "Hello World!";
String lowerCaseStr = str.toLowerCase();

En este ejemplo, toLowerCase()se llama al método y la cadena en minúsculas devuelta se almacena en lowerCaseStruna variable. En última instancia, lowerCaseStrel valor de es "¡hola mundo!".

Cabe señalar que estos dos métodos generarán un nuevo objeto de cadena y la cadena original en sí no se modificará.

Además, estos dos métodos solo pueden convertir caracteres alfabéticos a mayúsculas o minúsculas, para caracteres no alfabéticos (como números, caracteres especiales, etc.), permanecerán sin cambios.

Aquí hay un ejemplo de cómo convertir mayúsculas y minúsculas solo para letras en una cadena:

String str = "Hello 123 World!";
String convertedStr = "";
for (int i = 0; i < str.length(); i++) {
    
    
    char c = str.charAt(i);
    if (Character.isLetter(c)) {
    
    
        if (Character.isUpperCase(c)) {
    
    
            convertedStr += Character.toLowerCase(c);
        } else {
    
    
            convertedStr += Character.toUpperCase(c);
        }
    } else {
    
    
        convertedStr += c;
    }
}

En este ejemplo, iteramos sobre cada carácter de la cadena y usamos Character.isLetter()el método para verificar si el carácter es una letra. Si es una letra, use Character.isUpperCase()el método para determinar el caso del carácter y convierta en consecuencia. Para caracteres no alfabéticos, lo dejamos sin cambios.

El resultado del código anterior será "¡HOLA 123 MUNDO!" con las mayúsculas y minúsculas al revés.

Quitar los espacios en blanco iniciales y finales

En Java, puede usar trim()métodos para eliminar los espacios en blanco iniciales y finales de una cadena. Este método devuelve una nueva cadena con los espacios iniciales y finales eliminados de la cadena original.

Aquí hay un ejemplo simple:

String str = "   Hello World!   ";
String trimmedStr = str.trim();

En este ejemplo, trim()se llama al método y la cadena devuelta se almacena en trimmedStruna variable sin espacios en blanco. En última instancia, trimmedStrel valor de es "Hello World!".

Cabe señalar que trim()el método solo puede eliminar los espacios al principio y al final de la cadena, pero no los espacios en el medio de la cadena. Por ejemplo, para la cadena "¡Hola mundo!", trim()el método solo eliminará los espacios iniciales y finales y devolverá "¡Hola mundo!".

Además, trim()el método también puede eliminar otros tipos de caracteres de espacio en blanco, como tabulaciones, saltos de línea, etc.

Si desea eliminar los espacios de una cadena, puede usar replaceAll()el método para reemplazar todos los caracteres de espacio:

String str = "   Hello    World!   ";
String noSpaceStr = str.replaceAll("\\s+", "");

En este ejemplo, replaceAll()se llama al método y se usa la expresión regular "\s+" para hacer coincidir uno o más caracteres de espacio en blanco consecutivos y los reemplaza con una cadena vacía. Finalmente, noSpaceStrel valor de "HelloWorld!".

Cabe señalar que replaceAll()el método también devolverá una nueva cadena y la cadena original en sí no se modificará.

cadena dividida

En Java, puede usar split()el método para dividir una cadena en subcadenas. split()El método divide una cadena en una matriz de cadenas según el delimitador dado.

Aquí hay un ejemplo simple:

String str = "Hello,World,Java";
String[] parts = str.split(",");

En este ejemplo, split()se llama al método y strse divide la cadena en varias subcadenas utilizando comas como delimitadores. Los resultados de la división se almacenan en partsuna matriz. En última instancia, partsel valor de la matriz es ["Hello", "World", "Java"].

Como puede ver, split()el método devuelve una matriz de cadenas, cada elemento del cual es una subcadena de la cadena original dividida según el delimitador.

Cabe señalar que el delimitador puede ser una cadena o una expresión regular. Si el delimitador es una expresión regular, debe escaparse con barras invertidas dobles.

Además, si desea limitar la cantidad de subcadenas después de la división, puede usar el método con el segundo parámetro split(). Por ejemplo, el siguiente ejemplo strdivide una cadena en dos subcadenas como máximo:

String str = "Hello,World,Java";
String[] parts = str.split(",", 2);

En este ejemplo, split()el segundo parámetro del método es 2, lo que significa que se divide en 2 subcadenas como máximo. Los resultados de la división se almacenan en partsuna matriz. En última instancia, partsel valor de la matriz es ["Hello", "World,Java"].

Si hay delimitadores consecutivos en la cadena, split()el método devuelve una cadena vacía como subcadena entre delimitadores adyacentes. Si desea eliminar estas cadenas vacías, puede combinar los métodos split()y :trim()

String str = "Hello,,World,Java";
String[] parts = str.split(",", -1);
for (int i = 0; i < parts.length; i++) {
    
    
    parts[i] = parts[i].trim();
}

En este ejemplo, split()el método se llama con -1 como segundo parámetro, lo que significa mantener todos los separadores consecutivos. Luego, use un bucle y trim()un método para eliminar los espacios en blanco iniciales y finales de cada subcadena.

formato de cadena

En Java, el formato de cadenas se puede utilizar para crear cadenas con un formato específico. El formato de las cadenas se realiza mediante patrones de formato y sustitución de parámetros.

El formateo de cadenas en Java depende principalmente de String.format()métodos y System.out.printf()métodos. Ambos métodos admiten el uso de marcadores de posición especiales y caracteres de conversión para el formato de cadenas.

Aquí hay un ejemplo simple:

String name = "Alice";
int age = 25;
double weight = 55.5;

String message = String.format("My name is %s, I'm %d years old, and my weight is %.2f kg.", name, age, weight);
System.out.println(message);

En este ejemplo, String.format()el método se usa para crear una cadena con formato message. Entre ellos, %sy %dson %.2fmarcadores de posición que representan una cadena, un número entero y un número de coma flotante con dos decimales, respectivamente. Estos marcadores de posición serán reemplazados por los siguientes parámetros a su vez para formar la cadena con formato final.

Ejecute el código anterior y el resultado es: "Mi nombre es Alice, tengo 25 años y peso 55,50 kg".

Además de String.format()los métodos, los métodos también se pueden usar System.out.printf()para enviar cadenas formateadas directamente a la consola:

String name = "Alice";
int age = 25;
double weight = 55.5;

System.out.printf("My name is %s, I'm %d years old, and my weight is %.2f kg.", name, age, weight);

Ejecutar el código anterior también generará: "Mi nombre es Alice, tengo 25 años y peso 55,50 kg".

Además de los marcadores de posición regulares, los caracteres de conversión también se pueden usar para especificar formatos especiales, como fechas, horas, etc. Aquí hay un ejemplo:

import java.time.LocalDateTime;

LocalDateTime now = LocalDateTime.now();

System.out.printf("Current date and time: %tF %tT", now, now);

En este ejemplo, los caracteres de uso %tFy %tTconversión representan el formato de la fecha y la hora, respectivamente. nowUna variable es un LocalDateTimeobjeto que contiene información de fecha y hora actual. Ejecutar el código anterior generará la fecha y hora actual, por ejemplo: "Fecha y hora actual: 2023-06-29 14:30:00".

Cabe señalar que en la cadena de formato, también se pueden usar otros modificadores para ajustar el formato de la salida, como el ancho, la precisión, la alineación, etc.

4. Inmutabilidad de cadenas y problemas de rendimiento

Efectos de la inmutabilidad de cadenas en los programas

  1. Seguridad de subprocesos: dado que las cadenas son inmutables, son seguras para subprocesos en un entorno de subprocesos múltiples. Múltiples subprocesos pueden acceder y compartir el mismo objeto de cadena al mismo tiempo sin preocuparse por los problemas de concurrencia causados ​​por la modificación de datos. Esto hace que las cadenas sean más confiables y fáciles de usar en la programación concurrente.

  2. Hashes de caché: dado que las cadenas son inmutables, sus hashes se pueden almacenar en caché. En Java, el valor hash de una cadena se almacena en caché después del primer cálculo para mejorar la eficiencia de búsqueda de cadenas en estructuras de datos como conjuntos hash y mapas hash. Si la cadena es mutable, cada cálculo del valor hash debe atravesar la matriz de caracteres de la cadena, lo que afecta el rendimiento de las operaciones relacionadas con el hash.

  3. Seguridad de paso de método: dado que las cadenas son inmutables, se pueden pasar de forma segura como parámetros de método. Dentro del método, si se modifica la cadena, en realidad se crea un nuevo objeto de cadena sin afectar el objeto de cadena original. Esto evita modificaciones accidentales cuando los datos se comparten entre métodos, lo que aumenta la confiabilidad del programa.

  4. Seguridad y confiabilidad: la inmutabilidad de las cadenas garantiza que los datos de las cadenas en los programas no se puedan modificar accidentalmente. Esto es muy importante para la seguridad y la confiabilidad, especialmente cuando necesita proteger información confidencial (como contraseñas) o manipular datos.

  5. Optimización del rendimiento: aunque la inmutabilidad de las cadenas puede causar algunos problemas de rendimiento (como cuando se concatenan cadenas en grandes cantidades), también brinda algunas oportunidades de optimización del rendimiento. Dado que las cadenas son inmutables, varias cadenas pueden compartir el mismo espacio de memoria, ahorrando memoria. Además, la inmutabilidad de las cadenas también permite que los objetos de cadena se almacenen en caché y se reutilicen, lo que reduce la sobrecarga de la creación frecuente de objetos y mejora el rendimiento del programa.

Debe tenerse en cuenta que aunque las cadenas son inmutables, en las clases de Java , los caracteres de las cadenas Stringen realidad se almacenan mediante el uso de matrices. char[]Cuando se realiza una operación de modificación en una cadena (como llamar a un método), en realidad se crea substring()un nuevo objeto que se refiere a la misma matriz, pero posiblemente con diferentes rangos de índices. Este diseño permite operaciones en cadenas sin modificar el objeto original, mejorando aún más la confiabilidad y seguridad del programa.Stringchar[]String

Eficiencia del empalme de cuerdas

En Java, la operación de concatenación de cadenas se puede implementar de varias maneras, como usar el operador, concat()método, StringBuilderclase o StringBufferclase "+", etc.

Sin embargo, debido a la inmutabilidad de las cadenas, cada operación de concatenación de cadenas creará un nuevo objeto de cadena. Esto puede conducir a los siguientes problemas de eficiencia:

  1. Sobrecarga de memoria: cada operación de concatenación de cadenas implica la creación de un nuevo objeto de cadena, lo que significa que se debe asignar espacio de memoria adicional para almacenar la nueva cadena. Si se realiza una gran cantidad de operaciones de concatenación de cadenas, se generará una gran cantidad de objetos temporales, lo que aumenta la sobrecarga de memoria.

  2. Pérdida de rendimiento: la inmutabilidad de las cadenas hace que cada operación de concatenación copie el contenido de la cadena anterior y cree un nuevo objeto de cadena. Esta operación provocará una pérdida de rendimiento al empalmar una gran cantidad de cadenas con frecuencia, especialmente cuando se usa el operador "+" para empalmar, porque cada operador "+" desencadenará una copia y creación de un objeto de cadena.

Para resolver el problema de eficiencia de la concatenación de cadenas, se pueden usar StringBuilderclases o clases. StringBufferEstas son clases de cadenas mutables que proporcionan operaciones eficientes de concatenación de cadenas. Aquí están sus características:

  • StringBuilder: una clase de cadena mutable no segura para subprocesos, utilizada en un entorno de un solo subproceso.
  • StringBuffer: una clase de cadena variable segura para subprocesos, utilizada en un entorno de subprocesos múltiples.

Estas clases proporcionan una serie de métodos, como append(), insert()etc., para agregar o insertar operaciones sobre la base de la cadena original sin crear un nuevo objeto de cadena. Esto evita la creación frecuente de objetos y la copia de cadenas, lo que mejora la eficiencia de la operación de empalme.

El siguiente es un código de muestra que demuestra StringBuildercómo usar la concatenación de cadenas:

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World!");

String result = sb.toString();

En el ejemplo anterior, StringBuilderel objeto agrega el contenido de la cadena sbllamando al método varias veces . Finalmente , el objeto se convierte en un objeto inmutable append()llamando a un toString()método .StringBuilderString

El uso de StringBuilder y StringBuffer

StringBuildery StringBufferson clases en Java para el manejo eficiente de cadenas mutables. Proporcionan una serie de métodos para agregar, insertar, eliminar y reemplazar sobre la base de la cadena original sin crear un nuevo objeto de cadena.

  1. Crear objeto:

    • Use un constructor de parámetros nulos:StringBuilder sb = new StringBuilder();
    • Use un constructor que especifique una capacidad inicial:StringBuilder sb = new StringBuilder(int capacity);

    StringBufferEl uso es StringBuildersimilar a , excepto que es seguro para subprocesos y adecuado para entornos de subprocesos múltiples.

  2. Operación básica:

    • Agregar cadena: append(String str), se usa para agregar la cadena especificada después de la cadena actual.
    • Insertar cadena: insert(int offset, String str), inserta la cadena especificada en la posición especificada.
    • Eliminar caracteres o cadenas: delete(int start, int end), para eliminar los caracteres dentro del rango especificado; deleteCharAt(int index), para eliminar los caracteres en la posición de índice especificada.
    • Reemplazar carácter o cadena: replace(int start, int end, String str), para reemplazar los caracteres dentro del rango especificado con la cadena especificada.

  3. Llamadas encadenadas: ambos métodos
    StringBuildery StringBufferdevuelven sus propios objetos, por lo que se pueden realizar múltiples operaciones a través de llamadas encadenadas. Por ejemplo:

    StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World!");

  4. Convertir a cadena:

    • Utilice toString()el método para convertir un objeto StringBuildero StringBufferen un objeto inmutable String.

  5. Seguridad del hilo:

    • StringBuilderNo es seguro para subprocesos y es adecuado para entornos de un solo subproceso.
    • StringBufferEs seguro para subprocesos y adecuado para entornos de subprocesos múltiples.

Dado que StringBuildery StringBufferson clases de cadenas mutables, suelen ser más eficientes que la concatenación de cadenas con el operador "+". StringBuilderSe recomienda usar o cuando se requieren operaciones de cadena frecuentes o se usan en un entorno de subprocesos múltiples StringBuffer.

Cabe señalar que, aunque StringBuilderproporciona StringBufferuna manipulación de cadenas eficiente, en un entorno de subproceso único, se recomienda su uso StringBuilderporque es StringBufferun poco más liviano que . Solo en un entorno de subprocesos múltiples debe tener en cuenta StringBufferla seguridad de subprocesos utilizada.

5. Cadenas y expresiones regulares

Resumen de expresiones regulares

Las expresiones regulares son una poderosa herramienta de coincidencia de patrones para buscar, unir y reemplazar cadenas de caracteres que coinciden con patrones específicos en el texto. Proporciona una forma flexible y eficiente de procesar cadenas y tiene una amplia gama de escenarios de aplicación, incluido el procesamiento de texto, la validación de datos, la extracción de datos, etc.

Las expresiones regulares constan de caracteres y caracteres especiales y se utilizan para describir patrones de cadenas.

  1. Caracteres ordinarios: cualquier carácter no especial se representa a sí mismo. Por ejemplo, la expresión regular abccoincidirá con "abc" en la cadena.

  2. Metacaracteres: Caracteres con significado especial, utilizados para construir patrones más complejos.

    • .: Coincide con cualquier carácter individual, excepto nueva línea.
    • *: Coincide con el elemento anterior cero o más veces.
    • +: Coincide con el elemento anterior una o más veces.
    • ?: Coincide con el elemento anterior cero o una vez.
    • ^: La posición inicial de la cadena coincidente.
    • $: Coincide con la posición final de la cadena.
    • \: carácter de escape, utilizado para tratar los siguientes caracteres especiales como caracteres normales. Por ejemplo, \.coincide con el carácter de punto ".".
    • []: Clase de carácter, coincide con cualquier carácter entre corchetes. Por ejemplo, [aeiou]coincide con cualquier vocal individual.
    • [^]: niega la clase de carácter, haciendo coincidir cualquier carácter excepto los caracteres entre corchetes. Por ejemplo, [^0-9]coincide con cualquier carácter no numérico.
    • (): Agrupación, trate los patrones en ella como un todo.
    • |: OR lógico, coincide con cualquiera de los dos patrones.

  3. Cuantificador: Se utiliza para especificar el número de ocurrencias de un elemento.

    • {n}: coincide exactamente con n ocurrencias del elemento anterior.
    • {n,}: Coincide con al menos n ocurrencias del elemento anterior.
    • {n,m}: Coincide con el elemento anterior al menos n veces y como máximo m veces.
    • ?, *, +, {n,}, {n,m}se agregan después de ?, lo que indica una coincidencia no codiciosa, la menor coincidencia posible.

  4. Clases de caracteres predefinidas: formas abreviadas predefinidas para algunas clases de caracteres de uso común.

    • \d: Caracteres numéricos, equivalentes a [0-9].
    • \D: Caracteres no numéricos, equivalente a [^0-9].
    • \w: carácter de palabra, equivalente a [a-zA-Z0-9_].
    • \W: Caracteres que no son palabras, equivalentes a [^a-zA-Z0-9_].
    • \s: Caracteres de espacio en blanco, incluidos espacios, tabulaciones, saltos de línea, etc.
    • \S: Un carácter que no está en blanco.

  5. Coincidencia codiciosa y no codiciosa: De forma predeterminada, la expresión regular coincidirá tanto como sea posible, es decir, coincidencia codiciosa. El emparejamiento no codicioso se puede lograr agregando después del cuantificador ?, emparejando lo menos posible.

Los pasos generales para usar expresiones regulares son los siguientes:

  1. Define un patrón de expresión regular.
  2. Use el método correspondiente para hacer coincidir, buscar o reemplazar, los métodos comunes son:
    • matches(String regex, CharSequence input): determine si toda la cadena coincide con el patrón.
    • find(): busca y devuelve la siguiente subcadena coincidente.
    • replaceAll(String regex, String replacement): reemplaza todas las subcadenas coincidentes con la cadena especificada.
    • split(String regex): divide una cadena en función de una expresión regular.

El uso de expresiones regulares en Java puede usar java.util.regexclases y métodos relacionados en el paquete, principalmente incluyendo Patterndos Matcherclases. Entre ellos, Patternse utiliza para compilar expresiones regulares Matcherpara operaciones de coincidencia.

A continuación se muestra un código de muestra de Java simple que demuestra el proceso de hacer coincidir y reemplazar cadenas usando expresiones regulares:

import java.util.regex.*;

public class RegexExample {
    
    
    public static void main(String[] args) {
    
    
        String text = "The quick brown fox jumps over the lazy dog.";

        // 匹配包含 "fox" 的单词
        Pattern pattern = Pattern.compile("\\bfox\\b");
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
    
    
            System.out.println("Found match at index " + matcher.start());
        }

        // 替换所有的元音字母为 "*"
        String replacedText = text.replaceAll("[aeiou]", "*");
        System.out.println(replacedText);
    }
}

El código anterior coincide y genera palabras que contienen "fox" a través de expresiones regulares y reemplaza las vocales en el texto con "*".

Coincidencia y reemplazo de cadenas y expresiones regulares

Hacer coincidir y reemplazar cadenas con expresiones regulares es una operación común y muy útil. Mediante el uso de expresiones regulares, podemos buscar, unir y reemplazar cadenas en el texto que coincidan con ciertos patrones.

La operación de coincidencia se refiere a encontrar subcadenas que satisfagan un patrón específico en una cadena dada. Java proporciona java.util.regexpaquetes en los que las clases Patterny Matcherse pueden usar para operaciones de coincidencia.

  1. PatternClase: Se utiliza para compilar expresiones regulares y crear Patternobjetos. Proporciona múltiples métodos estáticos para compilar expresiones regulares, y también se pueden configurar algunas opciones para ajustar el comportamiento de coincidencia. Por ejemplo, Pattern.compile(String regex)el método compila una expresión regular en Patternun objeto.

  2. MatcherClase: se utiliza para realizar operaciones de coincidencia en una cadena determinada. Al llamar Pattern.matcher(CharSequence input)a un método, podemos obtener un Matcherobjeto. A continuación, Matcherse pueden usar varios métodos de la clase para realizar operaciones de coincidencia:

    • matches(): determine si la cadena completa coincide con la expresión regular.
    • find(): intenta encontrar la siguiente subcadena coincidente en la cadena.
    • start(): Devuelve el índice inicial de la subcadena que coincide actualmente.
    • end(): Devuelve el índice final de la subcadena que coincide actualmente.
    • group(): Devuelve la subcadena que coincide actualmente.

El siguiente es un código de muestra simple que demuestra cómo usar expresiones regulares para operaciones de coincidencia:

import java.util.regex.*;

public class RegexMatchingExample {
    
    
    public static void main(String[] args) {
    
    
        String text = "The quick brown fox jumps over the lazy dog.";

        // 匹配包含 "fox" 的单词
        Pattern pattern = Pattern.compile("\\bfox\\b");
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
    
    
            System.out.println("Found match at index " + matcher.start());
        }
    }
}

El código anterior usa una expresión regular "\bfox\b"para hacer coincidir las palabras que contienen "zorro" en el texto. Al llamar Matcher.find()al método, encontramos la posición de cada coincidencia y generamos su índice de inicio.

La operación de reemplazo se refiere a reemplazar la subcadena coincidente con una nueva cadena. Hay dos formas comunes de usar expresiones regulares para operaciones de reemplazo en Java:

  1. String.replaceAll(String regex, String replacement): este método utiliza una expresión regular para buscar y reemplazar todas las subcadenas coincidentes en la cadena dada. Entre ellos, regexel parámetro especifica la expresión regular y replacementel parámetro especifica la cadena que se va a reemplazar.

  2. Matcher.replaceAll(String replacement): este método Matcherbusca y reemplaza todas las subcadenas coincidentes en la cadena actual del objeto. Asimismo, replacementel parámetro especifica la cadena a reemplazar.

Aquí hay un código de muestra que demuestra cómo usar expresiones regulares para operaciones de reemplazo:

import java.util.regex.*;

public class RegexReplacementExample {
    
    
    public static void main(String[] args) {
    
    
        String text = "The quick brown fox jumps over the lazy dog.";

        // 将文本中的元音字母替换为 "*"
        String replacedText = text.replaceAll("[aeiou]", "*");
        System.out.println(replacedText);
    }
}

El código anterior usa expresiones regulares "[aeiou]"para hacer coincidir las vocales en el texto y reemplazarlas con "*". Al llamar String.replaceAll()al método, podemos obtener la cadena reemplazada y generarla.

6. Codificación y decodificación de cadenas

El concepto de codificación de caracteres y juego de caracteres

Cuando tratamos con texto, la codificación de caracteres y el juego de caracteres son dos conceptos importantes. Se utilizan para representar y manipular caracteres y texto.

El juego de caracteres (Character Set) es una colección de caracteres, cada carácter tiene un número único. Los juegos de caracteres comunes incluyen ASCII, Unicode, etc. Un conjunto de caracteres define la asignación entre caracteres y números.

ASCII (Código estándar estadounidense para el intercambio de información) es uno de los conjuntos de caracteres más antiguos y más utilizados. Utiliza números binarios de 7 bits (0-127) para representar 128 caracteres, incluidas letras en inglés, números y algunos signos de puntuación. El conjunto de caracteres ASCII es el conjunto de caracteres utilizado por el inglés y otros países occidentales.

Con el desarrollo de la tecnología informática, ha habido más necesidades de representar caracteres de varios idiomas en todo el mundo. Unicode nació. Unicode es un juego de caracteres estándar internacional que proporciona números únicos para casi todos los caracteres del mundo. Unicode utiliza una variedad de esquemas de codificación para representar caracteres, los más utilizados son UTF-8 y UTF-16.

UTF-8 (Unicode Transformation Format-8) es un esquema de codificación de longitud variable que utiliza números binarios de 8 bits (0-255) para representar caracteres Unicode. UTF-8 puede representar caracteres ASCII, así como otros caracteres Unicode, por lo que es compatible con versiones anteriores de ASCII.

UTF-16 (Unicode Transformation Format-16) es un esquema de codificación de longitud fija que utiliza números binarios de 16 bits (0-65535) para representar caracteres Unicode. UTF-16 es adecuado para representar la mayoría de los caracteres Unicode, pero ocupará más espacio de almacenamiento que UTF-8.

La codificación de caracteres (Character Encoding) es una regla que convierte los caracteres de un conjunto de caracteres en un formato binario reconocible por computadora. Utiliza una tabla de codificación para representar el mapeo entre caracteres y números.

En Java, la codificación predeterminada para cadenas es UTF-16. Cuando tratamos con texto en programas Java, generalmente usamos Stringclases para representar cadenas, y esta clase usa codificación UTF-16 para almacenar y procesar datos de cadenas.

En el desarrollo real, debemos prestar atención al uso y la conversión correctos de la codificación de caracteres. Si está tratando con datos de texto en un entorno diferente, puede usar getBytes()el método Convertir una cadena en una matriz de bytes específica, o usar new String(byte[], charset)Convertir una matriz de bytes en una cadena en una codificación específica.

Métodos comunes de codificación de caracteres

Los métodos de codificación de caracteres comunes incluyen ASCII, UTF-8, UTF-16 e ISO-8859-1.

  1. ASCII (Código estándar estadounidense para el intercambio de información):

    • Rango de codificación: representado por números binarios de 7 bits, incluidos 0-127 caracteres.
    • Características: ASCII es el método de codificación de caracteres más antiguo y más utilizado, principalmente para la representación de caracteres en inglés y otros países occidentales. Solo puede representar letras latinas básicas, números y algunos signos de puntuación, no se admiten caracteres no latinos ni caracteres especiales.
    • Cuándo usar: Adecuado para representaciones de inglés, números y puntuación básica.

  2. UTF-8 (formato de transformación Unicode-8):

    • Rango de codificación: codificación de longitud variable, que utiliza números binarios de 8 bits para representar caracteres Unicode.
    • Características: UTF-8 es un método de codificación del estándar Unicode, que puede representar casi todos los caracteres Unicode. Para caracteres ASCII, UTF-8 es compatible con la codificación ASCII. Ahorra más espacio de almacenamiento que UTF-16 cuando representa caracteres no latinos, ya que utiliza codificación de longitud variable y asigna bytes de diferentes longitudes según diferentes caracteres.
    • Escenario de uso: un método de codificación de caracteres universal, adecuado para casi todos los datos de texto, especialmente adecuado para la transmisión y el almacenamiento de Internet.

  3. UTF-16 (formato de transformación Unicode-16):

    • Rango de codificación: codificación de longitud fija, utilizando números binarios de 16 bits para representar caracteres Unicode.
    • Características: UTF-16 también es un método de codificación del estándar Unicode, que puede representar casi todos los caracteres Unicode. En comparación con UTF-8, UTF-16 ocupará más espacio de almacenamiento al representar caracteres no latinos, ya que utiliza una codificación de 16 bits de longitud fija.
    • Escenarios de uso: adecuado para escenarios que requieren codificación de longitud fija y acceso aleatorio a las posiciones de los caracteres, como el procesamiento de cadenas internas del sistema y aplicaciones específicas.

  4. ISO-8859-1（Latín-1）：

    • Rango de codificación: representado por números binarios de 8 bits, incluidos 0-255 caracteres.
    • Características: ISO-8859-1 es un método de codificación de caracteres definido por la Organización Internacional de Normalización. Es una extensión de la codificación ASCII y puede representar más caracteres de Europa occidental. Sin embargo, ISO-8859-1 solo puede representar algunos caracteres de idiomas europeos y no admite caracteres de la mayoría de los demás idiomas del mundo.
    • Escenario de uso: se utiliza principalmente para la representación de texto en idiomas de Europa occidental y no es adecuado para entornos multilingües o escenarios de aplicaciones de globalización.

Además de los métodos de codificación de caracteres comunes mencionados anteriormente, existen otros métodos de codificación, como GBK, GB2312, Big5, etc., que se utilizan principalmente para la representación de caracteres de los idiomas chino y asiático oriental.

En el proceso de desarrollo real, es necesario seleccionar un método de codificación de caracteres adecuado para procesar y almacenar datos de texto de acuerdo con las necesidades y los entornos específicos. Asegúrese de que el método de codificación utilizado pueda cubrir el rango de caracteres requerido y preste atención a la conversión y el procesamiento correctos de la codificación de caracteres para evitar problemas de caracteres ilegibles o faltantes.

Introducción a los métodos de codificación y decodificación de cadenas

  1. Una cadena se codifica como una secuencia de bytes:

    • Utilice el método getBytes(): este método puede codificar una cadena en una matriz de bytes de acuerdo con el conjunto de caracteres especificado. Por ejemplo, para codificar una cadena como una matriz de bytes mediante la codificación UTF-8:byte[] bytes = str.getBytes("UTF-8");
    • Use la clase de conversión de codificación de cadenas: Java proporciona las clases Charset y CharsetEncoder para la conversión de codificación de cadenas. El código de ejemplo es el siguiente:
      Charset charset = Charset.forName("UTF-8");
CharsetEncoder encoder = charset.newEncoder();
ByteBuffer buffer = encoder.encode(CharBuffer.wrap(str));
byte[] bytes = buffer.array();

  2. Secuencia de bytes decodificada a cadena:

    • Usando el constructor: un objeto de cadena se puede crear y decodificar usando el conjunto de caracteres especificado. Por ejemplo, para decodificar una matriz de bytes en una cadena usando el juego de caracteres UTF-8:String str = new String(bytes, "UTF-8");
    • Use la clase de conversión de codificación de cadenas: Java proporciona las clases Charset y CharsetDecoder para la conversión de decodificación de cadenas. El código de ejemplo es el siguiente:
      Charset charset = Charset.forName("UTF-8");
CharsetDecoder decoder = charset.newDecoder();
CharBuffer buffer = decoder.decode(ByteBuffer.wrap(bytes));
String str = buffer.toString();

  3. Codificación y decodificación de URL:

    • Codificación de URL mediante la clase URLEncoder: puede utilizar la clase URLEncoder para codificar cadenas de URL y convertir caracteres especiales en un formato seguro para URL. El código de ejemplo es el siguiente:
      String encodedStr = URLEncoder.encode(str, "UTF-8");
    • Use la clase URLDecoder para la decodificación de URL: puede usar la clase URLDecoder para decodificar la cadena codificada en URL y restaurarla a la cadena original. El código de ejemplo es el siguiente:
      String decodedStr = URLDecoder.decode(encodedStr, "UTF-8");

  4. Codificación y decodificación Base64:

    • Codificación Base64 utilizando la clase Base64: Java proporciona la clase Base64, que puede realizar la codificación Base64 en una matriz de bytes para obtener una representación de cadena Base64. El código de ejemplo es el siguiente:
      byte[] encodedBytes = Base64.getEncoder().encode(bytes);
String base64Str = new String(encodedBytes, StandardCharsets.UTF_8);
    • Decodificación Base64 usando la clase Base64: puede usar la clase Base64 para decodificar la cadena codificada en Base64 y restaurarla a la matriz de bytes original. El código de ejemplo es el siguiente:
      byte[] decodedBytes = Base64.getDecoder().decode(base64Str);

7. Conversión de cadenas y otros tipos de datos

Conversión de cadenas a tipos de datos básicos

  1. Cadena al tipo de datos básico:

    • Utilice el método estático de la clase contenedora: cada tipo de datos básico tiene una clase contenedora correspondiente, como Integer, , Doubleetc. Estas clases contenedoras proporcionan métodos estáticos para convertir cadenas en los tipos correspondientes, como Integer.parseInt(), Double.parseDouble()etc. Por ejemplo:
      String str = "123";
int num = Integer.parseInt(str);
double decimal = Double.parseDouble(str);
    • Utilice el método valueOf: todas las clases contenedoras proporcionan valueOfmétodos para convertir la cadena correspondiente en un objeto de clase contenedora del tipo correspondiente. Los objetos de la clase contenedora se pueden convertir en tipos de datos primitivos mediante el desempaquetado automático. Por ejemplo:
      String str = "123";
Integer integer = Integer.valueOf(str);
int num = integer.intValue();

  2. Convierta tipos de datos básicos en cadenas:

    • Uso de la concatenación de cadenas: puede usar la concatenación de cadenas (+) para convertir tipos de datos primitivos en cadenas. Por ejemplo:
      int num = 123;
String str = "" + num;
    • Use el método valueOf de la clase String: todas las clases contenedoras y los tipos de datos básicos han implementado toString()el método, y puede usar String.valueOf()o llamar directamente al método del objeto toString()para convertir el tipo de datos básico en una cadena. Por ejemplo:
      int num = 123;
String str = String.valueOf(num);

Cabe señalar que cuando la cadena no se puede convertir correctamente al tipo correspondiente, NumberFormatExceptionse lanzará una excepción. Por lo tanto, al convertir una cadena a un tipo de datos primitivo, es necesario asegurarse de que la cadena tenga el formato correcto.

Además, se han introducido nuevos métodos basados ​​en secuencias en Java 8 y versiones posteriores, que pueden manejar de manera más conveniente la conversión entre cadenas y tipos de datos primitivos. Por ejemplo, Integerla clase proporciona versiones sobrecargadas de parseInt()los valueOf()métodos y que permiten especificar la base (base) al convertir. Estos nuevos métodos proporcionan una forma más flexible de conversión.

Conversión de cadena a tipo de fecha y hora

  1. Cadena al tipo de fecha y hora:

    • Trabajar con SimpleDateFormatclases: SimpleDateFormatLas clases son clases para formatear y analizar fechas y horas. Puede usar sus parse()métodos para analizar una cadena en un tipo de fecha. Por ejemplo:
      String str = "2023-06-29 12:34:56";
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = format.parse(str);
    • Uso de DateTimeFormatterclases (Java 8 y posterior): DateTimeFormatterlas clases son clases de manejo de fecha y hora introducidas en Java 8. Puede usar sus parse()métodos para analizar una cadena en un tipo de fecha y hora. Por ejemplo:
      String str = "2023-06-29 12:34:56";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime dateTime = LocalDateTime.parse(str, formatter);

  2. Convierta el tipo de fecha y hora en una cadena:

    • Usando SimpleDateFormatclases: puede usar los métodos SimpleDateFormatde la clase format()para formatear el tipo de fecha como una cadena. Por ejemplo:
      Date date = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = format.format(date);
    • Uso DateTimeFormatterde clases (Java 8 y posterior): puede usar los métodos DateTimeFormatterde una clase format()para formatear tipos de fecha y hora como cadenas. Por ejemplo:
      LocalDateTime dateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String str = dateTime.format(formatter);

Cabe señalar que al usar SimpleDateFormatla clase o DateTimeFormatter, debe usar el patrón de formato de fecha y hora correcto (patrón) para especificar el formato de la cadena. Por ejemplo, yyyypara representar el año, MMpara representar el mes, ddpara representar la fecha, HHpara representar la hora (sistema de 24 horas), mmpara representar el minuto, sspara representar el segundo, etc.

Además, Java 8 introdujo java.timepaquetes para proporcionar clases de procesamiento de fecha y hora más potentes y flexibles. Además LocalDateTime, hay LocalDate, y otras clases que se pueden usar para manejar la fecha y la hora con diferentes granularidades LocalTime. ZonedDateTimeEstas nuevas clases de fecha y hora también proporcionan métodos de conversión hacia y desde cadenas, que se usan de manera similar a los ejemplos anteriores.

8. Internacionalización y localización de cadenas

Soporte de internacionalización para la plataforma Java

La plataforma ava proporciona un sólido soporte de internacionalización (Internationalization, denominado i18n), lo que permite a los desarrolladores escribir fácilmente aplicaciones con características regionales y multilingües.

  1. Localización:

    • LocaleClase: Localeuna clase representa un idioma y una configuración regional específicos. Se puede utilizar para identificar diferentes idiomas, países y culturas. Las clases Localele permiten especificar el idioma o la región a usar, lo que garantiza que su aplicación muestre el contenido localizado correcto en diferentes entornos.
    • Paquete de recursos: un paquete de recursos es una colección que contiene información de localización. Cada idioma o región puede tener un paquete de recursos correspondiente, que contiene información como texto, imágenes y formatos relacionados con el idioma o la región. Los paquetes de recursos en Java generalmente se almacenan en archivos .properties y cada archivo corresponde al contenido de recursos de un idioma o región.

  2. Codificación de caracteres y procesamiento de texto:

    • CharsetClase: Charsetuna clase representa un conjunto de codificación de caracteres. Java usa el conjunto de caracteres Unicode como codificación interna, pero los datos y archivos externos pueden usar una codificación de caracteres diferente. A través Charsetde la clase, se puede realizar la conversión y el procesamiento de conjuntos de caracteres para garantizar la conversión y el procesamiento correctos del contenido de texto entre diferentes codificaciones de caracteres.
    • StringClases y MessageFormatclases: las clases de Java Stringproporcionan muchos métodos para el procesamiento de texto localizado, como la concatenación de cadenas y el formateo. MessageFormatLa clase proporciona funciones de formato de cadena más avanzadas y puede realizar operaciones complejas de formato y reemplazo de mensajes de acuerdo con el idioma y la región especificados.

  3. Manejo de fecha y hora:

    • java.timePaquetes: Java 8 presenta nuevas API de fecha y hora, ubicadas java.timeen paquetes. Proporciona un poderoso conjunto de clases y métodos para trabajar con fechas y horas en diferentes granularidades, así como operaciones relacionadas con la zona horaria. Estas clases pueden dar formato a la información de fecha y hora según el idioma y la configuración regional especificados.
    • DateFormatclass: DateFormatclass es la clase de formato de fecha heredada, ubicada java.texten el paquete. Proporciona funciones básicas de formateo de fecha y hora, y puede realizar formateo localizado de acuerdo con el idioma y la región especificados.

  4. Formato de número y moneda:

    • NumberFormatClases: NumberFormatLas clases son clases para formatear números y se encuentran java.texten el paquete. Puede dar formato a cosas como números, porcentajes y monedas según el idioma y la configuración regional especificados.
    • CurrencyClase: Currencyuna clase es una clase que representa una moneda, que proporciona información sobre la moneda, como el código de moneda, el símbolo, los lugares decimales, etc. Clases Currencyque permiten que los valores de moneda tengan el formato correcto para el idioma y la configuración regional especificados.

  5. Convenciones de formato para la hora y la moneda:

    • LocaleClases e java.util.spi.LocaleServiceProviderinterfaces: mediante el uso Localede clases, se pueden especificar convenciones de formato para el tiempo y la moneda. Diferentes idiomas y regiones pueden tener diferentes convenciones para los formatos de hora, fecha y moneda, y la plataforma Java proporciona un conjunto de Localeinterfaces de convenciones de localización basadas en clases para manejar estas diferencias.

Cómo se localizan las cadenas

  1. Use Resource Bundle:
    Resource Bundle es un método de procesamiento de localización común en Java, a través del cual las cadenas relacionadas con la localización se pueden almacenar en diferentes archivos de propiedades, y cada archivo de propiedades corresponde a un idioma o región. Los paquetes de recursos suelen utilizar archivos .properties y el contenido se expresa en forma de pares clave-valor.

    • Cree un paquete de recursos: cree un archivo .properties, por ejemplo messages.properties, en el que almacenar las cadenas de idioma predeterminadas. Luego cree archivos de atributos correspondientes para diferentes idiomas y regiones, como el messages_zh_CN.propertieschino simplificado.
    • Cargar paquete de recursos: en el código Java, use ResourceBundlela clase para cargar el archivo del paquete de recursos correspondiente. El idioma y la región se pueden especificar según sea necesario, si no se especifica, se utilizará el idioma y la región predeterminados del sistema.
    • Obtener cadena localizada: use ResourceBundlela clase para obtener la cadena localizada correspondiente de acuerdo con la clave especificada.

    El código de ejemplo es el siguiente:

    // 加载资源包
ResourceBundle bundle = ResourceBundle.getBundle("messages", new Locale("zh", "CN"));
// 获取本地化字符串
String localizedString = bundle.getString("hello.world");

  2. Use la clase MessageFormat:
    MessageFormatla clase es una clase de herramienta proporcionada por Java para formatear cadenas, que puede realizar operaciones complejas de formateo y reemplazo de mensajes de acuerdo con el idioma y la región especificados. La sustitución dinámica se puede lograr mediante el uso de marcadores de posición y parámetros en la cadena.

    El código de ejemplo es el siguiente:

    String pattern = "Hello, {0}! Today is {1}.";
String name = "John";
String date = DateFormat.getDateInstance(DateFormat.FULL).format(new Date());
String formattedString = MessageFormat.format(pattern, name, date);

    En el ejemplo anterior, patternes una cadena con marcadores de posición y MessageFormat.format()el método reemplazará los parámetros entrantes con los marcadores de posición correspondientes según el idioma y la región especificados.

  3. Use la clase StringFormat:
    String.format()el método es un método de formato de cadena de uso común en Java y también admite la localización. Este método puede realizar la salida formateada de la cadena utilizando la cadena de formato y los parámetros.

    El código de ejemplo es el siguiente:

    String name = "Alice";
int age = 30;
String localizedString = String.format("My name is %s and I'm %d years old.", name, age);

    En el ejemplo anterior, %sy %dson marcadores de posición para el formato de cadena, String.format()el método reemplazará los parámetros entrantes con los marcadores de posición correspondientes según el idioma y la región especificados.

Supongo que te gusta

Origin blog.csdn.net/u012581020/article/details/131455658
Recomendado
Clasificación
Diario
Más
2024-05-04(17)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(33)
2024-04-29(5)
2024-04-28(9)
2024-04-27(28)
2024-04-26(22)
2024-04-25(34)

Code World

© 2018 codetd.com