Une introduction détaillée à String, une classe courante en Java

Présentation La classe

java.lang.String représente une chaîne. Tous les littéraux de chaîne (tels que "abc") dans les programmes Java peuvent être considérés comme des instances qui implémentent cette classe.

String inclut des méthodes pour vérifier des chaînes individuelles, par exemple pour comparer des chaînes, rechercher une chaîne, extraire des sous-chaînes. , et crée une copie de la chaîne avec tous les caractères traduits en majuscules ou minuscules.

Caractéristiques

1 La chaîne est inchangée : la valeur de la chaîne ne peut pas être modifiée après la création

String s1 = "abc"; s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

2. .Parce que les objets String sont immuables, ils peuvent être partagés

String s1 = "abc"; 
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3 "abc" est équivalent à char[] data = {'a','b','c'}

.

Partage de vidéos d'apprentissage en ligne : vidéo Java

Étapes d'utilisation

Afficher la classe

java.lang.String Cette classe n'a pas besoin d'être importée.

Constructeur de vue

public String()：Initialise l'objet String nouvellement créé afin qu'il représente une séquence vide de caractères.

public String(char[] value)  : Construisez une nouvelle chaîne à partir du tableau de caractères dans le paramètre actuel.

public String(byte[] bytes) : Construit une nouvelle chaîne en décodant le tableau d'octets dans l'argument actuel en utilisant le jeu de caractères par défaut de la plateforme.

Exemple de construction, le code est le suivant :

Méthodes courantes

Méthodes de jugement des fonctions

public boolean equals (Object anObject)  : Comparez cette chaîne avec l'objet spécifié.

public boolean equalsIgnoreCase (String anotherString)  : Comparez cette chaîne avec l'objet spécifié, en ignorant la casse

de démonstration de la méthode, le code est le suivant :

Object signifie « objet » et est également un type de référence. En tant que type de paramètre, cela signifie que n’importe quel objet peut être transmis à la méthode.

Méthode d'obtention de la fonction

public int length () Renvoie la longueur de cette chaîne.

public String concat (String str)  : Concatène la chaîne spécifiée à la fin de la chaîne.

public char charAt (int index)  : renvoie la valeur du caractère à l'index spécifié.

public int indexOf (String str)：La position d'index de la première occurrence de la chaîne

public String substring (int beginIndex) : renvoie une sous-chaîne, interceptant la chaîne à partir du début de l'index jusqu'à la fin de la chaîne

public String substring (int beginIndex, int endIndex)  : renvoie une sous-chaîne, interceptant la chaîne de beginIndex à endIndex. Contient BeginIndex mais n’inclut pas EndIndex.

démonstration de la méthode, le code est le suivant :

public class String_Demo02 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "helloworld";

        // int length():获取字符串的长度，其实也就是字符个数
        // System.out.println(s.length()); 
        // System.out.println("‐‐‐‐‐‐‐‐");

        // String concat (String str):将将指定的字符串连接到该字符串的末尾. 
        // String s = "helloworld";
        String s2 = s.concat("**hello itheima");

        // char charAt(int index):获取指定索引处的字符
        // System.out.println(s.charAt(0));
        // System.out.println(s.charAt(1));
        // System.out.println("‐‐‐‐‐‐‐‐");

        // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
        // System.out.println(s.indexOf("l"));
        // System.out.println(s.indexOf("owo"));
        // System.out.println(s.indexOf("ak"));
        System.out.println("‐‐‐‐‐‐‐‐");

        // String substring(int start):从start开始截取字符串到字符串结尾
        // System.out.println(s.substring(0)); 
        // System.out.println(s.substring(5)); 
        // System.out.println("‐‐‐‐‐‐‐‐");

        // String substring(int start,int end):从start到end截取字符串。含start，不含end。
        // System.out.println(s.substring(0, s.length()));
        // System.out.println(s.substring(3,8));
    }
}

public char[] toCharArray () : Convertir cette chaîne en un nouveau tableau de chaînes

public byte[] getBytes () : Utiliser le jeu de caractères par défaut de la plateforme Convertissez l'encodage de chaîne en un nouveau tableau d'octets

public String replace (CharSequence target, CharSequence replacement)  : remplacez la chaîne correspondant à la cible par la chaîne de remplacement.

Démonstration de méthode, le code est le suivant :

public class String_Demo03 {
    public static void main(String[] args) {
        //创建字符串对象String s = "abcde";

        // char[] toCharArray():把字符串转换为字符数组
        // char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

        // byte[] getBytes ():把字符串转换为字节数组
        // byte[] bytes = s.getBytes();
        for (int x = 0; x < bytes.length; x++) {
            System.out.println(bytes[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");

        // 替换字母it为大写IT
        // String replace = str.replace("it", "IT");
        // System.out.println(replace);
        // ITcast ITheima System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    }
}

CharSequence est une interface et un type référence. En tant que type de paramètre, les objets String peuvent être transmis aux méthodes.

Méthode de fonction de division

public String[] split(String regex)Divisez cette chaîne en un tableau de chaînes selon la regex (règle) donnée.

Démonstration de méthode, le code est le suivant :

Exercice de classe String

Épissage de chaînes

Définissez une méthode pour épisser le tableau {1,2,3} en une chaîne selon le format spécifié. Le format est le suivant :

public class StringTest1 {
    public static void main(String[] args) {
        //定义一个int类型的数组
        // int[] arr = {1, 2, 3};

        //调用方法
        String s = arrayToString(arr);

        //输出结果System.out.println("s:" + s);
    }

    /*
     *写方法实现把数组中的元素按照指定的格式拼接成一个字符串
     *两个明确：
     *返回值类型：String
     *参数列表：int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 创建字符串s
        String s = new String("[");
        // 遍历数组，并拼接字符串
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                s = s.concat(arr[x] + "]");
            } else {
                s = s.concat(arr[x] + "#");
            }
        }
        return s;
    }

}

Nombre de caractères comptés

Entrez un caractère sur le clavier et comptez le nombre de lettres majuscules, minuscules et de caractères numériques dans la chaîne

Tutoriels d'articles associés recommandés : Débuter avec Java

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!