Compartilhamento de tecnologia

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

1. O que é a classe String?

Acho que vocês tiveram contato com strings quando estavam aprendendo a linguagem C, mas na linguagem C você só pode usar
Matriz de caracteres char[10] str = “olá” ou ponteiro de caractere char *str = “olá”;Nenhuma classe String dedicada é fornecida . Em Java orientado a objetos, a classe String e suas operações são fornecidas especialmente, o que é mais conveniente para nossos programadores usarem.

Imutabilidade de string

O conteúdo da string não pode ser alterado.

• Os caracteres da classe String, na verdade, mantêm uma matriz de caracteres chamada valor.
• A classe String é modificada por final, o que significa que final não pode ser herdado.
• Final modifica o valor, o que significa que o valor não pode se referir a outros arrays, mas o conteúdo do array ainda pode ser alterado!

Em String, todas as operações que envolvem a possibilidade de modificar o conteúdo da string criam um novo objeto, e o que é alterado é o novo objeto.
Por exemplo, ao pesquisar substrings:

Algumas pessoas dizem: Strings são imutáveis ​​porque o array que armazena os caracteres dentro delas é modificado por final e, portanto, não pode ser alterado.

• Esta afirmação está incorreta。 Primeiro, a modificação final de String indica que a classe String é a classe final e não pode ser modificada ou herdada. O tipo de referência modificado final indica que a variável de referência não pode fazer referência a outros objetos, mas o conteúdo do objeto referenciado ainda pode ser modificado.

  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 da classe String

1 Construção de cordas

String é um tipo de dados de referência e não armazena a string em si.

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

Perceber:
String s1 = “primeiro”;
A Java Virtual Machine (JVM) verificará primeiro se a string "first" já existe no conjunto de constantes de string. Se existir, a referência da string no pool de constantes é retornada diretamente; se não existir, a string é adicionada ao pool de constantes e sua referência no pool de constantes é retornada;

2 Comparação de objetos String

1. == Compara se são a mesma referência

     //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 e para determinar se duas strings são iguais, retorna verdadeiro se for igual, caso contrário, 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 em ordem lexicográfica, o valor de retorno é 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() O mesmo que o método compareTo, mas ignora maiúsculas e 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. Pesquisa de strings

 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.Conversão

1. Conversão de números e strings

		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. Conversão de caso

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

3. String para matriz de caracteres e matriz de caracteres para string

 		//字符串转字符数组
        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.Formatação

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

5. Substituição de cordas

		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. Divisão de cordas

 		//字符串拆分
        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. Interceptação de cordas

	 //字符串截取
        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. Remova espaços iniciais e finais de strings

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

10. Modificação de string

A classe String não pode ser modificada. Todas as modificações criarão novos objetos, o que não é eficiente.

Isso é apenas 10.000, que é 341ms. Se você quiser modificá-lo, é recomendado usar StringBuffer ou StringBuilder.

3. StringBuffer e StringBuilder

Devido à natureza imutável de String, para facilitar a modificação de strings, Java também fornece classes StringBuilder e StringBuffer. E a maioria dos métodos dessas duas classes são iguais.
Se você estiver interessado, por favor cliqueDocumentação on-line

1ms depois de usar StringBuffer.

Nota: As classes String e StringBuilder não podem ser convertidas diretamente. Se quiserem converter-se, podem adotar os seguintes princípios:

• String se torna StringBuilder: Use o construtor ou método append() de StringBuilder
• StringBuilder se torna String: chama o método toString()

A diferença entre String, StringBuffer e StringBuilder

• O conteúdo de String não pode ser modificado, mas o conteúdo de StringBuffer e StringBuilder pode ser modificado.
• StringBuffer usa processamento síncrono e é uma operação segura para thread; StringBuilder não usa processamento síncrono e é uma operação insegura para thread.
  fazer

A chamada segurança do fio é como quando várias pessoas vão ao banheiro. Há apenas um cômodo no momento. Você entra primeiro, fecha a porta e sai depois de terminar. Durante este período, você tem este quarto só para você e ninguém pode entrar. Conclua primeiro a tarefa atual, monopolize os recursos e, em seguida, libere os recursos ocupados após a conclusão.