Comment utiliser la classe String, StringBuffer et StringBuilder en Java ?

Concepts de base de la classe String

• La classe String est un type de données de référence, pas un type de données de base.

• En Java, tant qu'il est placé entre " " (guillemets doubles), il s'agit d'un objet String.

• Java stipule que les chaînes entre guillemets doubles sont immuables, ce qui signifie que "abc" ne peut pas devenir "abcd" ou "ab" de la naissance à la mort.

• Dans le JDK, les chaînes entre guillemets doubles sont stockées dans le pool de constantes de chaîne dans la zone des méthodes. (Parce que dans le développement réel, la fréquence d'utilisation des chaînes est très élevée, par souci d'efficacité d'exécution, les chaînes sont placées dans le pool de constantes de chaînes dans la zone méthode)

Principe de stockage des chaînes des chaînes

• Grâce à String s = "abc", un objet sera créé dans le pool de constantes de chaîne dans la zone de méthode, et s enregistrera l'adresse de la chaîne dans le pool de constantes de chaîne.

• Créez un objet via String s = new String("abc") Tout d'abord, l'objet "abc" sera créé dans le pool de constantes de chaîne (s'il y a déjà "abc" dans le pool de constantes de chaîne, il le sera. ne sera pas créé à nouveau), alors un objet de classe String sera créé dans la zone du tas, qui stockera l'adresse de "abc" dans la zone de méthode, et s enregistrera l'adresse de l'objet String dans le tas.

Regardez le code suivant :

public class StringTest01 {
    //这两行代码表示创建3个字符串对象，且都在字符串常量池中
    String A = "abc";
    String B = "abc" + "de";
    //通过 new 来创建字符串对象,会先在字符串常量池中寻找"abc"
    //找不到的话就会在字符串常量池中创建一个"abc"对象
    //在堆中创建创建字符串对象，并且保存"abc"在字符串常量池中的地址
    String C = new String("abc");
}

D'après le code ci-dessus, dessinez le diagramme de mémoire JVM comme suit :

Après avoir connu le principe de stockage de la chaîne de classe String, vous pouvez facilement connaître le résultat de la compilation de le code suivant :

public class StringTest01 {
    public static void main(String[] args) {
        //没有在堆中创建对象
        //s1与s2都存的是"hello"在字符串常量池中的地址
        String s1 = "hello";
        String s2 = "hello";
        //在堆中创建了对象
        //m,n分别存的是他们在堆中对象的地址
        String m = new String("你好！");
        String n = new String("你好！");
        System.out.println(s1 == s2);//结果为true
        System.out.println(m == n);//结果为false
    }
}

Méthodes de construction courantes de la classe String

//String类构造方法的使用
public class StringTest02 {
    public static void main(String[] args) {
        byte []x1 = { 97 , 98 , 99 };
        char []x2 = {'我','是','中','国','人'};
        //String s = new String(byte数组);
        String y1 = new String(x1);
        System.out.println(y1);//ABC
        //String s = new String(byte数组，偏移量，长度)
        String y2  = new String(x1,1,2);
        System.out.println(y2);//BC
        //String s = new String(char数组)
        String y3 = new String(x2);
        System.out.println(y3);//我是中国人
        //String s = new String(char数组，偏移量，长度)
        String y4 = new String(x2,2,3);
        System.out.println(y4);//中国人
    }
}

Méthodes communes de la classe String

public class StringTest03 {
    public static void main(String[] args) {
        //public char charAt(int index)方法
        //返回索引值处的char类型字符
        char s1 = "中国人".charAt(1);
        System.out.println(s1);//国
        //public int compareTo(String anotherString)方法
        //按字典序比较两个字符串
        System.out.println("abc".compareTo("abd"));//负整数
        System.out.println("abc".compareTo("abc"));//0
        System.out.println("abc".compareTo("abb"));//正整数
        //public boolean contains(CharSequence s)方法
        //判断字符串是否包含s
        System.out.println("abcdefg".contains("efg"));//true
        System.out.println("abcdefg".contains("hij"));//false
        //public boolean endsWith(String suffix)方法
        //判断字符串是否以suffix结尾
        System.out.println("abcde".endsWith("cde"));//true
        System.out.println("abcde".endsWith("qwe"));//false
        //public boolean equalsIgnoreCase(String anotherString) 方法
        //判断两个字符串是否相等，忽略大小写
        System.out.println("ABcd".equalsIgnoreCase("abCD"));//true
        //public byte[] getBytes()
        //将字符串转换成byte数组，并返回
        byte [] s2 = "abcdefg".getBytes();
        for (int i = 0; i < s2.length; i++) {
            System.out.print(s2[i] + " ");
        }//97 98 99 100 101 102 103
        //public int indexOf(String str)
        //判断某个子字符串在当前字符串中第一次出现处的索引
        //若子字符串不存在，返回-1
        System.out.println("abcdefghigk".indexOf("hig"));//7
        System.out.println("abc".indexOf("fgh"));//-1
        //public int lastIndexOf(String str)
        //判断某个子字符串最后一次出现在当前字符串中的索引
        System.out.println("abcdhdhdabc".lastIndexOf("abc"));//8
        //public boolean isEmpty()
        //判断字符串是否为空串
        //底层调用length()方法，空串长度为0
        //注意：判断数组长度是length属性，判断字符串长度是length()方法
        System.out.println("".isEmpty());//true
        //public String replace(char oldChar,char newChar)
        //返回一个将原字符串中所有的oldChar替换为newChar的新字符串，不改变原字符串
        String s3 = "aaatttooo";
        System.out.println( s3.replace(&#39;t&#39;,&#39;q&#39;));//aaaqqqooo
        //public String replace(CharSequence target,CharSequence replacement)
        //CharSequence可以看出String
        //将原字符串中的 target 全部换成 replacement
        String s4 = "abcsgdjsssjabcjdjjdjabc";
        System.out.println(s4.replace("abc","www"));//wwwsgdjsssjwwwjdjjdjwww
        //public String[] split(String regex)
        //以regex为分界线，将字符串分割保存在一个字符串数组当中，并返回
        String s5 = "2022-3-19";
        String [] str = s5.split("-");
        System.out.println(str[0] + str[1] + str[2]);//2022319
        //public String substring(int beginIndex)
        //返回一个以索引beginIndex开始直至结尾的字符串
        System.out.println("abcdefgh".substring(4));//efgh
        //public String substring(int beginIndex,int endIndex)
        //返回一个以索引值beginIndex开始，以索引值endIndex结束(不包含该索引值处的字符)的子字符串
        System.out.println("abcdefgh".substring(2,5));//cde
        //public char[] toCharArray()
        //将一个字符串以字符数组的形式返回
        char[] str2 = "abcdefg".toCharArray();
        for(int i = 0 ; i < str2.length ; i++){
            System.out.println(str2[i]);
        }
        //public String toLowerCase()
        //返回一个将原字符串中所有字符变成小写的新字符串
        System.out.println("ABcDeFG".toLowerCase());//abcdefg
        //public String toUpperCase()
        //返回一个将原字符串中所有字符变成大写的新字符串
        System.out.println("aCbcdEfg".toUpperCase());//ABCDEFG
        //public String trim()
        // 返回一个去除字符串的前后空白(空格)的新字符串
        System.out.println("       abcdefg      ".trim());//abcdefg
        //public static String valueOf(参数列表)
        //参数列表可以是int型，char型，int数组，对象 等等.......
        //String类中唯一一个静态方法，可以直接调用
        //将非字符串转换为字符串
        //println()底层调用的就是valueOf()方法,只要是打印在控制台上的都是字符串
        System.out.println(String.valueOf(true));
    }
}

Classe StringBuffer

Réflexion :

• Quels sont les effets de l'utilisation fréquente de l'épissage de cordes ?

• Les chaînes en Java sont immuables. Chaque épissage produira une nouvelle chaîne

• L'utilisation fréquente de l'épissage de chaînes occupera beaucoup d'espace dans la zone de méthode. Afin d'éviter les problèmes ci-dessus, nous pouvons utiliser la classe StringBuffer

  //java.lang.StringBuffer
  public class StringBufferTest {
      public static void main(String[] args) {
          //创建一个初始化容量为16个 byte[] 数组(字符串缓冲区对象)
          StringBuffer strBuffer = new StringBuffer();
          //拼接字符串调用 append()方法
          //append()方法底层会调用 System.arraycopy()方法，效率较低
          //append()再追加时，如果byte[]满了之后会自动扩容
          strBuffer.append(1);
          strBuffer.append('q');
          strBuffer.append(3.14);
          strBuffer.append("abc");
          System.out.println(strBuffer);//1q3.14abc
          //StringBuffer可以进行一定的优化
          //在创建StringBuffer时尽可能可能给定一个合适的初始化容量
          //从而减少底层数组的扩容次数
          //指定初始化容量的字符串缓冲区
          StringBuffer newstrBuffer = new StringBuffer(100);
      }
  }

  Classe StringBuilder

  Son utilisation est très similaire à StringBuffer, mais il y a aussi de grandes différences :

  Les méthodes dans StringBuffer ont toutes le mot-clé synchronisé Modification, indiquant que StringBuffer est sûr dans un environnement de compilation multithread

  • Les méthodes de StringBuilder ne sont pas modifiées avec le mot-clé synchronisé, indiquant que StringBuilder n'est pas sûr dans un environnement de compilation multithread

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!