Chaîne Java. Questions et réponses d'entretien, partie 1

La classe Stringest l’une des classes les plus utilisées en Java. Cet article fournit quelques questions et réponses importantes lors de l'entretien sur Java String. Ils vous seront très utiles pour obtenir une image complète de la classe Stringet vous prépareront à toute Stringquestion d’entretien liée à la classe.

1. Qu'est-ce que la chaîne en Java ? De quel type de données s'agit-il ?

String est une classe en Java définie dans le package java.lang. Ce n'est pas un type de données primitif comme int et long. La classe String représente un jeu de caractères de chaîne. Les chaînes sont utilisées dans presque toutes les applications Java et nous devons connaître quelques faits sur la classe String. Il s'agit d'un type de données immuable ( immutable) et finalisé en Java et Stringla machine virtuelle stocke tous les objets de la classe dans un pool de chaînes. Une autre fonctionnalité Stringest la manière d'obtenir des objets de classe Stringen utilisant des guillemets doubles et en surchargeant l'opérateur « + » pour la concaténation.

2. Quelles sont les différentes manières de créer un objet String ?

Nous pouvons créer des objets en utilisant l'opérateur new comme n'importe quelle autre classe en Java ou nous pouvons utiliser des guillemets doubles pour créer un objet String. Il existe également plusieurs constructeurs de classes Stringpermettant d'obtenir une chaîne à partir d'un tableau de caractères, d'un tableau d'octets et également d'utiliser StringBufferou StringBuilder.

String str = new String("abc");
String str1 = "abc";

Lorsque nous créons une chaîne à l’aide de guillemets doubles, la machine virtuelle Java recherche dans le pool de chaînes une autre chaîne avec la même valeur. Si la chaîne est trouvée, alors seule une référence à un objet existant de la classe est renvoyée String, sinon un nouvel objet est créé avec la valeur reçue et stocké dans le pool. Lorsque nous utilisons l'opérateur new, la machine virtuelle crée un objet Stringmais ne le stocke pas dans le pool de chaînes. Nous pouvons utiliser la méthode intern()pour stocker une chaîne dans un pool de chaînes, ou obtenir une référence si une telle chaîne est déjà dans le pool.

3. Écrivez une méthode pour vérifier si une chaîne est un palindrome.

Une chaîne est appelée palindrome si elle se lit de la même manière dans les deux sens. Par exemple, « aba » est une chaîne palindromique. La classe Stringne fournit aucune méthode pour inverser une chaîne, mais les classes StringBufferont StringBuilderune méthode d'inversion avec laquelle nous pouvons vérifier si notre chaîne est un palindrome ou non.

private static boolean isPalindrome(String str) {
        if (str == null)
            return false;
        StringBuilder strBuilder = new StringBuilder(str);
        strBuilder.reverse();
        return strBuilder.toString().equals(str);
    }

Parfois, l'enquêteur peut demander de ne pas utiliser d'autres classes pour cette vérification, auquel cas nous pouvons comparer les caractères de la chaîne des deux côtés pour vérifier le palindrome.

private static boolean isPalindromeString(String str) {
        if (str == null)
            return false;
        int length = str.length();
        System.out.println(length / 2);
        for (int i = 0; i < length / 2; i++) {

            if (str.charAt(i) != str.charAt(length - i - 1))
                return false;
        }
        return true;
    }

4. Écrivez une méthode pour supprimer un caractère donné d'une chaîne.

Nous pouvons utiliser une méthode replaceAllpour remplacer toutes les occurrences d’une chaîne par une autre chaîne. Notez que la méthode prend une chaîne comme argument, nous utilisons donc la classe Characterpour créer une chaîne à partir d'un caractère et l'utilisons pour remplacer tous les caractères par la chaîne vide.

private static String removeChar(String str, char ch) {
        if (str == null)
            return null;
        return str.replaceAll(Character.toString(ch), "");
    }

5. Comment pouvons-nous convertir une chaîne en majuscules ou en minuscules ?

Nous pouvons utiliser des méthodes de classe String toUpperCasepour toLowerCaceobtenir des chaînes majuscules et minuscules. Ces méthodes ont une surcharge qui prend un argument Localeet utilise ses règles de localisation pour convertir la chaîne en majuscules ou minuscules.

6. À quoi sert la méthode subSequence ?

Java 1.4 a introduit l'interface CharSequence, une classe Stringhérite de cette interface et c'est la seule raison d'implémenter une méthode subSequencedans une classe String. En interne, il appelle le substring. Un exemple simple d'utilisation de la méthode :

public class StringSubsequence {

    public static void main(String[] args) {
        String str = "www.journaldev.com";
        System.out.println("Last 4 char String: "+str.subSequence(str.length()-4, str.length()));
        System.out.println("First 4 char String: "+str.subSequence(0, 4));
        System.out.println("website name: "+str.subSequence(4, 14));

        //substring vs subSequence
        System.out.println("substring == subSequence ? "
			+(str.substring(4, 14) == str.subSequence(4, 14)));

        System.out.println("substring equals subSequence ? "
			+(str.substring(4, 14).equals(str.subSequence(4, 14))));
    }
}

La sortie du programme affichera ce qui suit :

Last 4 char String: .com
First 4 char String: www.
website name: journaldev
substring == subSequence ? false
substring equals subSequence ? true

Idéalement, vous devriez toujours utiliser le substring.

7. Comment comparer deux chaînes en Java ?

La classe Stringhérite de l'interface Comparableet dispose de deux options de méthode compareTo(). La méthode compareTo(String anotherString)compare l'objet Stringavec l'argument reçu Stringde manière lexicographique. Si la ligne actuelle précède la chaîne reçue, la méthode renvoie un entier négatif, et si la chaîne suit l'argument reçu, elle renvoie un entier positif integer. Si la méthode renvoie 0, alors la chaîne a la même valeur, auquel cas la méthode equals(String str)retournera également vrai. compareToIgnoreCase(String str): Cette méthode est similaire à la précédente sauf qu'elle ignore la casse. Il utilise le comparateur CASE_INSENSITIVE_ORDER pour une comparaison insensible à la casse. Si la valeur de retour est zéro, la méthode equalsIgnoreCase(String str)retournera également vrai. Regardons un petit exemple pour expliquer ces méthodes :

public class StringCompareToExample {
    public static void main(String[] args) {
        String str = "ABC";
        System.out.println(str.compareTo("DEF"));
        System.out.println(str.compareToIgnoreCase("abc"));
    }
}

Le programme affichera ce qui suit :

-3
0

8. Comment convertir une chaîne en caractère et vice versa ?

Il s’agit d’une question piège car une chaîne est une séquence de caractères, nous ne pouvons donc la convertir qu’en un seul caractère. Nous pouvons utiliser une méthode charAtpour localiser le caractère à une position spécifiée ou nous pouvons utiliser une méthode toCharArray()pour convertir une chaîne en un tableau de caractères. Un exemple simple montrant comment convertir une chaîne en caractère et un caractère en chaîne en Java.

import java.util.Arrays;

public class StringToCharToString {
    public static void main(String[] args) {
        //String to char array
        String str = "123";
        char[] chArr = str.toCharArray();
        System.out.println("String to char array: "+Arrays.toString(chArr));
        //String to char
        char c = str.charAt(1);
        System.out.println("String to char: "+c);
        //char to String
        String s = Character.toString(c);
        System.out.println("char to String: "+s);
        //удалить все заданные символы из строки
        System.out.println("removing all chars from String: "
                                 +removeCharFromString("1ABCD12DW", '1'));
    }

    private static String removeCharFromString(String str, char c) {
        return str.replaceAll(Character.toString( c ), "");
    }
}

Le programme affichera ce qui suit :

String to char array: [1, 2, 3]
String to char: 2
char to String: 2
removing all chars from String: ABCD2DW

9. Comment convertir une chaîne en tableau d'octets et vice versa ?

Nous pouvons utiliser une méthode getBytes()pour convertir une chaîne en tableau d’octets et nous pouvons utiliser un constructeur new String(byte[] arr)pour convertir un tableau d’octets en chaîne.

import java.util.Arrays;

public class StringByteArray {
     public static void main(String[] args) {
        String str = "www.journaldev.com";
        //преобразование String в byte array
        byte[] byteArr = str.getBytes();
        System.out.println("String to byte array : "+Arrays.toString(byteArr));
        //преобразование byte array и String
        String str1 = new String(byteArr);
        System.out.println("byte array to String : "+str1);
        //посмотрим, str и str1 одинаковые or нет
        System.out.println("str == str1? " + (str == str1));
        System.out.println("str.equals(str1)? " + (str.equals(str1)));
    }
}

Le programme affichera ce qui suit :

String to byte array : [119, 119, 119, 46, 106, 111, 117, 114, 110, 97, 108, 100, 101, 118, 46, 99, 111, 109]
byte array to String : www.journaldev.com
str == str1? false
str.equals(str1)? true

10. Pouvons-nous utiliser une chaîne dans une construction switch ?

Cette question délicate permet de tester vos connaissances sur l’évolution actuelle du langage. Java 7 étend l'instruction switch pour utiliser des chaînes ; les versions antérieures de Java ne prennent pas en charge cela. Si vous implémentez un flux conditionnel pour les chaînes, vous pouvez utiliser des conditions if-else et vous pouvez utiliser une instruction switch si vous utilisez Java 7 ou une version ultérieure. Un petit exemple d'utilisation d'une chaîne dans une instruction switchet une autre méthode qui montre la même logique en utilisant des conditions if-else.

public class SwitchStringExample {

    public static void main(String[] args) {
        printColorUsingSwitch("red");
        printColorUsingIf("red");
        // оператор switch регистрозависимый
        printColorUsingSwitch("RED");
        printColorUsingSwitch(null);
    }

    private static void printColorUsingIf(String color) {
        if (color.equals("blue")) {
            System.out.println("BLUE");
        } else if (color.equals("red")) {
            System.out.println("RED");
        } else {
            System.out.println("INVALID COLOR CODE");
        }
    }

    private static void printColorUsingSwitch(String color) {
        switch (color) {
        case "blue":
            System.out.println("BLUE");
            break;
        case "red":
            System.out.println("RED");
            break;
        default:
            System.out.println("INVALID COLOR CODE");
        }
    }
}

Le programme affichera ce qui suit :

RED
RED
INVALID COLOR CODE
Exception in thread "main"
java.lang.NullPointerException
    at com.journaldev.util.SwitchStringExample.printColorUsingSwitch(SwitchStringExample.java:24)
    at com.journaldev.util.SwitchStringExample.main(SwitchStringExample.java:10)

Points d'utilisation clés switchdes chaînes en Java.

• l'utilisation de chaînes dans la conception switchrend le code plus lisible en éliminant plusieurs chaînes de conditions if-else.
• les chaînes sont switchsensibles à la casse, l'exemple ci-dessus le montre.
• L'opérateur switchutilise une méthode String.equals()pour comparer la valeur résultante avec les valeurs de cas , ajoutez donc une vérification de NULL pour éviter NullPointerException.
• Selon la documentation Java 7 pour les chaînes dans switch, le compilateur Java génère un bytecode plus efficace pour les chaînes d'une construction switchque pour les conditions concaténées if-else.
• assurez-vous que cela sera utilisé avec Java 7 ou version ultérieure, sinon vous obtiendrez xception.

11. Écrivez un programme qui imprime toutes les permutations d'une chaîne.

C'est une question délicate et nous devons utiliser la récursion pour trouver toutes les permutations d'une chaîne, par exemple les permutations de « AAB » pourraient être « AAB », « ABA » et « BAA ». Nous devons également utiliser Set pour nous assurer que nous n'avons pas de lignes en double. Pour obtenir toutes les permutations, nous prenons d’abord le premier caractère de la chaîne et réorganisons les caractères restants. Si String = « ABC » Premier caractère char = A et permutations restantes BC et CB. Nous pouvons maintenant insérer le premier caractère dans les positions disponibles dans les permutations. BC -> ABC, BAC, BCA CB -> ACB, CAB, CBA Exemple de programme :

import java.util.HashSet;
import java.util.Set;

public class StringHelper {
    public static Set<String> permutationFinder(String str) {
        Set<String> perm = new HashSet<String>();
        //Handling error scenarios
        if (str == null) {
            return null;
        } else if (str.length() == 0) {
            perm.add("");
            return perm;
        }
        char initial = str.charAt(0); // первый символ
        String rem = str.substring(1); // полная строка без первого символа
        Set<String> words = permutationFinder(rem);
        for (String strNew : words) {
            for (int i = 0;i<=strNew.length();i++){
                perm.add(charInsert(strNew, initial, i));
            }
        }
        return perm;
    }

    public static String charInsert(String str, char c, int j) {
        String begin = str.substring(0, j);
        String end = str.substring(j);
        return begin + c + end;
    }

    public static void main(String[] args) {
        String s = "AAC";
        String s1 = "ABC";
        String s2 = "ABCD";
        System.out.println("\nPermutations for " + s + " are: \n" + permutationFinder(s));
        System.out.println("\nPermutations for " + s1 + " are: \n" + permutationFinder(s1));
        System.out.println("\nPermutations for " + s2 + " are: \n" + permutationFinder(s2));
    }
}

Résultat du programme :

Permutations for AAC are:
[AAC, ACA, CAA]

Permutations for ABC are:
[ACB, ABC, BCA, CBA, CAB, BAC]

Permutations for ABCD are:
[DABC, CADB, BCAD, DBAC, BACD, ABCD, ABDC, DCBA, ADBC, ADCB, CBDA, CBAD, DACB, ACBD, CDBA, CDAB, DCAB, ACDB, DBCA, BDAC, CABD, BADC, BCDA, BDCA]

Suite de l'article