Java-String. Fragen und Antworten im Vorstellungsgespräch, Teil 2

Leider passte der Artikel nicht in ein Fragment, ich musste ihn in zwei Teile teilen. Den Anfang sehen Sie hier

12. Schreiben Sie eine Funktion, um das längste Palindrom in einer bestimmten Zeichenfolge zu finden

Eine Zeichenfolge kann palindromische Zeichenfolgen enthalten, und das Finden des längsten Palindroms ist eine Frage der Programmierung. Der entscheidende Punkt hierbei ist, dass es sich von der Mitte eines Palindroms aus immer um dasselbe Zeichen handelt, wenn wir uns um ein Zeichen nach rechts und links bewegen. Zum Beispiel 12321, die Mitte ist 3, und wenn wir uns von der aktuellen Position aus in beide Richtungen weiterbewegen, erhalten wir 2 und dann 1. Wir verwenden eine ähnliche Logik in unserem Java-Programm, um das längste Palindrom zu finden. Wenn jedoch die Länge des Palindroms gerade ist, ist auch die Länge der Mitte gerade, also müssen wir sicherstellen, dass dies auch in unserem Programm vorgesehen ist, zum Beispiel 12333321, die Mitte ist 33, und wenn wir weitermachen in beide Richtungen erhalten wir 3, 2 und 1. In unserem Programm gehen wir die resultierende Zeichenfolge zunächst mit der Mitte durch und überprüfen die linken und rechten Zeichen. Wir haben auch zwei globale Variablen, um die Anfangsposition des Palindroms zu speichern. Wir müssen auch prüfen, ob bereits ein längeres Palindrom gefunden wurde, da wir in einer bestimmten Zeichenfolge mehrere Palindrome finden können. Nachfolgend finden Sie ein Beispielprogramm, das in allen Fällen einwandfrei funktioniert. Wir können den obigen Code verbessern, indem wir die while-Schleife in eine separate Methode verschieben, aber diesen Teil überlasse ich Ihnen. Bitte lassen Sie mich wissen, wenn Sie eine bessere Implementierung haben oder das Programm auf irgendeine Weise fehlschlägt.

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++) {
            // для случая нечетного палиндрома Wie 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);
    }
}

Das Programm gibt Folgendes aus:

1
12321
12321
12333321
454454

13. Was sind die Unterschiede zwischen String, StringBuffer und StringBuilder?

Ein String ist in Java unveränderlich und finalisiert, sodass alle unsere String-Manipulationen immer einen neuen String erzeugen. Die String-Manipulation ist ressourcenintensiv, daher bietet Java zwei nützliche Klassen für die String-Manipulation – StringBufferund StringBuilder. StringBufferund StringBuildersind veränderliche Klassen. Operationen mit StringBuffersind Thread-sicher und synchronisiert, Methoden StringBuildersind jedoch nicht Thread-sicher. Wenn also mehrere Threads an derselben Zeichenfolge arbeiten, sollten wir verwenden StringBuffer, in einer Umgebung mit nur einem Thread sollten wir jedoch verwenden StringBuilder. StringBuilderproduktiver als StringBufferweil es nicht mit der Synchronisierung belastet ist.

14. Warum ist String in Java unveränderlich und finalisiert?

Die Unveränderlichkeit von Zeichenfolgen bietet mehrere Vorteile:

1. String-Pooling ist nur möglich, weil Strings in Java unveränderlich sind. Dadurch spart die virtuelle Maschine viel Heap-Speicherplatz, da verschiedene String-Variablen auf dieselbe Variable im Pool verweisen. Wenn eine Zeichenfolge nicht unveränderlich wäre, wäre die Internierung von Zeichenfolgen nicht möglich, da, wenn eine Variable ihren Wert ändert, auch andere Variablen, die auf diese Zeichenfolge verweisen, betroffen sind.

2. Wenn die Zeichenfolge veränderbar ist, stellt sie ein ernstes Sicherheitsrisiko für die Anwendung dar. Beispielsweise werden der Benutzername und das Kennwort der Datenbank als Zeichenfolge übergeben, um eine Verbindung zur Datenbank herzustellen, und bei der Socket-Programmierung werden die Host- und Portdetails als Zeichenfolge übergeben. Da die Zeichenfolge unveränderlich ist, kann ihr Wert nicht geändert werden. Andernfalls kann jeder Hacker den Wert des Links ändern und Probleme bei der Sicherheit der Anwendung verursachen.

3. Da die Zeichenfolge unveränderlich ist, ist sie threadsicher und eine Instanz der Zeichenfolge kann von verschiedenen Threads gemeinsam genutzt werden. Dadurch wird aus Gründen der Thread-Sicherheit eine Synchronisierung vermieden, Strings sind vollständig threadsicher.

4. In Java werden Zeichenfolgen verwendet classloaderund die Unveränderlichkeit stellt sicher, dass die Klasse korrekt geladen wird Classloader. Denken Sie beispielsweise an eine Klasseninstanz, wenn Sie versuchen, java.sql.Connectioneine Klasse zu laden, der Referenzwert jedoch in myhacked.Connectioneine Klasse geändert wird, die möglicherweise unerwünschte Dinge mit Ihrer Datenbank macht.

5. Da die Zeichenfolge unveränderlich ist, hashcodewird sie zum Zeitpunkt der Erstellung zwischengespeichert und muss nicht erneut berechnet werden. Dies macht die Zeichenfolge zu einem hervorragenden Kandidaten für die Eingabe Mapund ihre Verarbeitung erfolgt schneller als bei anderen Schlüsseln HashMap. Aus diesem Grund ist der String das am häufigsten als Schlüssel verwendete Objekt HashMap.

15. Wie zerlege ich eine Zeichenfolge in Teile?

Wir können eine Methode verwenden split(String regex), um einen String in ein Array von Strings aufzuteilen, indem wir einen regulären Ausdruck als Trennzeichen verwenden.

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));
    }
}

Die Methode split(String regex, int numOfStrings)ist eine überladene Methode zum Aufteilen einer Zeichenfolge in eine angegebene Anzahl von Zeilen. Wir können einen Backslash verwenden, um reguläre Ausdrucks-Sonderzeichen als reguläre Zeichen zu verwenden. Das Programm gibt Folgendes aus:

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. Warum ist ein String-Array einem String zum Speichern eines Passworts vorzuziehen?

Ein String ist in Java unveränderlich und wird in einem String-Pool gespeichert. Sobald es erstellt wurde, verbleibt es im Pool, bis es durch den Müll gesammelt wird. Wenn wir also denken, dass wir mit dem Passwort fertig sind, bleibt es eine Weile im Speicher verfügbar und es gibt keine Möglichkeit, dies zu vermeiden. Dies stellt ein Sicherheitsrisiko dar, da jeder, der Zugriff auf den Speicherauszug hat, das Passwort im Klartext finden kann. Wenn wir zum Speichern des Passworts ein Zeichenarray verwenden, können wir es löschen, nachdem wir damit fertig sind. Auf diese Weise können wir steuern, wie lange es im Speicher bleibt, und so die mit einem String verbundenen Sicherheitsrisiken vermeiden.

17. Wie überprüft man in Java zwei Zeichenfolgen auf Ähnlichkeit?

Es gibt zwei Möglichkeiten, um zu überprüfen, ob zwei Zeichenfolgen äquivalent sind: mit dem ==Operator „ “ oder mit dem equals. Wenn wir den „ ==“-Operator verwenden, prüft er den Wert der Zeichenfolge als Referenz, aber beim Programmieren prüfen wir die Zeichenfolgenäquivalenz meistens nur für den Wert. Daher müssen wir die Methode „equals“ verwenden, um zwei Zeichenfolgen auf Gleichheit zu testen. Es gibt auch eine Methode, mit equalsIgnoreCaseder wir die Groß- und Kleinschreibung ignorieren können.

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. Was ist ein String-Pool?

Wie der Name schon sagt, handelt es sich bei einem String-Pool um eine Sammlung von Strings, die in einem Java-Heap gespeichert werden. Wir wissen, dass Stringdies eine spezielle Klasse in Java ist und wir können Objekte dieser Klasse mit dem neuen Operator erstellen, genauso wie wir Objekte erstellen können, indem wir den Wert einer Zeichenfolge in doppelten Anführungszeichen angeben. Das folgende Diagramm erklärt, wie der String-Pool im Java-Heap zugewiesen wird und was passiert, wenn wir unterschiedliche Methoden zum Erstellen von Strings verwenden. String-Pooling ist allein aufgrund der Unveränderlichkeit von Strings in Java und der Implementierung der Idee der String-Internierung möglich. Ein String-Pool ist ebenfalls ein Beispiel für das Flyweight-Muster. Der String-Pool hilft, viel Speicher zu sparen, aber andererseits nimmt das Erstellen einer Zeile mehr Zeit in Anspruch. Wenn wir zum Erstellen einer Zeichenfolge doppelte Anführungszeichen verwenden, wird zunächst im Pool nach einer Zeichenfolge mit demselben Wert gesucht. Wenn sie gefunden wird, wird einfach eine Referenz zurückgegeben. Andernfalls wird eine neue Zeichenfolge im Pool erstellt und dann eine Referenz zurückgegeben. Wenn wir jedoch den neuen Operator verwenden, zwingen wir die Klasse, Stringein neues String-Objekt zu erstellen, und dann können wir die Methode verwenden, intern()um den String in den Pool zu legen oder eine Referenz aus dem Pool auf ein anderes Objekt Stringmit demselben Wert zu erhalten. Unten sehen Sie ein Beispiel, das zeigt, wie der String-Pool funktioniert.

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));
    }
}

Das Programm gibt Folgendes aus:

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

19. Was macht die intern()-Methode?

Wenn die Methode intern()aufgerufen wird und der String-Pool bereits einen String enthält, der unserem Objekt entspricht, wie von der Methode überprüft equals(Object), wird ein Verweis auf den String aus dem Pool zurückgegeben. Andernfalls wird das Zeichenfolgenobjekt zum Pool hinzugefügt und ein Verweis auf dieses Objekt zurückgegeben. Diese Methode gibt immer eine Zeichenfolge zurück, die denselben Wert wie die aktuelle Zeichenfolge hat, garantiert jedoch, dass es sich um eine Zeichenfolge aus dem Pool eindeutiger Zeichenfolgen handelt. Nachfolgend finden Sie ein Beispiel für die Funktionsweise der Methode intern():

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. Sind Strings in Java threadsicher?

Zeichenfolgen sind unveränderlich, daher können wir ihren Wert im Programm nicht ändern. Daher sind sie Thread-sicher und können sicher in einer Multithread-Umgebung verwendet werden.

21. Warum ist String ein beliebter Schlüssel in HashMap in Java?

Da Zeichenfolgen unveränderlich sind, wird ihr Hash-Code zum Zeitpunkt der Erstellung zwischengespeichert und erfordert keine Neuberechnung. Dies macht Strings zu hervorragenden Kandidaten für einen Schlüssel Mapund sie werden schneller verarbeitet als andere Schlüsselobjekte HashMap. Aus diesem Grund werden als Schlüssel überwiegend Zeichenfolgen verwendet HashMap. Ich hoffe, dass die in diesem Artikel aufgeführten Fragen Ihnen bei Ihren Vorstellungsgesprächen helfen werden. Bitte lassen Sie mich wissen, wenn ich etwas verpasst habe. Link zum Originalartikel Autor: Pankaj Kumar