Introducción
Contenido
- 1 Introducción
- 2 Preguntas de la entrevista sobre cadenas de Java
- 3 Preguntas teóricas
- 4 Clases de cadenas
- 5 Inmutabilidad de Strings
- 6 Piscina de Strings
- 7 Herencia de cadenas
- 8 == vs .equals ()
- 9 Índice de caracteres
- 10 Concatenación de cadenas
- 11 String Thread Safety
- 12 String vs StringBuilder vs StringBuffer
- 13 Coding Questions
- 13.0.1 Reversing a String
- 13.0.2 Comprobación de si la cadena contiene solo dígitos
- 13.0.3 Cómo convertir una cadena en entero
- 13.0.4 Eliminar caracteres duplicados en una cadena
- 13.0.5 Encontrar el carácter máximo que ocurre en una cadena
- 13.0.6 Encuentra el primer carácter que no se repite en una cadena
- 13.0.7 Comprobar si dos cadenas son anagramas entre sí
- 13.0.8 Contar el número de palabras en una cadena
- 14 Conclusió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 String
s 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.
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 devuelvetrue
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 devuelvetrue
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.
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.
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:
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 HashSet
s, Stream
s, e incluso LinkedList
s. 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 HashMap
s. 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 JavaCharacter ' ' 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