Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. ¿Qué es la clase String?

Creo que ustedes entraron en contacto con cadenas cuando estaban aprendiendo el lenguaje C, pero en el lenguaje C solo pueden usar
Matriz de caracteres char[10] str = “hola” o puntero de carácter char *str = “hola”;No se proporciona ninguna clase String dedicada . En Java orientado a objetos, la clase String y sus operaciones se proporcionan especialmente, lo que es más conveniente de usar para nuestros programadores.

Inmutabilidad de cuerdas

El contenido de la cadena no se puede cambiar.

• Los caracteres de la clase String en realidad mantienen una matriz de caracteres llamada valor.
• La clase String se modifica con final, lo que significa que final no se puede heredar.
• Final modifica el valor, lo que significa que el valor no puede hacer referencia a otras matrices, ¡pero el contenido de la matriz aún se puede cambiar!

En String, todas las operaciones que implican la posibilidad de modificar el contenido de la cadena crean un nuevo objeto, y lo que se cambia es el nuevo objeto.
Por ejemplo, al buscar subcadenas:

Algunas personas dicen: Las cadenas son inmutables porque la matriz que almacena los caracteres dentro de ellas se modifica con final y, por lo tanto, no se puede cambiar.

• Esta afirmación es incorrecta.。 Primero, la modificación final de String indica que la clase String es la clase final y no se puede modificar ni heredar. El tipo de referencia modificado final indica que la variable de referencia no puede hacer referencia a otros objetos, pero el contenido del objeto referenciado aún se puede modificar.

  public static void main(String[] args) {
        final char[] arr = {'h','e','l','l','o'};
        arr[0] = 'H';
        System.out.println(String.valueOf(arr));//Hello
        // arr = new char[]{'h','o'};Error

    }
1
2
3
4
5
6
7

2. Uso básico de la clase String

1 construcción de cuerdas

String es un tipo de datos de referencia y no almacena la cadena en sí.

public class Test {
    public static void main(String[] args) {
        //1.直接赋值
        String s1 = "first";
        //2.new 对象
        String s2 = new String("second");
        //3. 创建字符数组
        char[] arr = {'t','h','i','r','d'};
        String s3 = new String(arr);
        
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Aviso:
Cadena s1 = “primero”;
La máquina virtual Java (JVM) primero verificará si la cadena "primera" ya existe en el grupo constante de cadenas. Si existe, la referencia de la cadena en el grupo de constantes se devuelve directamente; si no existe, la cadena se agrega al grupo de constantes y se devuelve su referencia en el grupo de constantes.

2 Comparación de objetos String

1. == Compara si son la misma referencia

     //s1 s2 分别是new 一个新的字符串"hello"
    String s1 = new String("hello");
	String s2 = new String("hello");
	String s3 = "Hello";
	String s4 = s1;

	System.out.println(s1 == s2);//false
 	System.out.println(s1 == s4);//true
	System.out.println(s1 == s3);//false
1
2
3
4
5
6
7
8
9

2. equals() usa y para determinar si dos cadenas son iguales, devuelve verdadero si son iguales; de lo contrario, falso

      
        //因为Object类中的equals()方法是==实现的，完成不了String类的需求，
        //所以String对equals()实现了重写

        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = "Hello";
        String s4 = s1;

        System.out.println(s1.equals(s2));//true
       	System.out.println(s1.equals(s4));//true
        System.out.println(s1.equals(s3));//false
1
2
3
4
5
6
7
8
9
10
11
12

3. compareTo() compara en orden lexicográfico, el valor de retorno es int

        /*
        * 比较的方式有一下两种：
        * 1.先一个一个字符相比较，如果出现不同的字符，则返回差值
        * 2.如果前x个字符相等，则返回两个字符串的长度差值
        * */

        String s1 = new String("abc");
        String s2 = new String("abcdef");
        String s3 = new String("abd");
        String s4 = new String("abc");
        
        System.out.println(s1.compareTo(s2));//-3 (3-6)
        System.out.println(s1.compareTo(s3));//-1
        System.out.println(s1.compareTo(s4));//0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4. compareToIgnoreCase() Igual que el método compareTo, pero ignora mayúsculas y minúsculas

        String s1 = new String("Abc");
        String s2 = new String("aBcdef");
        String s3 = new String("aBd");
        String s4 = new String("ABc");

        System.out.println(s1.compareToIgnoreCase(s2));//-3 (3-6)
        System.out.println(s1.compareToIgnoreCase(s3));//-1
        System.out.println(s1.compareToIgnoreCase(s4));//0

1
2
3
4
5
6
7
8
9
10

3. Búsqueda de cadenas

 public static void main(String[] args) {
 
        String s = "Hello, how are you today?";
        System.out.println(s.charAt(2)); //l
        System.out.println(s.indexOf('H')); //0
        System.out.println(s.indexOf('l',2)); //从第二个开始找 2
        System.out.println(s.indexOf("are")); //11
        System.out.println(s.indexOf("are",12)); // 未找到-1
        System.out.println(s.lastIndexOf('l')); //从后往前数 3
        System.out.println(s.lastIndexOf('l',3));// 从第三个往后数 3
        System.out.println(s.lastIndexOf("how"));// 7
        System.out.println(s.lastIndexOf("how",6));// 未找到 -1

    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.Conversión

1. Conversión de números y cadenas.

		String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("Hanmeimei", 18));
        System.out.println(s1);//1234 String
        System.out.println(s2);//12.34 String
        System.out.println(s3);//true String
        System.out.println(s4);//Student@1b6d3586
        System.out.println("=================================");
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);//1234
        System.out.println(data2);//12.34
1
2
3
4
5
6
7
8
9
10
11
12
13

2. Conversión de casos

 		String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.toUpperCase());//HELLO
        System.out.println(s1.toLowerCase());//hello
1
2
3
4

3. Cadena a matriz de caracteres y matriz de caracteres a cadena

 		//字符串转字符数组
        String s = "What can I say!";
        char[] arr = s.toCharArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        System.out.println();
        //字符数组转字符串
        String s1 = new String(arr);
        System.out.println(s1);
1
2
3
4
5
6
7
8
9
10

4.Formato

		//格式化
        String s = String.format("%d/%02d/%d",2024,07,10);
        System.out.println(s);//2024/07/10
1
2
3

5. Reemplazo de cuerdas

		String s = "What can I say say!";
        System.out.println(s.replaceAll("say","look"));
        System.out.println(s.replaceFirst("say","SAY"));

        //What can I look look!
        //What can I SAY say!
1
2
3
4
5
6

6. División de cuerdas

 		//字符串拆分
        String s = "字 符 串 拆 分";
        String[] str = s.split(" ");
        for(String i : str) {
            System.out.print(i+"|");
        }
        System.out.println();
        String[] str2 = s.split(" ",2);
        for(String i : str2) {
            System.out.println(i);
        }
        
        /*
        * 输出：
        字|符|串|拆|分|
        字
        符 串 拆 分
        * */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

       /*
       *拆分是特别常用的操作：
       * 一定要重点掌握
       *另外有些特殊字符（通配符）作为分割符可能无法正确切分, 需要加上转义.
       * */
       String s2 = "192.168.1.16" ;
       String[] result = s2.split("\.") ;
       for(String i: result) {
           System.out.println(i);
       }
       System.out.println("\");
       //为了匹配字面上的点号，你需要使用反斜杠（）来转义它，
       // 但在Java字符串中，反斜杠本身也是一个转义字符，
       // 所以你需要使用双反斜杠（\）来表示一个字面量上的反斜杠。
       
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7. Intercepción de cuerdas

	 //字符串截取
        String s = "What can I say!";
        System.out.println(s.substring(6));//an I say!
        System.out.println(s.substring(0,3));//What
1
2
3
4

8. Elimine los espacios iniciales y finales de las cadenas.

	 String s = "   yy ds       ";
        System.out.println(s.trim());//yy ds
1
2

10. Modificación de cuerdas

La clase String no se puede modificar. Todas las modificaciones crearán nuevos objetos, lo cual no es eficiente.

Esto es solo 10000, que son 341 ms. Si desea modificarlo, se recomienda utilizar StringBuffer o StringBuilder.

3. StringBuffer y StringBuilder

Debido a la naturaleza inmutable de String, para facilitar la modificación de cadenas, Java también proporciona las clases StringBuilder y StringBuffer. Y la mayoría de los métodos de estas dos clases son iguales.
Si está interesado, haga clicDocumentación en línea

1 ms después de usar StringBuffer.

Nota: Las clases String y StringBuilder no se pueden convertir directamente. Si desea convertirse entre sí, puede utilizar los siguientes principios:

• String se convierte en StringBuilder: utilice el método constructor o append() de StringBuilder
• StringBuilder se convierte en String: llama al método toString()

La diferencia entre String, StringBuffer y StringBuilder

• El contenido de String no se puede modificar, pero sí el contenido de StringBuffer y StringBuilder.
• StringBuffer utiliza procesamiento sincrónico y es una operación segura para subprocesos; StringBuilder no utiliza procesamiento sincrónico y es una operación insegura para subprocesos.
  hacer

La llamada seguridad del hilo es como cuando varias personas van al baño. En este momento, solo hay una habitación. Usted entra primero, cierra la puerta y sale cuando termina. Durante este período, tendrás esta habitación para ti solo y nadie podrá entrar. Primero complete la tarea actual, monopolice los recursos y luego libere los recursos ocupados una vez completada.