Méthodes courantes de la classe String

Classe de chaîne

Pas besoin de guider le paquet

En Java, toutes les données entre guillemets doubles sont un objet de String

String s = "abc";

Chaîne()

Initialisez un objet String nouvellement créé afin qu'il représente une séquence de caractères vide.

Chaîne （Chaîne d'origine）

Initialisez un objet String nouvellement créé pour qu'il représente la même séquence de caractères que la liste de paramètres: en d'autres termes, la chaîne créée par le cœur est une copie de la chaîne de paramètres

chaîne （char [] valeur）

Allouer une nouvelle chaîne pour représenter la séquence de caractères actuellement contenue dans le paramètre de tableau de caractères

Chaîne （char [] value, int offset, int count）

Allouez une nouvelle chaîne, qui contient les caractères tirés d'un tableau de mots du paramètre de tableau de chaînes.

Chaîne （octet [] octets）

Construisez une nouvelle chaîne en utilisant le jeu de caractères par défaut de la plate-forme pour décoder le tableau d'octets spécifié

Chaîne (octet [] octets, décalage int, longueur int)

Construisez une nouvelle chaîne en utilisant le jeu de caractères par défaut de la plate-forme pour décoder le sous-tableau d'octets spécifié

Étude de cas

public class StringConstructor {
      
      
    public static void main(String[] args) {
      
      
         // 1. 创建出一个空字符串序列  String()
         String s = new String(); // String s = "";
         System.out.println(s + "---");

         // 2. String(字符序列)
        String s1 = new String("hello");// String s = "hello"
        System.out.println(s1);// hello

      // 3. String(char[] ch) : 将参数char类型数组中的每一个字符, 拼接成一个字符串结果
        char[] ch = {
      
      'A','a','1','?','家'};
        String s2 = new String(ch);
        System.out.println(s2);// Aa1?家

        // 4. String(char[] ch, int beginIndex, int count): 将字符数组的一部分,转换成字符串
        // beginIndex 从指定索引位置开始
        // count 需要转换的字符个数
        String s3 = new String(ch,2,2);
        System.out.println(s3);// 1?

       // 5. String(byte[] b) : 将字节数组b, 参考编码表, 转换成字符, 将字符拼接成字符串
        byte[] b = {
      
      65,66,67,68};
        String s4 = new String(b);
        System.out.println(s4);// ABCD

        // 6. String(byte[] b, int beginIndex,int count): 将字节数组的一部分,转换成字符串
        String s5 = new String(b,1,2);
        System.out.println(s5);// BC
    }

Obtenir la fonction dans la classe String

longueur():

lenght (): Récupère le nombre de caractères dans une chaîne (la longueur de la chaîne), le type de valeur de retour est int

charAt (index int):

charAt (int index): récupère le caractère correspondant à la position d'index d'index spécifiée dans la chaîne, et le type de valeur de retour est char

subString (int beginIndex):

subString (int beginIndex): découpe une partie de la chaîne, de l'index beginIndex à la fin de toutes les séquences de caractères sont supprimées, la valeur de retour result, la nouvelle chaîne String

subString (int beginIndex, int endIndex):

subString (int beginIndex, int endIndex): intercepte la séquence de caractères de beginIndex à endIndex-1 dans une nouvelle chaîne et renvoie le résultat String.
Remarque: Dans la méthode JDK, si elle doit fonctionner sur deux positions d'index, généralement y compris start index, hors index de fin

indexOf (chaîne de caractères):

indexOf (String str): obtient la position d'index de la première occurrence de la chaîne de paramètre str dans la chaîne d'appel de méthode. Le
type de valeur de retour est int. Si la position du paramètre str est introuvable, renvoie -1

indexOf (chaîne str, int formIndex):

indexOf (String str, int formIndex): renvoie l'index de la première occurrence du caractère spécifié dans cette chaîne, à partir de l'index spécifié, le type de valeur de retour est int, si l'emplacement du paramètre str n'est pas trouvé, il retourne -1

lastIndexOf (chaîne de caractères):

lastIndexOf (String str): Récupère la position d'index de la dernière occurrence de la chaîne de paramètre str dans la chaîne d'appel de méthode
Valeur de retour type int, si la position du paramètre str n'est pas trouvée, renvoie -1

Code

public class StringGetMethod {
    
    
    public static void main(String[] args) {
    
    
        // 1. 获取字符串长度 length()
        String s = "hello  ";
        System.out.println(s.length());// 7

        // 2. charAt(int index): 将字符串中指定的index索引位置上对对应的字符获取到
        // 返回值类型char
        // 因为字符串底层存储就是一个字符数组, 字符数组的索引就对应了字符串中索引位置
        char ch = s.charAt(4);
        System.out.println(ch);// 'o'
        System.out.println(s.charAt(5) + "---");// ' '

        // 扩展 : 利用字符串有索引, 范围0---length()-1, 使用charAt方法,将每一个索引位置上
        // 的字符获取到, 形成了字符串的遍历
        for(int index = 0; index < s.length(); index++){
    
    
            char c = s.charAt(index);
            System.out.println(c);
        }

        // 3. subString(int beginIndex) : 截取出字符串的一部分,从beginIndex索引开始, 到最后
        // 的全部字字符串取出来, 返回值结果,新的字符串
        String s1 = "我在家?hello";
        String s1Sub = s1.substring(4);
        System.out.println(s1Sub);// hello

        // 4. subString(int beginIndex, int endIndex) : 从beginIndex到endIndex-1之间的字符序列截取
        // 成一个新的字符串, 返回值结果String
        // 注意 : JDK的方法中, 如果是对于两个索引位置进行操作, 通常包括开始索引, 不包括结束索引
        System.out.println(s1.substring(1,5));// 在家?h

        // 5. indexOf(String str) : 获取参数字符串str在方法调用字符串中第一次出现的索引位置
        // 返回值类型int, 如果没有找到参数str存在位置, 返回-1
        int index1 = s1.indexOf("he");
        System.out.println(index1);// 4

        int index2 = s1.indexOf("le");
        System.out.println(index2);// -1

        // 6. indexOf(String str, int formIndex):
        // 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
        int index3 = s1.indexOf("l",7);
        System.out.println(index3);// 7

        System.out.println("-----------------");

        // 7. lastIndexOf(String str) : 获取参数字符串str在方法调用字符串中最后一次出现的索引位置
        // 返回值类型int, 如果没有找到参数str存在位置, 返回-1
        System.out.println(s1.lastIndexOf("l"));// 7
        System.out.println(s1.lastIndexOf("哈哈"));// -1
    }

Fonction de conversion

byte [] getBytes (): Convertit la chaîne actuelle en un tableau d'octets
char [] toCharArray (): Convertit la chaîne actuelle en un tableau de caractères
toUpperCase (): Convertit la chaîne actuelle en majuscules
toLowerCase (): Convertit la chaîne actuelle en minuscules
Valeur statique de la famille: les données de tout type de données peuvent être converties en chaîne

Autres fonctions

1. Replace (String oldStr, String newStr): remplacez l'ancienne chaîne de l'appelant par une nouvelle chaîne, et la valeur de retour est la nouvelle chaîne après le remplacement

2. Split (String regex): Coupez la chaîne en fonction de la règle de regex de chaîne de paramètre, et le résultat est une chaîne []

3. trim (): supprimez les espaces et les tabulations sur les côtés gauche et droit de la chaîne