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

Malheureusement, l'article ne tenait pas en un seul fragment, j'ai dû le diviser en deux parties. Voir le début ici

12. Écrivez une fonction pour trouver le palindrome le plus long dans une chaîne donnée

Une chaîne peut contenir des chaînes palindromiques, et trouver le palindrome le plus long est une question de programmation. Le point clé ici est qu'à partir du milieu de n'importe quel palindrome, si l'on va à droite et à gauche d'un caractère, ce sera toujours le même caractère. Par exemple, 12321, le milieu est 3, et si nous continuons à nous déplacer depuis la position actuelle dans les deux sens, nous obtiendrons 2 puis 1. Nous utilisons une logique similaire dans notre programme Java pour trouver le palindrome le plus long. Cependant, si la longueur du palindrome est paire, la longueur du milieu est également paire, nous devons donc nous assurer que cela est également prévu dans notre programme, par exemple, 12333321, le milieu est 33, et si nous continuons à avancer dans les deux sens, nous obtiendrons 3, 2 et 1. Dans notre programme, nous parcourons la chaîne résultante avec le milieu en premier lieu et vérifions les caractères gauche et droit. Nous disposons également de deux variables globales pour stocker la position initiale du palindrome. Nous devons également vérifier s’il existe déjà un palindrome plus long, car nous pouvons trouver plusieurs palindromes dans une chaîne donnée. Vous trouverez ci-dessous un exemple de programme qui fonctionne correctement dans tous les cas. Nous pouvons améliorer le code ci-dessus en déplaçant la boucle while dans une méthode distincte, mais je vous laisse cette partie. S'il vous plaît laissez-moi savoir si vous avez une meilleure implémentation ou si le programme échoue d'une manière ou d'une autre.

package com.journaldev.util;

public class LongestPalindromeFinder {

    public static void main(String[] args) {
        System.out.println(longestPalindromeString("1234"));
        System.out.println(longestPalindromeString("12321"));
        System.out.println(longestPalindromeString("9912321456"));
        System.out.println(longestPalindromeString("9912333321456"));
        System.out.println(longestPalindromeString("12145445499"));
    }

    public static String longestPalindromeString(String in) {
        char[] input = in.toCharArray();
        int longestPalindromeStart = 0;
        int longestPalindromeEnd = 0;

        for (int mid = 0; mid < input.length; mid++) {
            // для случая нечетного палиндрома How 12321, 3 будет серединой
            int left = mid-1;
            int right = mid+1;
            // нам необходимо двигаться влево и вправо на 1 позицию до конца
            while (left >= 0 && right < input.length) {
                // ниже проверка, является ли это палиндромом
                if (input[left] == input[right]) {
                    // обновление глобальных позиций, только если палиндром длиннее имеющегося
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                left--;
                right++;
            }
            // для четного палиндрома у нас должна быть подобная логика с размером середины 2
            // для этого мы начнем на одну позицию правее
            left = mid-1;
            right = mid + 2;// к примеру, для 12333321 мы выбрали 33 в качестве середины
            while (left >= 0 && right < input.length)
            {
                if (input[left] == input[right]) {
                    if (right - left > longestPalindromeEnd
                            - longestPalindromeStart) {
                        longestPalindromeStart = left;
                        longestPalindromeEnd = right;
                    }
                }
                left--;
                right++;
            }
        }
        // теперь у нас есть позиции для самого длинного палиндрома
        return in.substring(longestPalindromeStart, longestPalindromeEnd + 1);
    }
}

Le programme affichera ce qui suit :

1
12321
12321
12333321
454454

13. Quelles sont les différences entre String, StringBuffer et StringBuilder

Une chaîne est immuable et finalisée en Java, donc toutes nos manipulations de chaîne créeront toujours une nouvelle chaîne. La manipulation de chaînes nécessite beaucoup de ressources, c'est pourquoi Java fournit deux classes utiles pour la manipulation de chaînes : StringBufferet StringBuilder. StringBufferet StringBuildersont des classes mutables. Les opérations avec StringBuffersont thread-safe et synchronisées, mais les méthodes StringBuilderne sont pas thread-safe. Ainsi, lorsque plusieurs threads travaillent sur la même chaîne, nous devrions utiliser StringBuffer, mais dans un environnement à thread unique, nous devrions utiliser StringBuilder. StringBuilderplus productif que StringBufferparce qu'il n'est pas chargé de synchronisation.

14. Pourquoi la chaîne est-elle immuable et finalisée en Java ?

L'immuabilité des chaînes présente plusieurs avantages :

1. Le regroupement de chaînes n'est possible que parce que la chaîne est immuable en Java, ainsi la machine virtuelle économise beaucoup d'espace de mémoire car différentes variables de chaîne pointent vers la même variable dans le pool. Si une chaîne n'était pas immuable, l'internement de chaîne ne serait pas possible, car si une variable change de valeur, d'autres variables faisant référence à cette chaîne seront également affectées.

2. Si la chaîne est mutable, cela devient un risque sérieux pour la sécurité de l'application. Par exemple, le nom d'utilisateur et le mot de passe de la base de données sont transmis sous forme de chaîne pour obtenir une connexion à la base de données et dans la programmation socket, les détails de l'hôte et du port sont transmis sous forme de chaîne. Étant donné que la chaîne est immuable, sa valeur ne peut pas être modifiée, sinon tout pirate informatique peut modifier la valeur du lien et provoquer des problèmes de sécurité de l'application.

3. Étant donné que la chaîne est immuable, elle est thread-safe et une instance de la chaîne peut être partagée entre différents threads. Cela évite la synchronisation pour la sécurité des threads, les chaînes sont complètement thread-safe.

4. Les chaînes sont utilisées en Java classloaderet l'immuabilité garantit que la classe est chargée correctement à l'aide de Classloader. Par exemple, pensez à une instance de classe lorsque vous essayez de charger java.sql.Connectionune classe, mais que la valeur de référence est remplacée par myhacked.Connectionune classe susceptible d'effectuer des opérations indésirables sur votre base de données.

5. La chaîne étant immuable, elle hashcodeest mise en cache au moment de la création et il n’est pas nécessaire de la recalculer. Cela fait de la chaîne un excellent candidat pour la clé in Mapet son traitement sera plus rapide que les autres clés HashMap. C'est la raison pour laquelle la chaîne est l'objet le plus couramment utilisé comme clé HashMap.

15. Comment diviser une chaîne en parties ?

Nous pouvons utiliser une méthode split(String regex)pour diviser une chaîne en un tableau de chaînes en utilisant une expression régulière comme délimiteur.

import java.util.Arrays;

public class JavaSplitString {
    public static void main(String[] args) {
        String line = "I am a java developer";
        String[] words = line.split(" ");
        String[] twoWords = line.split(" ", 2);
        System.out.println("String split with delimiter: "+Arrays.toString(words));
        System.out.println("String split into two: "+Arrays.toString(twoWords));
        //split string delimited with special characters
        String wordsWithNumbers = "I|am|a|java|developer";
        String[] numbers = wordsWithNumbers.split("\\|");
        System.out.println("String split with special character: "+Arrays.toString(numbers));
    }
}

La méthode split(String regex, int numOfStrings)est une méthode surchargée permettant de diviser une chaîne en un nombre spécifié de lignes. Nous pouvons utiliser la barre oblique inverse pour utiliser des caractères spéciaux d'expression régulière comme caractères normaux. Le programme affichera ce qui suit :

String split with delimiter: [I, am, a, java, developer]
String split into two: [I, am a java developer]
String split with special character: [I, am, a, java, developer]

16. Pourquoi un tableau de chaînes est-il préférable à une chaîne pour stocker un mot de passe ?

Une chaîne est immuable en Java et est stockée dans un pool de chaînes. Une fois créé, il reste dans le pool jusqu'à ce qu'il soit récupéré. Ainsi, lorsque nous pensons en avoir fini avec le mot de passe, il reste disponible en mémoire pendant un certain temps et il n'y a aucun moyen d'éviter cela. Il s'agit d'un risque de sécurité car toute personne ayant accès à l'image mémoire pourra trouver le mot de passe en texte clair. Si nous utilisons un tableau de caractères pour stocker le mot de passe, nous pouvons l'effacer une fois que nous en avons terminé. De cette façon, nous pouvons contrôler la durée pendant laquelle elle reste en mémoire, évitant ainsi les risques de sécurité inhérents à une chaîne.

17. Comment vérifier la similarité de deux chaînes en Java ?

Il existe deux façons de vérifier si deux chaînes sont équivalentes : en utilisant l' ==opérateur « » ou en utilisant le equals. Lorsque nous utilisons l' ==opérateur « », il vérifie la valeur de la chaîne comme référence, mais en programmation la plupart du temps, nous vérifions l'équivalence de la chaîne uniquement pour la valeur. Par conséquent, nous devons utiliser la méthode égale pour tester si deux chaînes sont équivalentes. Il existe également une méthode equalsIgnoreCaseque nous pouvons utiliser pour ignorer la casse.

String s1 = "abc";
String s2 = "abc";
String s3= new String("abc");
System.out.println("s1 == s2 ? "+(s1==s2)); //true
System.out.println("s1 == s3 ? "+(s1==s3)); //false
System.out.println("s1 equals s3 ? "+(s1.equals(s3))); //true

18. Qu'est-ce qu'un pool de chaînes ?

Comme son nom l'indique, un pool de chaînes est une collection de chaînes stockées dans un tas Java. Nous savons qu'il Strings'agit d'une classe spéciale en Java et nous pouvons créer des objets de cette classe en utilisant l'opérateur new tout comme nous pouvons créer des objets en fournissant la valeur d'une chaîne entre guillemets doubles. Le diagramme ci-dessous explique comment le pool de chaînes est alloué dans le tas Java et ce qui se passe lorsque nous utilisons différentes manières de créer des chaînes. Le regroupement de chaînes est possible uniquement grâce à l'immuabilité des chaînes de Java et à la mise en œuvre de l'idée d'internement de chaînes. Un pool de cordes est également un exemple du modèle Flyweight. Le pool de chaînes permet d'économiser beaucoup de mémoire, mais d'un autre côté, la création d'une ligne prend plus de temps. Lorsque nous utilisons des guillemets doubles pour créer une chaîne, il recherche d'abord une chaîne dans le pool avec la même valeur, si elle est trouvée, renvoie simplement une référence, sinon une nouvelle chaîne est créée dans le pool et renvoie ensuite une référence. Cependant, lorsque nous utilisons l'opérateur new, nous forçons la classe Stringà créer un nouvel objet chaîne, puis nous pouvons utiliser la méthode intern()pour mettre la chaîne dans le pool, ou obtenir une référence du pool vers un autre objet Stringavec la même valeur. Vous trouverez ci-dessous un exemple montrant le fonctionnement du pool de chaînes.

public class StringPool {
    public static void main(String[] args) {
        String s1 = "Cat";
        String s2 = "Cat";
        String s3 = new String("Cat");

        System.out.println("s1 == s2 :"+(s1==s2));
        System.out.println("s1 == s3 :"+(s1==s3));
    }
}

Le programme affichera ce qui suit :

s1 == s2 :true
s1 == s3 :false

19. Que fait la méthode stagiaire() ?

Lorsque la méthode intern()est appelée, si le pool de chaînes contient déjà une chaîne équivalente à notre objet, comme vérifié par la méthode equals(Object), alors une référence à la chaîne du pool est renvoyée. Sinon, l'objet chaîne est ajouté au pool et une référence à cet objet est renvoyée. Cette méthode renvoie toujours une chaîne qui a la même valeur que la chaîne actuelle, mais garantit qu'il s'agira d'une chaîne issue du pool de chaînes uniques. Voici un exemple du fonctionnement de la méthodeintern() :

public class StringPool {
    public static void main(String[] args) {
        String a = "string a";
        String b = new String("string a");
        String c = b.intern();

        System.out.println(a == b);
        System.out.println(b == c);
        System.out.println(a == c);
    }
}
Программа выведет следующее:false
false
true

20. Les chaînes sont-elles thread-safe en Java ?

Les chaînes sont immuables, nous ne pouvons donc pas modifier leur valeur dans le programme. Par conséquent, ils sont thread-safe et peuvent être utilisés en toute sécurité dans un environnement multithread.

21. Pourquoi String est-il une clé populaire dans HashMap en Java ?

Les chaînes étant immuables, leur code de hachage est mis en cache au moment de la création et ne nécessite pas de recalcul. Cela fait des chaînes un excellent candidat pour une clé Mapet elles sont traitées plus rapidement que les autres objets clés HashMap. C'est pourquoi les chaînes sont principalement utilisées comme clés HashMap. J'espère que les questions répertoriées dans cet article vous aideront dans vos entretiens, n'hésitez pas à me faire savoir si j'ai raté quelque chose. Lien vers l'article original Auteur : Pankaj Kumar