Classe de chaîne en Java

La classe String en Java est conçue pour fonctionner avec des chaînes en Java. Tous les littéraux de chaîne définis dans un programme Java (par exemple, « abc ») sont des instances de la classe String. Examinons ses principales caractéristiques :

1. La classe implémente les interfaces Serializableet CharSequence. Puisqu’il est inclus dans le package java.lang, il n’est pas nécessaire de l’importer.
2. La classe String en Java est une classe finale et ne peut pas avoir d'enfants.
3. La classe String est une classe immuable, ce qui signifie que ses objets ne peuvent pas être modifiés après leur création. Toute opération sur un objet String qui aboutirait à un objet de la classe String entraînera la création d'un nouvel objet.
4. En raison de leur immuabilité, les objets de la classe String sont thread-safe et peuvent être utilisés dans un environnement multithread.
5. Chaque objet en Java peut être converti en chaîne via une méthode toStringdont toutes les classes Java héritent de la classe Object.

Travailler avec une chaîne Java

C'est l'une des classes les plus couramment utilisées en Java. Il dispose de méthodes pour analyser certains caractères d'une chaîne, pour comparer et rechercher des chaînes, extraire des sous-chaînes, créer une copie d'une chaîne avec tous les caractères convertis en minuscules et majuscules, etc. Une liste de toutes les méthodes de la classe String peut être trouvée dans la documentation officielle . Java implémente également un mécanisme simple de concaténation (chaînes de connexion), convertissant les primitives en chaîne et vice versa. Examinons quelques exemples d'utilisation de la classe String en Java.

Création de chaînes

Le moyen le plus simple de créer une instance de la classe String est de lui attribuer la valeur d'une chaîne littérale :

String s = "I love movies";

Cependant, la classe String possède de nombreux constructeurs qui permettent de :

• créer un objet contenant une chaîne vide
• créer une copie d'une variable de chaîne
• créer une chaîne basée sur un tableau de caractères
• créer une chaîne basée sur un tableau d'octets (en tenant compte des encodages)
• etc.

Ajout de chaîne

L'ajout de deux chaînes en Java est assez simple en utilisant le +. Java vous permet d'ajouter des variables et des chaînes littérales les unes aux autres :

public static void main(String[] args) {
    String day = "Day";
    String and = "And";
    String night = "Night";

    String dayAndNight = day + " " + and + " " + night;
}

En ajoutant des objets de la classe String avec des objets d'autres classes, on réduit ces derniers sous forme de chaîne. La conversion d'objets d'autres classes en une représentation sous forme de chaîne est effectuée via un appel de méthode implicite toStringsur l'objet. Montrons cela avec l'exemple suivant :

public class StringExamples {
    public static void main(String[] args) {
        Human max = new Human("Max");
        String out = "java object: " + max;
        System.out.println(out);
        // Output: Java object: Person named Max
    }

    static class Human {
        private String name;

        public Human(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "The Man with the Name" + name;
        }
    }
}

Comparaison de chaînes

Pour comparer des chaînes, vous pouvez utiliser la méthode equals():

public static void main(String[] args) {
    String x = "Test String";
    System.out.println("Test String".equals(x)); // true
}

Lorsque la casse n'est pas importante pour nous lors de la comparaison de chaînes, nous devons utiliser la méthodeequalsIgnoreCase() :

public static void main(String[] args) {
       String x = "Test String";
       System.out.println("test string".equalsIgnoreCase(x)); // true
}

Conversion d'un objet/primitive en chaîne

Pour convertir une instance de n'importe quelle classe Java ou de n'importe quel type de données primitif en une représentation sous forme de chaîne, vous pouvez utiliser la méthodeString.valueOf() :

public class StringExamples {
    public static void main(String[] args) {
        String a = String.valueOf(1);
        String b = String.valueOf(12.0D);
        String c = String.valueOf(123.4F);
        String d = String.valueOf(123456L);
        String s = String.valueOf(true);
        String human = String.valueOf(new Human("Alex"));

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(s);
        System.out.println(human);
        /*
        Output:
        1
        12.0
        123.4
        123456
        true
        Person named Alex
         */
    }

    static class Human {
        private String name;

        public Human(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "The Man with the Name" + name;
        }
    }
}

Conversion d'une chaîne en nombre

Vous devez souvent convertir une chaîne en nombre. Les classes wrapper de type primitif ont des méthodes qui servent exactement cet objectif. Toutes ces méthodes commencent par le mot analyser. Considérez la traduction d'une chaîne en nombres entiers ( Integer) et fractionnaires ( Double) ci-dessous :

public static void main(String[] args) {
    Integer i = Integer.parseInt("12");
    Double d = Double.parseDouble("12.65D");

    System.out.println(i); // 12
    System.out.println(d); // 12.65
}

Conversion d'une collection de chaînes en une représentation sous forme de chaîne

Si vous devez convertir tous les éléments d'une collection de chaînes en une représentation sous forme de chaîne via un délimiteur arbitraire, vous pouvez utiliser les méthodes suivantes de la classe Java String :

• join(CharSequence delimiter, CharSequence... elements)
• join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

Où delimiterest le séparateur d'éléments et elementsest une instance de tableau de chaînes/de collection de chaînes. Regardons un exemple où nous convertissons une liste de chaînes en chaîne, en séparant chacune par un point-virgule :

public static void main(String[] args) {
    List<String> people = Arrays.asList(
            "Philip J. Fry",
            "Turanga Leela",
            "Bender Bending Rodriguez",
            "Hubert Farnsworth",
            "Hermes Conrad",
            "John D. Zoidberg",
            "Amy Wong"
    );

    String peopleString = String.join("; ", people);
    System.out.println(peopleString);
    /*
    Output:
    Philip J. Fry; Turanga Leela; Bender Bending Rodriguez; Hubert Farnsworth; Hermes Conrad; John D. Zoidberg; Amy Wong
     */
}

Diviser une chaîne en un tableau de chaînes

Cette opération est effectuée par la méthode split(String regex) Le séparateur est une expression régulière de chaîne regex. Dans l’exemple ci-dessous, nous effectuerons l’opération inverse de celle que nous avons effectuée dans l’exemple précédent :

public static void main(String[] args) {
    String people = "Philip J. Fry; Turanga Leela; Bender Bending Rodriguez; Hubert Farnsworth; Hermes Conrad; John D. Zoidberg; Amy Wong";

    String[] peopleArray = people.split("; ");
    for (String human : peopleArray) {
        System.out.println(human);
    }
    /*
    Output:
    Philip J. Fry
    Turanga Leela
    Bender Bending Rodriguez
    Hubert Farnsworth
    Hermes Conrad
    John D. Zoidberg
    Amy Wong
     */
}

Déterminer la position d'un élément dans une ligne

Dans le langage Java, String fournit un ensemble de méthodes pour déterminer la position d'un caractère/sous-chaîne dans une chaîne :

1. indexOf(int ch)
2. indexOf(int ch, int fromIndex)
3. indexOf(String str)
4. indexOf(String str, int fromIndex)
5. lastIndexOf(int ch)
6. lastIndexOf(int ch, int fromIndex)
7. lastIndexOf(String str)
8. lastIndexOf(String str, int fromIndex)

Où:

1. ch— le symbole que vous recherchez ( char)
2. str- chaîne de recherche
3. fromIndex— la position à partir de laquelle rechercher l'élément
4. méthodes indexOf- renvoie la position du premier élément trouvé
5. méthodes lastIndexOf- renvoie la position du dernier élément trouvé

Si l'élément que vous recherchez n'est pas trouvé, les méthodes renverront la ligne -1. Essayons de trouver le numéro de série des lettres A, K, Z, Яdans l'alphabet anglais, mais gardez à l'esprit que l'indexation des caractères dans une chaîne en Java commence à zéro :

public static void main(String[] args) {
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    System.out.println(alphabet.indexOf('A')); // 0
    System.out.println(alphabet.indexOf('K')); // 10
    System.out.println(alphabet.indexOf('Z')); // 25
    System.out.println(alphabet.indexOf('Я')); // -1
}

Extraire une sous-chaîne d'une chaîne

Pour extraire une sous-chaîne d'une chaîne, la classe String en Java fournit des méthodes :

• substring(int beginIndex)
• substring(int beginIndex, int endIndex)

Voyons comment utiliser les méthodes de positionnement d'élément et d'extraction de sous-chaîne pour obtenir le nom du fichier à partir de son chemin :

public static void main(String[] args) {
    String filePath = "D:\\Movies\\Futurama.mp4";
    int lastFileSeparatorIndex = filePath.lastIndexOf('\\');
    String fileName = filePath.substring(lastFileSeparatorIndex + 1);
    System.out.println(fileName); //9
}

Convertir une chaîne en majuscules/minuscules :

La classe String fournit des méthodes pour convertir une chaîne en majuscules et minuscules :

• toLowerCase()
• toUpperCase()

Regardons comment ces méthodes fonctionnent à l'aide d'un exemple :

public static void main(String[] args) {
    String fry = "Philip J. Fry";

    String lowerCaseFry = fry.toLowerCase();
    String upperCaseFry = fry.toUpperCase();

    System.out.println(lowerCaseFry); // philip j. fry
    System.out.println(upperCaseFry); // PHILIP J. FRY
}

Travailler avec cette classe Java est étudié aux niveaux initiaux du cours en ligne JavaRush :

• Une introduction à String est donnée au niveau 1, leçon 4 de la quête Java Syntax
• La structure interne de String, la méthode des sous-chaînes sont étudiées au 2ème niveau, 3ème cours de la quête Java Multithreading
• Trouver, obtenir, supprimer une sous-chaîne dans une String est étudié au 2ème niveau, 4ème cours de la quête Java Multithreading
• La méthode String.format est abordée au niveau 2, cours 6 de la quête Java Multithreading

Sources supplémentaires

Des informations sur la classe String sont également fournies dans d'autres articles de la communauté JavaRush :

1. Chaînes en Java - Cet article couvre quelques bases sur l'utilisation de chaînes en Java.
2. Chaîne Java. Questions et réponses d'entretien, partie 1 - cet article traite des questions d'entretien sur le sujet Stringet fournit également des réponses aux questions avec des explications et des exemples de code.
3. Chaînes en Java (classe java.lang.String) - cet article fournit une analyse plus approfondie de la classe String et aborde également les subtilités de l'utilisation de cette classe.