Cadena de Java. Preguntas y respuestas de la entrevista, parte 2

Desafortunadamente, el artículo no cabía en un solo fragmento, tuve que dividirlo en dos partes. Mira el comienzo aquí

12. Escribe una función para encontrar el palíndromo más largo en una cadena determinada.

Una cadena puede contener cadenas palindrómicas y encontrar el palíndromo más largo es una cuestión de programación. El punto clave aquí es que desde el medio de cualquier palíndromo, si vamos 1 carácter hacia la derecha y hacia la izquierda, siempre será el mismo carácter. Por ejemplo, 12321, el medio es 3, y si continuamos moviéndonos desde la posición actual en ambas direcciones, obtendremos 2 y luego 1. Usamos una lógica similar en nuestro programa Java para encontrar el palíndromo más largo. Sin embargo, si la longitud del palíndromo es par, la longitud del medio también es par, por lo que debemos asegurarnos de que esto también esté incluido en nuestro programa, por ejemplo, 12333321, el medio es 33, y si continuamos moviéndonos en ambas direcciones obtendremos 3, 2 y 1. En nuestro programa, revisamos la cadena resultante con el medio en primer lugar y verificamos los caracteres izquierdo y derecho. También tenemos dos variables globales para almacenar la posición inicial del palíndromo. También debemos verificar si ya se ha encontrado un palíndromo más largo, ya que podemos encontrar varios palíndromos en una cadena determinada. A continuación se muestra un programa de ejemplo que funciona bien en todos los casos. Podemos mejorar el código anterior moviendo el bucle while a un método separado, pero dejaré esa parte para ti. Avíseme si tiene una mejor implementación o si el programa falla de alguna manera.

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

El programa generará lo siguiente:

1
12321
12321
12333321
454454

13. ¿Cuáles son las diferencias entre String, StringBuffer y StringBuilder?

Una cadena es inmutable y finalizada en Java, por lo que todas nuestras manipulaciones de cadenas siempre crearán una nueva cadena. La manipulación de cadenas requiere muchos recursos, por lo que Java proporciona dos clases útiles para la manipulación de cadenas: StringBuffery StringBuilder. StringBuffery StringBuilderson clases mutables. Las operaciones con StringBufferson seguras para subprocesos y están sincronizadas, pero los métodos StringBuilderno son seguros para subprocesos. Entonces, cuando varios subprocesos están trabajando en la misma cadena, deberíamos usar StringBuffer, pero en un entorno de un solo subproceso, deberíamos usar StringBuilder. StringBuildermás productivo que StringBufferporque no está cargado de sincronización.

14. ¿Por qué la cadena es inmutable y finalizada en Java?

La inmutabilidad de cadenas tiene varias ventajas:

1. La agrupación de cadenas solo es posible porque las cadenas son inmutables en Java, por lo que la máquina virtual ahorra una gran cantidad de espacio en el montón, ya que diferentes variables de cadena apuntan a la misma variable en el grupo. Si una cadena no fuera inmutable, entonces la internación de cadenas no sería posible, porque si alguna variable cambia su valor, otras variables que hacen referencia a esa cadena también se verán afectadas.

2. Si la cadena es mutable, se convierte en un grave riesgo de seguridad para la aplicación. Por ejemplo, el nombre de usuario y la contraseña de la base de datos se pasan como una cadena para obtener una conexión a la base de datos y, en la programación de sockets, los detalles del host y del puerto se pasan como una cadena. Dado que la cadena es inmutable, su valor no se puede cambiar; de lo contrario, cualquier pirata informático puede cambiar el valor del enlace y causar problemas en la seguridad de la aplicación.

3. Dado que la cadena es inmutable, es segura para subprocesos y una instancia de la cadena se puede compartir entre diferentes subprocesos. Esto evita la sincronización para la seguridad de los subprocesos, las cadenas son completamente seguras para los subprocesos.

4. Las cadenas se utilizan en Java classloadery la inmutabilidad garantiza que la clase se cargue correctamente mediante Classloader. Por ejemplo, piense en una instancia de clase cuando intenta cargar java.sql.Connectionuna clase, pero el valor de referencia se cambia a myhacked.Connectionuna clase que podría hacer cosas no deseadas en su base de datos.

5. Dado que la cadena es inmutable, se hashcodealmacena en caché en el momento de la creación y no es necesario calcularla nuevamente. Esto hace que la cadena sea un excelente candidato para la entrada de claves Mapy su procesamiento será más rápido que el de otras claves HashMap. Esta es la razón por la que la cadena es el objeto más utilizado como clave HashMap.

15. ¿Cómo dividir una cuerda en partes?

Podemos usar un método split(String regex)para dividir una cadena en una matriz de cadenas usando una expresión 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));
    }
}

El método split(String regex, int numOfStrings)es un método sobrecargado para dividir una cadena en un número específico de líneas. Podemos usar una barra invertida para usar caracteres especiales de expresiones regulares como caracteres regulares. El programa generará lo siguiente:

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 qué es preferible una matriz de cadenas a una cadena para almacenar una contraseña?

Una cadena es inmutable en Java y se almacena en un grupo de cadenas. Una vez creada, permanece en el grupo hasta que se recolecta la basura, por lo que cuando creemos que hemos terminado con la contraseña, permanece disponible en la memoria por un tiempo y no hay forma de evitarlo. Esto supone un riesgo para la seguridad porque cualquiera que tenga acceso al volcado de memoria podrá encontrar la contraseña en texto sin cifrar. Si usamos una matriz de caracteres para almacenar la contraseña, podemos borrarla una vez que hayamos terminado. De esta forma podemos controlar cuánto tiempo permanece en memoria, evitando los riesgos de seguridad inherentes a una cadena.

17. ¿Cómo se comprueba la similitud de dos cadenas en Java?

Hay dos formas de comprobar si dos cadenas son equivalentes: utilizando el ==operador " " o utilizando el archivo equals. Cuando usamos el ==operador “ ”, verifica el valor de la cadena como referencia, pero en programación la mayor parte del tiempo verificamos la equivalencia de la cadena solo para el valor. Por lo tanto, debemos utilizar el método igual para comprobar si dos cadenas son equivalentes. También hay un método equalsIgnoreCaseque podemos utilizar para ignorar mayúsculas y 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. ¿Qué es un grupo de hilos?

Como sugiere el nombre, un grupo de cadenas es una colección de cadenas que se almacena en un montón de Java. Sabemos que Stringesta es una clase especial en Java y podemos crear objetos de esta clase usando el nuevo operador tal como podemos crear objetos proporcionando el valor de una cadena entre comillas dobles. El siguiente diagrama explica cómo se asigna el grupo de cadenas en el montón de Java y qué sucede cuando utilizamos diferentes formas de crear cadenas. La agrupación de cadenas es posible únicamente debido a la inmutabilidad de las cadenas de Java y la implementación de la idea de internamiento de cadenas. Un grupo de cadenas también es un ejemplo del patrón Flyweight. El grupo de cadenas ayuda a ahorrar mucha memoria, pero, por otro lado, crear una fila lleva más tiempo. Cuando usamos comillas dobles para crear una cadena, primero busca una cadena en el grupo con el mismo valor; si la encuentra, simplemente devuelve una referencia; de lo contrario, se crea una nueva cadena en el grupo y luego devuelve una referencia. Sin embargo, cuando usamos el operador new, forzamos a la clase Stringa crear un nuevo objeto de cadena y luego podemos usar el método intern()para colocar la cadena en el grupo u obtener una referencia del grupo a otro objeto Stringcon el mismo valor. A continuación se muestra un ejemplo que muestra cómo funciona el grupo de cadenas.

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

El programa generará lo siguiente:

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

19. ¿Qué hace el método intern()?

intern()Cuando se llama al método , si el grupo de cadenas ya contiene una cadena equivalente a nuestro objeto, según lo verifica el método equals(Object), entonces se devuelve una referencia a la cadena del grupo. De lo contrario, el objeto de cadena se agrega al grupo y se devuelve una referencia a ese objeto. Este método siempre devuelve una cadena que tiene el mismo valor que la cadena actual, pero garantiza que será una cadena del grupo de cadenas únicas. A continuación se muestra un ejemplo de cómo funciona el método 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. ¿Son seguras las cadenas de subprocesos en Java?

Las cadenas son inmutables, por lo que no podemos cambiar su valor en el programa. Por lo tanto, son seguros para subprocesos y se pueden utilizar de forma segura en un entorno de subprocesos múltiples.

21. ¿Por qué String es una clave popular en HashMap en Java?

Dado que las cadenas son inmutables, su código hash se almacena en caché en el momento de la creación y no es necesario volver a calcularlo. Esto hace que las cadenas sean un excelente candidato para una clave Mapy se procesan más rápido que otros objetos clave HashMap. Esta es la razón por la que las cadenas se utilizan predominantemente como claves HashMap. Espero que las preguntas enumeradas en este artículo le ayuden en sus entrevistas. Avíseme si me perdí algo. Enlace al artículo original Autor: Pankaj Kumar