Preguntas de la entrevista sobre cadenas de Java

Introducción

Sin duda, el String class es la clase más utilizada en Java, que representa una secuencia de caracteres, tratada como un objeto. Dado el papel por excelencia de Strings en prácticamente todas las aplicaciones Java, los reclutadores prestan mucha atención a String-Preguntas relacionadas durante una entrevista de trabajo. Al asistir a una entrevista, un desarrollador de Java debe tener un control y un conocimiento completos y profundos de esta clase.

Aún mejor, también debe prepararse para su entrevista estudiando las preguntas de entrevistas anteriores utilizadas por las principales empresas, lo que puede hacer con Problema de codificación diario. Con DCP, diariamente se le envían preguntas de práctica por correo electrónico. Aunque, si necesitas estudiar Java Strings en particular, sigue leyendo.

Preguntas de la entrevista sobre cadenas de Java

Las entrevistas de trabajo a menudo distinguen dos categorías de preguntas: teóricas y de codificación:

• Preguntas teóricas
  • Clases de cadenas
  • Inmutabilidad de Strings
  • Piscina de Strings
  • Herencia de cadenas
  • Índice de caracteres
  • Concatenación de cadenas
  • String, StringBuffer, StringBuilder
• Preguntas de codificación
  • Inversión de una String
  • Comprobación de si la cadena contiene solo dígitos
  • Cómo convertir una cadena en entero
  • Eliminar caracteres duplicados en una cadena
  • Encontrar el carácter máximo que ocurre en una cadena
  • Encuentra el primer carácter que no se repite en una cadena
  • Verificar si dos cadenas son anagramas entre sí
  • Contar el número de palabras en una cadena

Preguntas teóricas

Clases de cadenas

Pregunta

«¿Con qué clases de Strings estás familiarizado?

Responder

Esta pregunta puede parecer confusa al principio, pero no se preocupe, en realidad es bastante simple.

Una cadena es una secuencia de caracteres y la String la clase no es la única que hace eso. Hay tres clases en Java que se utilizan para crear objetos String: String, StringBuffer y StringBuilder. En realidad, este es un tema bastante profundo al considerar las diferencias entre las clases y sus ventajas / desventajas.

Si desea leer más sobre estos en detalle, consulte nuestro artículo que cubre el tema: String vs StringBuilder vs StringBuffer.

Inmutabilidad de Strings

Pregunta

«¿Es String una clase inmutable, y si es así, por qué?»

Responder

Esta es una pregunta muy común en las entrevistas y una respuesta de «Sí» o «No» generalmente no es suficiente. Por lo general, deberá poder explicar más.

String es una clase inmutable. Esto significa que una vez que una instancia de un String se crea el objeto, no se puede modificar. Este es, ante todo, el efecto de la final modificador aplicado al String clase. Llamar a cualquier tipo de método de modificación de contenido en un String instancia simplemente devolverá un nuevo, actualizado String instancia: el objeto original no cambia.

Esto se puede observar fácilmente en el código fuente de cualquier String método:

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

El original str nunca se cambia, porque no se puede cambiar. En última instancia, el método devuelve un nuevo String objeto.

Te puede interesar:Cómo usar TensorFlow con Java

Piscina de Strings

Pregunta

«¿Qué es el String Pool?»

Responder

Como se mencionó, las cadenas se usan con mucha frecuencia. Aprovechando el hecho de que son inmutables, la JVM guarda todos los literales de cadena en la memoria del montón. Cada vez que instanciamos implícitamente un String objeto, su valor literal se compara con los de la memoria de pila y si ya existe, la variable de referencia se asigna a la ubicación de memoria ya existente.

Este enfoque puede ahorrar memoria drásticamente ya que no hay valores duplicados. Esta colección de ubicaciones de memoria guardadas se llama Piscina de Strings.

Herencia de cadenas

Pregunta

«¿Puedes extender String? »

Responder

Dado que la clase String se declara como final, no se puede heredar.

== vs .equals ()

Pregunta

«¿Hay alguna diferencia entre == operador y el .equals() ¿método?»

Responder

Aunque pueden parecer iguales, hay una diferencia clara entre estos dos validadores de igualdad:

• los == El operador comprueba la igualdad de las variables de referencia y devuelve true si ambos apuntan al mismo objeto en la memoria.
• los .equals() El método es un método que compara dos cadenas en función de su contenido y devuelve true si son iguales.

Utilizando la == El operador para comparar Strings puede devolver el resultado esperado, debido a que el String Pool guarda los valores en la misma ubicación de memoria, aunque a menudo no lo hará.

Por otra parte, .equals() siempre devolverá el resultado esperado al comparar cadenas.

Índice de caracteres

Pregunta

«¿Cómo se encuentra el valor de un personaje en una posición específica?»

Responder

los String la clase proporciona un método .charAt(int position) que devuelve un solo carácter. El carácter que devolverá el método depende del argumento ‘posición’ especificado.

Como en una matriz, 0 representa el índice del primer carácter en una cadena y .length() - 1 representa el índice del último carácter.

Te puede interesar:Web Scraping a la manera de Java

Concatenación de cadenas

Pregunta

«¿De qué manera se puede realizar la concatenación de cadenas?»

Responder

La concatenación es una operación que se utiliza para fusionar dos cadenas en una nueva. Las cadenas básicas se pueden concatenar simplemente usando el + operador o usando .concat() método, mientras StringBuffers y StringBuilders lograr la concatenación usando .append() método.

Al usar el + operador con otros tipos de datos, si es posible, se convierten en un String.

Otra forma de unir varias cadenas es mediante el StringJoiner clase:

// El delimitador es "", el prefijo es "[" and the suffix is "+"
StringJoiner joiner = new StringJoiner("", "[", "+");
joiner.add("Orange")
  .add("Apple")
  .add("Pear");
  
System.out.println(joiner.toString());

The output would be:

[OrangeApplePear+

String Thread Safety

Question

«Are Strings thread-safe?»

Answer

In Java, every immutable object is thread-safe and therefore String is thread-safe too.

This applies to StringBuffer as well since it uses Java’s synchronized keyword, but doesn’t apply to StringBuilder, which isn’t thread-safe since it is mutable and does not use the synchronized keyword.

String vs StringBuilder vs StringBuffer

Question

«What are the differences between the String, StringBuilder and StringBuffer classes?

Answer

String objects are easier to use, thread-safe, and immutable, which means they consume more memory and they are slower than their siblings (StringBuffer and StringBuilder) when it comes to string manipulation.

StringBuffer objects are mutable, memory efficient, and thread-safe, but they are still slow when compared to StringBuilder.

StringBuilder objects are also mutable, memory efficient, and extremely fast, but they are not thread-safe.

Te puede interesar:Anotaciones de Spring: @RequestMapping y sus variantes

If you’d like to read more about Strings, StringBuffers, and StringBuilders, we’ve got a whole article that goes in-depth on the topic.

Coding Questions

Reversing a String

In order to reverse a String we would have to write a custom function right? Well, there is a workaround for this case – we can use StringBuilder or StringBuffer as a wrapper around our String object.

That way we can access the function .reverse() and use it to reverse our String without making a new custom function for the exact same task:

String str = "I'm a string waiting to be reversed";
System.out.println(str);

StringBuilder stringBuilder = new StringBuilder(str);
stringBuilder.reverse();
System.out.println("Reversing the string. . .n");

System.out.println(stringBuilder.toString());

Output:

I'm a string waiting to be reversed
Reversing the string. . .

desrever eb ot gnitiaw gnirts a m'I

However, if the recruiter doesn’t appreciate you using this workaround, there are many ways to reverse a String character by character. Let’s list a couple:

1. Reversing by character array:

public String reverse(String str) {
    char[] caracteres = str.toCharArray ();  int inicio = 0;  int finish = characters.length-1;  char temp;  while (terminar> comenzar) {temp = caracteres[start];  caracteres[start] = caracteres[finish];  caracteres[finish] = temp;  terminar--;  inicio ++;  } return new String (in);  }

Este enfoque es muy eficiente, ya que simplemente reorganiza los personajes y devuelve un nuevo String objeto con la matriz pasada al constructor.

2. Inversión por apilamiento de caracteres:

public String reverse(String str) {
    String result = "";
    for(int i = str.length() - 1; i >= 0; i--) {
        result = result + string.charAt(i);
    }
    System.out.println(result); 
}

Aunque, este enfoque no es tan eficiente debido a la creación de un nuevo objeto String mediante concatenación para cada carácter.

Comprobación de si la cadena contiene solo dígitos

El enfoque más fácil para verificar si la cadena contiene solo dígitos es usar el .matches() método y proporcionando un argumento de cadena – "[0-9]+". El argumento esperado debería ser una expresión regular (expresión regular) con la que se debe hacer coincidir la cadena; en nuestro caso, la expresión regular representa los caracteres numéricos del 0 al 9.

String str = "09";
        
if (str.matches("[0-9]+")) {
    System.out.println("String contains only numbers.");
} else {
    System.out.println("String doesn't contain only numbers!");
}

Salida:

String contains only numbers.

Cómo convertir una cadena en entero

los Integer La clase proporciona tres métodos que nos permiten convertir cadenas en enteros:

Te puede interesar:String vs StringBuilder vs StringBuffer en Java

• parseInt()
• valueOf()
• decode()

Estos son bastante sencillos y devuelven enteros con una cadena pasada:

String str = "1234";
int strNumber = Integer.parseInt(str);
int strNumber2 = Integer.valueOf(str);
int strNumber3 = Integer.decode(str);

System.out.println(4321 + strNumber);
System.out.println(4321 + strNumber);
System.out.println(4321 + strNumber);

Salida:

5555
5555
5555

Si desea leer todos los casos de uso de estos métodos, así como sus diferencias, tenemos un excelente artículo sobre la conversión de cadenas a números enteros que cubre el tema con más detalle.

Eliminar caracteres duplicados en una cadena

Para eliminar caracteres duplicados en una cadena, podemos usar HashSets, Streams, e incluso LinkedLists. Pero para este ejemplo en particular, usaremos solo String objetos y encuentre la solución implementando la lógica adecuada.

En primer lugar, necesitamos dos cadenas: una contendrá la Cadena de entrada y la otra contendrá el resultado «filtrado». Después de eso, creamos un ciclo que debería iterar a través de nuestra Cadena de entrada, 1 carácter a la vez.

Utilizaremos una bandera booleana, inicialmente establecida en false. El bucle interno itera a través del result Cadena, comparando caracteres de la primera Cadena a la segunda:

• Si el carácter no está presente en la segunda cadena, lo agregamos.
• Si el carácter está presente en la segunda cadena, marcamos la bandera booleana como true que excluye al personaje de la concatenación

Aquí está la implementación:

String str = "Pharos.sh";
String str2 = "";
for (int i = 0; i < str.length(); i++) {
    boolean found = false;
    for (int j = 0; j < str2.length(); j++) {
        if (str.charAt(i) == str2.charAt(j)) {
            found = true;
            break;
        }
    }
    if (found == false) {
        str2 = str2.concat(String.valueOf(str.charAt(i)));
    }
}
System.out.println(str2);

Salida:

stackbue

Encontrar el carácter máximo que ocurre en una cadena

El mejor método para encontrar el carácter máximo que ocurre en una cadena es usar HashMaps. Para encontrar el carácter correcto, así como el número de ocurrencias, nuestro HashMap debe contener un char clave y una int valor.

La lógica aquí es simple: verifique cada carácter en una Cadena y si un carácter ya existe en un HashMap luego incrementa su valor, de lo contrario guarda el personaje en un HashMap y darle un valor de 1. Para cada carácter que estamos verificando si su valor es mayor que el charCount variable que cuenta la ocurrencia máxima y si es así, incrementamos charCount.

Al final, iteramos a través del HashMap y busque una clave que tenga charCount número de ocurrencias y cuando lo encontramos lo imprimimos. Si hay varios personajes con el mismo charCount valor que todos se imprimen en la consola:

public static void findMaxOccurrence(String input) {
    int charCount = 0;
    HashMap<Character, Integer> map = new HashMap<>();
    char[] inputChar = input.toCharArray();
    
    for (int i = 0; i < inputChar.length; i++) {
        char c = inputChar[i];
        
        if (map.containsKey(c)) {
            int count = map.get(c);
            count++;
            
            if (charCount < count) {
                charCount++;
            }
            
            map.put(c, count);
        } else {
            map.put(c, 1);
        }
    }

    Set set = map.keySet();
    Iterator<Character> iterator = set.iterator();
    while (iterator.hasNext()) {
        char key = iterator.next();
        
        if (map.get(key) == charCount) {
            System.out.println("Character '" + key + "' has the max occurrence: " + charCount + " times!");
        }
    }
}
    
public static void main(String[] args) {
    Main.findMaxOccurrence("This is the best example");
}

Salida:

Te puede interesar:Operaciones comunes con cadenas en Java

Character ' ' has the max occurrence: 4 times!
Character 'e' has the max occurrence: 4 times!

Encuentra el primer carácter que no se repite en una cadena

Entonces, necesitamos encontrar el primer carácter no repetitivo en una Cadena, eso significa que debemos iterar a través de todos los caracteres de esa Cadena, compararlos y tan pronto como encontremos el primer carácter no repetitivo, lo imprimimos y el trabajo está hecho.

Esto se hace fácilmente usando una bandera booleana y dos bucles. Para cada carácter, iteramos por el resto de la Cadena de entrada. Si el carácter del primer bucle coincide con alguno de los caracteres del segundo bucle, la bandera se establece en true.

Si el flag es falso, lo que significa que no encontramos al menos dos ocurrencias del mismo carácter, separamos e imprimimos el carácter:

String str = "Pharos.sh";
for (int i = 0; i < str.length(); i++) {
    boolean found = false;
    for (int j = 0; j < str.length(); j++) {
        if (i != j) {
            if (str.charAt(i) == str.charAt(j)) {
                found = true;
            }
        }
    }
    if (!found) {
        System.out.println("The first non-repeating character is: '" + str.charAt(i) + "'");
        break;
    } else if (found && i == str.length() - 1) {
        System.out.println("There is no non-repeating character in this string!");
    }
}

Salida:

The first non-repeating character is: 't'

Comprobar si dos cadenas son anagramas entre sí

Para esta pregunta, crearemos un método personalizado que verifica si dos cadenas dadas son anagramas y devuelve un valor booleano apropiado.

En primer lugar, modificamos nuestras dos cadenas eliminando todo el espacio en blanco que puedan tener. Después de recortarlos, comparamos su longitud; si no tienen la misma longitud, no hay posibilidad de que sean anagramas entre sí, así que si ese es el caso, regresamos false.

De lo contrario, transformamos nuestras cadenas en matrices de caracteres y convertimos su contenido en letras minúsculas. Finalmente, Arrays.sort() se llama para ambas cadenas y ordena los caracteres por orden alfabético y devolvemos el resultado de una función Arrays.equals() que compara dos matrices de caracteres y devuelve true si tienen los mismos caracteres:

public static boolean checkAnagram(String str, String str2) {
    str = str.replaceAll("\s", "");
    str2 = str2.replaceAll("\s", "");

    if (str.length() != str2.length()) {
        return false;
    } else {
        char[] strCharArray = str.toLowerCase().toCharArray();
        char[] strCharArray2 = str2.toLowerCase().toCharArray();

        Arrays.sort(strCharArray);
        Arrays.sort(strCharArray);

        return (Arrays.equals(strCharArray, strCharArray));
    }
}
    
public static void main(String[] args) {
    String str = "Pharos.sh";
    String str2 = "Backseat Us";

    if (checkAnagram(str, str2)) {
        System.out.println(str + " and " + str2 + " are Anagrams!");
    } else {
        System.out.println(str + " and " + str2 + " are not Anagrams!");
    }
}

Salida:

Pharos.sh and Backseat Us are Anagrams!

Contar el número de palabras en una cadena

Para lograr esto, debemos dividir nuestra Cadena en partes más pequeñas (palabras) y usar un carácter de espacio como delimitador:

String str = "Java is an awesome programming language!";
str = str.trim().replaceAll("\s{2,}", " ");
String splitStr[] = str.split(" ");
System.out.println("The provided string '" + str + "' contains " + splitStr.length + " words!");

Salida:

The provided string 'Java is an awesome programming language!' contains 6 words!

Conclusión

En este artículo, hemos cubierto las preguntas comunes de entrevistas relacionadas con Strings.

Si está interesado en leer más sobre Programación de preguntas de entrevista en general, hemos compilado una lista extensa de estas preguntas, incluidas sus explicaciones, implementaciones, representaciones visuales y aplicaciones.

Te puede interesar:Implementando Hibernate con Spring Boot y PostgreSQL