Stringa Java. Domande e risposte all'intervista, parte 2

Sfortunatamente l'articolo non rientrava in un frammento; ho dovuto dividerlo in due parti. Vedi l'inizio qui

12. Scrivi una funzione per trovare il palindromo più lungo in una data stringa

Una stringa può contenere stringhe palindromiche e trovare il palindromo più lungo è una questione di programmazione. Il punto chiave qui è che dal centro di qualsiasi palindromo, se andiamo a destra e a sinistra di 1 carattere, sarà sempre lo stesso carattere. Ad esempio, 12321, il centro è 3 e se continuiamo a muoverci dalla posizione corrente in entrambe le direzioni, otterremo 2 e poi 1. Usiamo una logica simile nel nostro programma Java per trovare il palindromo più lungo. Tuttavia, se la lunghezza del palindromo è pari, anche la lunghezza del centro è pari, quindi dobbiamo assicurarci che anche questo sia fornito nel nostro programma, ad esempio 12333321, il centro è 33 e se continuiamo a muoverci in entrambe le direzioni otterremo 3, 2 e 1. Nel nostro programma, esaminiamo la stringa risultante partendo dal centro e controlliamo i caratteri sinistro e destro. Abbiamo anche due variabili globali per memorizzare la posizione iniziale del palindromo. Dobbiamo anche verificare se è già stato trovato un palindromo più lungo, poiché possiamo trovare più palindromi in una determinata stringa. Di seguito è riportato un programma di esempio che funziona correttamente in tutti i casi. Possiamo migliorare il codice precedente spostando il ciclo while in un metodo separato, ma lascerò quella parte per te. Per favore fatemi sapere se avete un'implementazione migliore o se il programma fallisce in qualche modo.

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

Il programma produrrà quanto segue:

1
12321
12321
12333321
454454

13. Quali sono le differenze tra String, StringBuffer e StringBuilder

Una stringa è immutabile e finalizzata in Java, quindi tutte le nostre manipolazioni sulle stringhe creeranno sempre una nuova stringa. La manipolazione delle stringhe richiede molte risorse, quindi Java fornisce due classi utili per la manipolazione delle stringhe: StringBuffere StringBuilder. StringBuffere StringBuildersono classi mutabili. Le operazioni con StringBuffersono thread-safe e sincronizzate, ma i metodi StringBuildernon sono thread-safe. Quindi, quando più thread lavorano sulla stessa stringa dovremmo usare StringBuffer, ma in un ambiente a thread singolo dovremmo usare StringBuilder. StringBuilderpiù produttivo che StringBufferperché non è gravato dalla sincronizzazione.

14. Perché la stringa è immutabile e finalizzata in Java?

Ci sono diversi vantaggi nell’immutabilità delle stringhe:

1. Il pool di stringhe è possibile solo perché la stringa è immutabile in Java, quindi la macchina virtuale risparmia molto spazio sull'heap poiché diverse variabili di stringa puntano alla stessa variabile nel pool. Se una stringa non fosse immutabile, l'internamento della stringa non sarebbe possibile, perché se una variabile cambia il suo valore, anche le altre variabili che fanno riferimento a quella stringa verranno influenzate.

2. Se la stringa è modificabile, diventa un serio rischio per la sicurezza dell'applicazione. Ad esempio, il nome utente e la password del database vengono passati come stringa per ottenere una connessione al database e nella programmazione del socket i dettagli dell'host e della porta vengono passati come stringa. Poiché la stringa è immutabile, il suo valore non può essere modificato, altrimenti qualsiasi hacker potrebbe modificare il valore del collegamento e causare problemi alla sicurezza dell'applicazione.

3. Poiché la stringa è immutabile, è thread-safe e un'istanza della stringa può essere condivisa tra thread diversi. Ciò evita la sincronizzazione per la sicurezza del thread, le stringhe sono completamente thread-safe.

4. Le stringhe vengono utilizzate in Java classloadere l'immutabilità garantisce che la classe venga caricata correttamente utilizzando Classloader. Ad esempio, pensa a un'istanza di classe quando stai tentando di caricare java.sql.Connectionuna classe, ma il valore di riferimento viene modificato in myhacked.Connectionuna classe che potrebbe eseguire operazioni indesiderate sul tuo database.

5. Poiché la stringa è immutabile, viene hashcodememorizzata nella cache al momento della creazione e non è necessario calcolarla nuovamente. Ciò rende la stringa un ottimo candidato per la chiave Mape la sua elaborazione sarà più veloce rispetto ad altre chiavi HashMap. Questo è il motivo per cui la stringa è l'oggetto più comunemente usato come chiave HashMap.

15. Come dividere una stringa in parti?

Possiamo utilizzare un metodo split(String regex)per dividere una stringa in un array di stringhe utilizzando un'espressione regolare come delimitatore.

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

Il metodo split(String regex, int numOfStrings)è un metodo di sovraccarico per dividere una stringa in un numero specificato di righe. Possiamo usare la barra rovesciata per utilizzare i caratteri speciali delle espressioni regolari come caratteri regolari. Il programma produrrà quanto segue:

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. Perché un array di stringhe è preferibile a una stringa per memorizzare una password?

Una stringa è immutabile in Java e viene archiviata in un pool di stringhe. Una volta creato, rimane nel pool finché non viene raccolto i rifiuti, quindi quando pensiamo di aver finito con la password, rimane disponibile in memoria per un po' e non c'è modo di evitarlo. Questo è un rischio per la sicurezza perché chiunque abbia accesso al dump della memoria sarà in grado di trovare la password in testo non crittografato. Se utilizziamo un array di caratteri per memorizzare la password, possiamo cancellarla dopo averla utilizzata. In questo modo possiamo controllare quanto tempo rimane in memoria, evitando i rischi per la sicurezza inerenti a una stringa.

17. Come si controlla la somiglianza di due stringhe in Java?

Esistono due modi per verificare se due stringhe sono equivalenti: utilizzando l' ==operatore " " o utilizzando l'operatore equals. Quando utilizziamo l' ==operatore “ ”, controlla il valore della stringa come riferimento, ma nella programmazione la maggior parte delle volte controlliamo l'equivalenza della stringa solo per il valore. Pertanto, dobbiamo utilizzare il metodo equals per verificare l'uguaglianza di due stringhe. Esiste anche un metodo equalsIgnoreCaseche possiamo utilizzare per ignorare le maiuscole e minuscole.

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. Cos'è uno string pool?

Come suggerisce il nome, uno string pool è una raccolta di stringhe archiviate in un heap Java. Sappiamo che Stringquesta è una classe speciale in Java e possiamo creare oggetti di questa classe utilizzando l'operatore new proprio come possiamo creare oggetti fornendo il valore di una stringa tra virgolette doppie. Il diagramma seguente spiega come viene allocato il pool di stringhe nell'heap Java e cosa succede quando utilizziamo modi diversi per creare stringhe. Il pooling di stringhe è possibile esclusivamente grazie all'immutabilità delle stringhe di Java e all'implementazione dell'idea dell'internamento delle stringhe. Uno string pool è anche un esempio del modello Flyweight. Il pool di stringhe aiuta a risparmiare molta memoria, ma d'altro canto la creazione di una riga richiede più tempo. Quando utilizziamo le virgolette doppie per creare una stringa, prima cerca una stringa nel pool con lo stesso valore, se trovata restituisce semplicemente un riferimento, altrimenti viene creata una nuova stringa nel pool e quindi restituisce un riferimento. Tuttavia, quando utilizziamo l'operatore new, forziamo la classe Stringa creare un nuovo oggetto stringa e quindi possiamo utilizzare il metodo intern()per inserire la stringa nel pool o ottenere un riferimento dal pool a un altro oggetto Stringcon lo stesso valore. Di seguito è riportato un esempio che mostra come funziona lo string pool.

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

Il programma produrrà quanto segue:

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

19. Cosa fa il metodo intern()?

Quando viene chiamato il metodo intern(), se il pool di stringhe contiene già una stringa equivalente al nostro oggetto, come verificato dal metodo equals(Object), viene restituito un riferimento alla stringa dal pool. Altrimenti, l'oggetto stringa viene aggiunto al pool e viene restituito un riferimento a tale oggetto. Questo metodo restituisce sempre una stringa che ha lo stesso valore della stringa corrente, ma garantisce che sarà una stringa dal pool di stringhe univoche. Di seguito è riportato un esempio di come funziona il metodo 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. Le stringhe sono thread-safe in Java?

Le stringhe sono immutabili, quindi non possiamo cambiare il loro valore nel programma. Pertanto sono thread-safe e possono essere utilizzati in sicurezza in un ambiente multi-thread.

21. Perché String è una chiave popolare in HashMap in Java?

Poiché le stringhe sono immutabili, il loro codice hash viene memorizzato nella cache al momento della creazione e non richiede il ricalcolo. Ciò rende le stringhe un ottimo candidato per una chiave Mape vengono elaborate più velocemente di altri oggetti chiave HashMap. Questo è il motivo per cui le stringhe vengono utilizzate prevalentemente come chiavi HashMap. Spero che le domande elencate in questo articolo ti possano aiutare nelle tue interviste, per favore fammi sapere se mi sono perso qualcosa. Link all'articolo originale Autore: Pankaj Kumar