Sequência Java. Perguntas e respostas da entrevista, parte 2

Infelizmente o artigo não cabia em um fragmento, tive que dividi-lo em duas partes. Veja o início aqui

12. Escreva uma função para encontrar o palíndromo mais longo em uma determinada string

Uma string pode conter strings palindrômicas, e encontrar o palíndromo mais longo é uma questão de programação. O ponto chave aqui é que a partir do meio de qualquer palíndromo, se formos para a direita e para a esquerda por 1 caractere, será sempre o mesmo caractere. Por exemplo, 12321, o meio é 3, e se continuarmos nos movendo da posição atual em ambas as direções, obteremos 2 e depois 1. Usamos lógica semelhante em nosso programa Java para encontrar o palíndromo mais longo. No entanto, se o comprimento do palíndromo for par, o comprimento do meio também será par, então precisamos ter certeza de que isso também é fornecido em nosso programa, por exemplo, 12333321, o meio é 33, e se continuarmos nos movendo em ambas as direções, obteremos 3, 2 e 1. Em nosso programa, percorremos a string resultante com o meio em primeiro lugar e verificamos os caracteres esquerdo e direito. Também temos duas variáveis ​​globais para armazenar a posição inicial do palíndromo. Também precisamos verificar se já foi encontrado um palíndromo mais longo, pois podemos encontrar vários palíndromos em uma determinada string. Abaixo está um exemplo de programa que funciona bem em todos os casos. Podemos melhorar o código acima movendo o loop while para um método separado, mas deixarei essa parte para você. Por favor, deixe-me saber se você tem uma implementação melhor ou se o programa falha de alguma forma.

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

O programa produzirá o seguinte:

1
12321
12321
12333321
454454

13. Quais são as diferenças entre String, StringBuffer e StringBuilder

Uma string é imutável e finalizada em Java, então todas as nossas manipulações de string sempre criarão uma nova string. A manipulação de strings consome muitos recursos, então Java fornece duas classes úteis para manipulação de strings - StringBuffere StringBuilder. StringBuffere StringBuildersão classes mutáveis. As operações com StringBuffersão thread-safe e sincronizadas, mas os métodos StringBuildernão são thread-safe. Portanto, quando vários threads estão trabalhando na mesma string, devemos usar StringBuffer, mas em um ambiente de thread único, devemos usar StringBuilder. StringBuildermais produtivo do que StringBufferporque não está sobrecarregado com sincronização.

14. Por que a string é imutável e finalizada em Java?

Existem várias vantagens na imutabilidade de strings:

1. O pool de strings só é possível porque string é imutável em Java, portanto, a máquina virtual economiza muito espaço de heap, pois diferentes variáveis ​​de string apontam para a mesma variável no pool. Se uma string não fosse imutável, então a internação da string não seria possível, pois se alguma variável alterar seu valor, outras variáveis ​​que fazem referência a essa string também serão afetadas.

2. Se a string for mutável, ela se tornará um sério risco de segurança para o aplicativo. Por exemplo, o nome de usuário e a senha do banco de dados são passados ​​como uma string para obter uma conexão com o banco de dados e na programação de soquete os detalhes do host e da porta são passados ​​como uma string. Como a string é imutável, seu valor não pode ser alterado, caso contrário qualquer hacker pode alterar o valor do link e causar problemas na segurança da aplicação.

3. Como a string é imutável, ela é segura para threads e uma instância da string pode ser compartilhada entre diferentes threads. Isso evita a sincronização para segurança de thread, as strings são completamente seguras para thread.

4. Strings são usadas em Java classloadere a imutabilidade garante que a classe seja carregada corretamente usando Classloader. Por exemplo, pense em uma instância de classe quando você está tentando carregar java.sql.Connectionuma classe, mas o valor de referência é alterado para myhacked.Connectionuma classe que pode fazer coisas indesejadas em seu banco de dados.

5. Como a string é imutável, ela hashcodeé armazenada em cache no momento da criação e não há necessidade de calculá-la novamente. Isso torna a string uma excelente candidata para a digitação Mape seu processamento será mais rápido que outras chaves HashMap. Esta é a razão pela qual string é o objeto mais comumente usado como chave HashMap.

15. Como dividir uma string em partes?

Podemos usar um método split(String regex)para dividir uma string em um array de strings usando uma expressão regular como delimitador.

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

O método split(String regex, int numOfStrings)é um método sobrecarregado para dividir uma string em um número especificado de linhas. Podemos usar barra invertida para usar caracteres especiais de expressões regulares como caracteres regulares. O programa produzirá o seguinte:

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. Por que um array de strings é preferível a uma string para armazenar uma senha?

Uma string é imutável em Java e é armazenada em um pool de strings. Depois de criado, ele permanece no pool até ser coletado como lixo, então quando pensamos que terminamos com a senha, ela permanece disponível na memória por um tempo e não há como evitar isso. Este é um risco de segurança porque qualquer pessoa com acesso ao despejo de memória poderá encontrar a senha em texto não criptografado. Se usarmos uma matriz de caracteres para armazenar a senha, poderemos limpá-la depois de terminarmos de usá-la. Desta forma podemos controlar quanto tempo ela permanece na memória, evitando os riscos de segurança inerentes a uma string.

17. Como você verifica a semelhança de duas strings em Java?

Existem duas maneiras de verificar se duas strings são equivalentes - usando o ==operador “ ” ou usando o equals. Quando utilizamos o ==operador “ ” ele verifica o valor da string como referência, mas na programação na maioria das vezes verificamos a equivalência da string apenas para o valor. Portanto, devemos usar o método equals para testar a igualdade de duas strings. Também existe um método equalsIgnoreCaseque podemos usar para ignorar maiúsculas e minúsculas.

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. O que é um pool de strings?

Como o nome sugere, um pool de strings é uma coleção de strings armazenadas em um heap Java. Sabemos que Stringesta é uma classe especial em Java e podemos criar objetos desta classe usando o operador new, assim como podemos criar objetos fornecendo o valor de uma string entre aspas duplas. O diagrama abaixo explica como o pool de strings é alocado no heap Java e o que acontece quando usamos diferentes maneiras de criar strings. O pool de strings é possível apenas por causa da imutabilidade das strings em Java e da implementação da ideia de internação de strings. Um pool de strings também é um exemplo do padrão Flyweight. O pool de strings ajuda a economizar muita memória, mas por outro lado, a criação de uma linha leva mais tempo. Quando usamos aspas duplas para criar uma string, ele primeiro procura uma string no pool com o mesmo valor, se encontrada simplesmente retorna uma referência, caso contrário uma nova string é criada no pool e então retorna uma referência. Porém, quando usamos o operador new, forçamos a classe Stringa criar um novo objeto string e então podemos usar o método intern()para colocar a string no pool ou obter uma referência do pool para outro objeto Stringcom o mesmo valor. Abaixo está um exemplo que mostra como funciona o pool de strings.

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

O programa produzirá o seguinte:

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

19. O que o método intern() faz?

Quando o método intern()é chamado, se o conjunto de strings já contém uma string equivalente ao nosso objeto, conforme verificado pelo método equals(Object), então uma referência à string do pool é retornada. Caso contrário, o objeto string será adicionado ao pool e uma referência a esse objeto será retornada. Este método sempre retorna uma string que tem o mesmo valor da string atual, mas garante que será uma string do conjunto de strings exclusivas. Abaixo está um exemplo de como o método funciona 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. As strings são seguras para threads em Java?

Strings são imutáveis, portanto não podemos alterar seu valor no programa. Portanto, eles são thread-safe e podem ser usados ​​com segurança em um ambiente multithread.

21. Por que String é uma chave popular no HashMap em Java?

Como as strings são imutáveis, seu código hash é armazenado em cache no momento da criação e não requer recálculo. Isso torna as strings uma excelente candidata para uma chave Mape elas são processadas mais rapidamente do que outros objetos-chave HashMap. É por isso que strings são predominantemente usadas como chaves HashMap. Espero que as perguntas listadas neste artigo ajudem você em suas entrevistas. Informe-me se perdi alguma coisa. Link para o artigo original Autor: Pankaj Kumar