La clase String es la más ampliamente utilizada en la programación Java. Por eso, los programas de String se utilizan en entrevistas de Java para evaluar las habilidades de codificación.
Programas de String en Java
Aquí estoy proporcionando algunos programas de String en Java para ayudarte a mejorar tus habilidades de codificación. Por favor, intenta resolver estas preguntas por ti mismo antes de revisar las respuestas para aprender de una mejor manera. Estoy tratando de utilizar todas las últimas funcionalidades introducidas en Java, como Stream, expresiones lambda, interfaces funcionales, etc.
¿Cómo obtener caracteres distintos y su conteo en un String?
package com.journaldev.java.string;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class DistinctCharsCount {
public static void main(String[] args) {
printDistinctCharsWithCount("abc");
printDistinctCharsWithCount("abcab3");
printDistinctCharsWithCount("hi there, i am pankaj");
}
private static void printDistinctCharsWithCount(String input) {
Map charsWithCountMap = new HashMap<>();
// usando el método merge de Map de Java 8
for (char c : input.toCharArray())
charsWithCountMap.merge(c, 1, Integer::sum);
System.out.println(charsWithCountMap);
// otra forma utilizando las últimas mejoras de Java y sin bucle for, aunque un poco más complejo
List list = input.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
list.stream().forEach(c -> charsWithCountMap.merge(c, 1, Integer::sum));
System.out.println(charsWithCountMap);
}
}
Escribe un programa en Java para invertir una cadena.
Existen muchas formas de invertir una cadena. Algunas de las más comunes son:
- Método
reverse()de StringBuilder/StringBuffer - Usando un arreglo de caracteres o bytes y recorriendo en dirección inversa para poblar la cadena de resultado
Sin embargo, si no estás seguro del contenido de la cadena de entrada, siempre es recomendable utilizar el método reverse() incorporado en StringBuilder. Porque usar un arreglo de caracteres o bytes puede producir resultados no deseados. He proporcionado una explicación completa para esto en Invertir una cadena en Java.
package com.journaldev.java.string;
public class ReverseAString {
public static void main(String[] args) {
reverseInputString("abc");
reverseInputString("ç©∆˙¨˚ø"); //special chars
}
private static void reverseInputString(String input) {
StringBuilder sb = new StringBuilder(input);
String result = sb.reverse().toString();
System.out.println(result);
}
}
¿Cómo verificar si una cadena es un palíndromo?
A palindrome string is one whose reverse is also same string. So we can reverse the input string and check if both strings are equal for this. Or we can be smart and use the String charAt(int index) method to check for palindrome string.
package com.journaldev.java.string;
public class PalindromeString {
public static void main(String[] args) {
checkPalindromeString("abc");
checkPalindromeString("abcba");
checkPalindromeString("ç∂©∂ç");
}
private static void checkPalindromeString(String input) {
boolean result = true;
int length = input.length();
for(int i=0; i < length/2; i++) {
if(input.charAt(i) != input.charAt(length-i-1)) {
result = false;
break;
}
}
System.out.println(input + " is palindrome = "+result);
}
}
¿Cómo eliminar todas las ocurrencias de un carácter dado de una cadena de entrada?
No hay una función de eliminación en la clase String, pero podemos usar replaceAll() en este caso. Aquí tienes un programa simple que muestra cómo hacerlo.
package com.journaldev.java.string;
public class RemoveCharFromString {
public static void main(String[] args) {
removeCharFromString("abcbcdjfkd", 'c');
removeCharFromString("Pankaj", 'a');
removeCharFromString("ç∂©∂ç", '©');
}
private static void removeCharFromString(String input, char c) {
String result = input.replaceAll(String.valueOf(c), "");
System.out.println(result);
}
}
Cómo demostrar que String es inmutable programáticamente?
Sabemos que String es inmutable en Java, sin embargo, los nuevos desarrolladores aún se confunden con esto. Intentemos entender la razón de esta confusión.
String s1 = "Java";
s1 = "Python";
En el fragmento de código anterior, podemos decir que el valor de s1 cambió y es un objeto String. Entonces, ¿cómo podemos decir que String es inmutable? El punto más importante para entender es cómo se crean los Strings en Java. Cuando creamos un String usando un literal de cadena, no cambia el valor del String original. Crea un nuevo String en el pool de strings y cambia la referencia de la variable. Por lo tanto, el valor de la cadena original nunca cambia y por eso los Strings son inmutables. El siguiente programa demuestra nuestra afirmación, lee los comentarios para comprender correctamente el concepto.
package com.journaldev.java.string;
public class StringImmutabilityTest {
public static void main(String[] args) {
String s1 = "Java"; // "Java" String created in pool and reference assigned to s1
String s2 = s1; //s2 is also having the same reference to "Java" in the pool
System.out.println(s1 == s2); // proof that s1 and s2 have same reference
s1 = "Python";
//s1 valor se cambió arriba, ¿entonces cómo es inmutable String?
//bueno, en el caso anterior se creó un nuevo String "Python" en el pool
//s1 ahora se refiere al nuevo String en el pool
//PERO, el String original "Java" todavía está sin cambios y permanece en el pool
//s2 todavía se refiere al String original "Java" en el pool
// prueba de que s1 y s2 tienen referencias diferentes
System.out.println(s1 == s2);
System.out.println(s2);
// imprime "Java" apoyando el hecho de que el valor original del String está sin cambios, por lo tanto, el String es inmutable
}
}
Escribe un programa para contar el número de palabras en un String?
La solución simple a este programa parece ser input.split(" ").length pero esto no funcionará si tu cadena no está correctamente formateada y contiene espacios al principio y al final, espacios múltiples duplicados y tabulaciones. Afortunadamente, la función split() de String toma expresiones regulares como argumento y podemos usarla para contar el número de palabras en una cadena.
package com.journaldev.java.string;
public class CountNumberOfWordsInString {
public static void main(String[] args) {
countNumberOfWords("My name is Pankaj");
countNumberOfWords("I Love Java Programming");
countNumberOfWords(" This is not properly formatted line ");
}
private static void countNumberOfWords(String line) {
//System.out.println(line.split(" ").length); //no funcionará con tabulaciones y espacios múltiples
String trimmedLine = line.trim();
int count = trimmedLine.isEmpty() ? 0 : trimmedLine.split("\\s+").length;
System.out.println(count);
}
}
Escribe un programa para verificar si dos cadenas están creadas con los mismos caracteres?
En primer lugar, tendremos que crear un conjunto de caracteres a partir de las cadenas de entrada. Luego, usa el método equals() del conjunto para verificar si contienen los mismos caracteres o no. Aquí tienes un programa simple para verificar si dos cadenas están creadas con los mismos caracteres.
package com.journaldev.java.string;
import java.util.Set;
import java.util.stream.Collectors;
public class CheckSameCharsInString {
public static void main(String[] args) {
sameCharsStrings("abc", "cba");
sameCharsStrings("aabbcc", "abc");
sameCharsStrings("abcd", "abc");
sameCharsStrings("11", "1122");
sameCharsStrings("1122", "11");
}
private static void sameCharsStrings(String s1, String s2) {
Set<Character> set1 = s1.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
Set<Character> set2 = s2.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
System.out.println(set1.equals(set2));
}
}
Lee dos entradas de usuario de tipo String y verifica si el primero contiene el segundo?
Este es un programa simple y podemos usar el método contains() de String para verificar si una cadena especificada es parte de esta cadena. Sin embargo, tendremos que usar la clase Scanner para leer las entradas del usuario.
package com.journaldev.java.string;
import java.util.Scanner;
public class StringContainsSubstring {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter First String:");
String s1 = scanner.nextLine();
System.out.println("Enter Second String:");
String s2 = scanner.nextLine();
scanner.close();
boolean result = stringContainsSubstring(s1, s2);
System.out.println(s1+" contains "+s2+" = "+result);
}
private static boolean stringContainsSubstring(String string, String substring) {
boolean result = false;
result = string.contains(substring);
return result;
}
}
Aquí tienes una salida de ejemplo del programa anterior:
Enter First String:
Pankaj
Enter Second String:
an
Pankaj contains an = true
Cómo intercambiar dos cadenas sin usar una tercera variable?
Podemos hacerlo usando el método substring() de String. Aquí tienes un simple fragmento de código para mostrar esto:
String s1 = "abc";
String s2 = "def";
s1 = s1.concat(s2);
s2 = s1.substring(0,s1.length()-s2.length());
s1 = s1.substring(s2.length());
¿Qué pasa si tenemos que escribir una función para hacer esto? Dado que String es inmutable, el cambio en los valores de las referencias de String en el método desaparecerá tan pronto como termine el método. Además, no podemos devolver múltiples objetos desde un método en Java. Por lo tanto, tendremos que crear un contenedor para contener las cadenas de entrada y luego realizar la lógica anterior en el método. El siguiente código muestra cómo se puede hacer esto, aunque puede parecer complejo, pero la lógica es la misma que la anterior.
package com.journaldev.java.string;
import java.util.Scanner;
public class SwapTwoStrings {
public static void main(String[] args) {
Container container = new Container();
Scanner scanner = new Scanner(System.in);
System.out.println("Enter First String:");
container.setFirstString(scanner.nextLine());
System.out.println("Enter Second String:");
container.setSecondString(scanner.nextLine());
scanner.close();
System.out.println(container);
container = swapStrings(container);
System.out.println(container);
}
private static Container swapStrings(Container container) {
container.setFirstString(container.getFirstString().concat(container.getSecondString())); //s1 = s1+s2
container.setSecondString(container.getFirstString().substring(0, container.getFirstString().length()-container.getSecondString().length())); // s2=s1
container.setFirstString(container.getFirstString().substring(container.getSecondString().length()));
return container;
}
}
class Container{
private String firstString;
private String secondString;
public String getFirstString() {
return firstString;
}
public void setFirstString(String firstString) {
this.firstString = firstString;
}
public String getSecondString() {
return secondString;
}
public void setSecondString(String secondString) {
this.secondString = secondString;
}
@Override
public String toString() {
return "First String = "+firstString+", Second String = "+secondString;
}
}
Salida de ejemplo:
Enter First String:
Java
Enter Second String:
Python
First String = Java, Second String = Python
First String = Python, Second String = Java
Escribe un programa para encontrar el primer carácter no repetido de una cadena de entrada?
package com.journaldev.java.string;
import java.util.ArrayList;
import java.util.List;
public class FindNonRepeatingChar {
public static void main(String[] args) {
System.out.println(printFirstNonRepeatingChar("abcaabcdedxy"));
System.out.println(printFirstNonRepeatingChar("abca"));
System.out.println(printFirstNonRepeatingChar("aaa"));
}
private static Character printFirstNonRepeatingChar(String string) {
char[] chars = string.toCharArray();
List<Character> discardedChars = new ArrayList<>();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if (discardedChars.contains(c))
continue;
for (int j = i + 1; j < chars.length; j++) {
if (c == chars[j]) { // match found
discardedChars.add(c);
break;
} else if (j == chars.length - 1) { // no match found till end
return c;
}
}
}
return null;
}
}
Proporciona dos formas de comprobar si una cadena contiene solo dígitos?
Podemos usar expresiones regulares para comprobar si una cadena es numérica o no. Otra forma es analizarla como Long y si es una cadena no numérica, lanzará NumberFormatException.
package com.journaldev.java.string;
public class CheckIfStringContainsDigitsOnly {
public static void main(String[] args) {
digitsOnlyString("111");
digitsOnlyString("111a 1");
digitsOnlyString("111 222");
digitsOnlyString("111L");
}
private static void digitsOnlyString(String string) {
if(string.matches("\\d+")) System.out.println("Digit Only String ::"+string);
try {
long l = Long.parseLong(string);
System.out.println("Digit Only String ::"+string);
}catch(Exception e){
System.out.println("Non Digit Only String ::"+string);
}
}
}
Cómo realizar una copia profunda para String?
String es inmutable, así que no necesitamos preocuparnos por la copia profunda o la copia superficial. Simplemente podemos usar el operador de asignación (=) para copiar una cadena en otra. Lee más detalles en Copia de cadenas en Java.
Puedes descargar los ejemplos desde mi Repositorio de GitHub.
Source:
https://www.digitalocean.com/community/tutorials/string-programs-in-java