Domina los Arreglos y Cadenas de Texto en Java con 10 ejercicios prácticos y resueltos.
¡Hola, futuro experto en Java! Hoy vamos a sumergirnos en dos de las herramientas más poderosas y utilizadas en la programación: los arreglos y las cadenas de texto. Aprender a manejarlos con soltura es como aprender a organizar tus herramientas y a comunicarte con claridad; es fundamental para construir cualquier programa útil y eficiente. A través de explicaciones claras y 10 ejercicios prácticos, te guiaremos para que domines estas estructuras desde cero. ¿Listo para empezar?
Aprendizaje Teórico: Conceptos Clave
Antes de lanzarnos a resolver problemas, vamos a sentar unas bases sólidas.
Arreglos (Arrays): Colecciones Ordenadas
Un arreglo (o array en inglés) es una estructura de datos que nos permite almacenar una colección de elementos del mismo tipo en una secuencia ordenada. Imagina un casillero con muchos compartimentos numerados: cada compartimento guarda un objeto y puedes acceder a él directamente si sabes su número.
Características principales de los arreglos en Java:
- Tamaño Fijo: Una vez que creas un arreglo con un tamaño determinado, no puedes cambiarlo.
- Mismo Tipo de Dato: Solo puedes guardar un tipo de dato en él (todos enteros, todos
String, etc.). - Índices Basados en Cero: El primer elemento se encuentra en la posición (índice) 0, el segundo en la 1, y así sucesivamente. Para acceder al último elemento de un arreglo
miArray, usaríasmiArray[miArray.length - 1].
Cadenas de Texto (Strings): Más que Simples Palabras
En Java, una cadena de texto (String) no es un tipo de dato primitivo como int o boolean, sino un objeto. Esto le otorga superpoderes, ya que viene con un montón de métodos útiles para manipular el texto. Piensa en un String como una secuencia inmutable de caracteres.
- Inmutabilidad: Una vez que se crea un objeto
String, su contenido no puede ser modificado. Si parece que lo modificas (por ejemplo, al convertirlo a mayúsculas), en realidad Java crea un nuevo objetoStringcon el resultado. - Métodos Útiles:
length()para saber su longitud,charAt(index)para obtener un carácter en una posición específica,toUpperCase()para convertir a mayúsculas,substring(inicio, fin)para extraer una parte de la cadena, ¡y muchos más!
¡Ahora te Toca a Ti! Intenta Resolverlo Primero
La programación se aprende practicando. Antes de ver la solución de cada ejercicio, te retamos a que lo intentes por tu cuenta. Lee el problema, piensa en la lógica que usarías y escribe el código. ¡No importa si te equivocas! El proceso de pensar y experimentar es lo que realmente te hará aprender. Una vez que tengas tu propuesta, compárala con la nuestra.
10 Ejercicios Resueltos de Arreglos y Cadenas
Ejercicio 1: Sumar los Elementos de un Arreglo
Problema: Crea un programa que declare un arreglo de números enteros y calcule la suma de todos sus elementos.
// Archivo: SumaArreglo.java
public class SumaArreglo {
public static void main(String[] args) {
// 1. Declaramos e inicializamos el arreglo de enteros
int[] numeros = {5, 10, 15, 20, 25};
// 2. Inicializamos una variable para almacenar la suma
int suma = 0;
// 3. Recorremos el arreglo con un bucle 'for-each'
// Este tipo de bucle es ideal para recorrer colecciones
for (int numero : numeros) {
// En cada iteración, 'numero' toma el valor de un elemento del arreglo
suma += numero; // Acumulamos el valor en la variable 'suma'
}
// 4. Mostramos el resultado por consola
System.out.println("La suma de los elementos del arreglo es: " + suma);
}
}
Ejercicio 2: Contar Vocales en una Cadena
Problema: Escribe un programa que cuente el número de vocales (a, e, i, o, u) en una cadena de texto dada.
// Archivo: ContadorVocales.java
public class ContadorVocales {
public static void main(String[] args) {
String texto = "Hola Mundo, estamos programando en Java!";
int contadorVocales = 0;
// Convertimos el texto a minúsculas para simplificar la comparación
String textoEnMinusculas = texto.toLowerCase();
// Recorremos cada caracter de la cadena
for (int i = 0; i < textoEnMinusculas.length(); i++) {
// Obtenemos el caracter en la posición 'i'
char caracter = textoEnMinusculas.charAt(i);
// Verificamos si el caracter es una vocal
if (caracter == 'a' || caracter == 'e' || caracter == 'i' || caracter == 'o' || caracter == 'u') {
contadorVocales++; // Si es vocal, incrementamos el contador
}
}
System.out.println("El número de vocales en el texto es: " + contadorVocales);
}
}
Ejercicio 3: Encontrar el Número Más Grande en un Arreglo
Problema: Dado un arreglo de números enteros, encuentra y muestra el valor máximo.
// Archivo: MaximoEnArreglo.java
public class MaximoEnArreglo {
public static void main(String[] args) {
int[] numeros = {12, 45, 7, 23, 51, 3, 19};
// Suponemos que el primer elemento es el máximo para empezar a comparar
int maximo = numeros[0];
// Recorremos el arreglo desde el segundo elemento (índice 1)
for (int i = 1; i < numeros.length; i++) {
// Si el elemento actual es mayor que nuestro máximo actual...
if (numeros[i] > maximo) {
maximo = numeros[i]; // ...lo actualizamos.
}
}
System.out.println("El número más grande en el arreglo es: " + maximo);
}
}
Ejercicio 4: Invertir una Cadena de Texto
Problema: Crea un programa que tome una cadena de texto y la imprima en orden inverso.
// Archivo: InvertirCadena.java
public class InvertirCadena {
public static void main(String[] args) {
String original = "Java";
String invertida = "";
// Recorremos la cadena desde el último caracter hacia el primero
for (int i = original.length() - 1; i >= 0; i--) {
// Concatenamos cada caracter a nuestra nueva cadena 'invertida'
invertida += original.charAt(i);
}
System.out.println("Cadena original: " + original);
System.out.println("Cadena invertida: " + invertida);
}
}
Ejercicio 5: Comprobar si una Palabra es un Palíndromo
Problema: Un palíndromo es una palabra que se lee igual de izquierda a derecha que de derecha a izquierda (ej. «reconocer»). Escribe un programa que determine si una cadena es un palíndromo.
// Archivo: PalindromoCheck.java
public class PalindromoCheck {
public static void main(String[] args) {
String palabra = "reconocer";
String invertida = "";
// 1. Invertimos la palabra (igual que en el ejercicio anterior)
for (int i = palabra.length() - 1; i >= 0; i--) {
invertida += palabra.charAt(i);
}
// 2. Comparamos la original con la invertida usando el método .equals()
if (palabra.equals(invertida)) {
System.out.println("La palabra '" + palabra + "' es un palíndromo.");
} else {
System.out.println("La palabra '" + palabra + "' no es un palíndromo.");
}
}
}
Ejercicio 6: Contar Palabras en una Frase
Problema: Dado un String que contiene una frase, cuenta cuántas palabras hay. Puedes asumir que las palabras están separadas por un único espacio.
// Archivo: ContadorPalabras.java
public class ContadorPalabras {
public static void main(String[] args) {
String frase = "La programación orientada a objetos es un paradigma.";
// El método split() divide la cadena en un arreglo de subcadenas
// usando el delimitador que le pasemos (en este caso, un espacio).
String[] palabras = frase.split(" ");
// El número de palabras es simplemente la longitud del arreglo resultante.
int numeroDePalabras = palabras.length;
System.out.println("La frase tiene " + numeroDePalabras + " palabras.");
}
}
Ejercicio 7: Reemplazar Caracteres en una Cadena
Problema: Escribe un programa que reemplace todas las ocurrencias de la letra ‘a’ por la letra ‘x’ en una cadena de texto.
// Archivo: ReemplazarCaracter.java
public class ReemplazarCaracter {
public static void main(String[] args) {
String original = "La casa de la abuela es grande y antigua.";
// El método replace() devuelve una NUEVA cadena con los reemplazos hechos.
// Recuerda que los Strings son inmutables.
String modificada = original.replace('a', 'x');
System.out.println("Original: " + original);
System.out.println("Modificada: " + modificada);
}
}
Ejercicio 8: Eliminar Duplicados de un Arreglo
Problema: Crea un programa que tome un arreglo de enteros con duplicados y genere un nuevo arreglo que contenga solo los elementos únicos. Este es un reto un poco más avanzado.
// Archivo: EliminarDuplicados.java
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
public class EliminarDuplicados {
public static void main(String[] args) {
// Arreglo original con duplicados
Integer[] arregloConDuplicados = {1, 2, 3, 2, 4, 5, 1, 6, 3};
// Un 'Set' es una colección que no permite elementos duplicados.
// Usamos LinkedHashSet para mantener el orden de inserción.
Set<Integer> setSinDuplicados = new LinkedHashSet<>(Arrays.asList(arregloConDuplicados));
// Convertimos el Set de nuevo a un arreglo
Integer[] arregloSinDuplicados = setSinDuplicados.toArray(new Integer[0]);
// Mostramos el resultado
System.out.println("Arreglo original: " + Arrays.toString(arregloConDuplicados));
System.out.println("Arreglo sin duplicados: " + Arrays.toString(arregloSinDuplicados));
}
}
Ejercicio 9: Encontrar la Palabra Más Larga
Problema: Dado un arreglo de String, encuentra y muestra la palabra más larga.
// Archivo: PalabraMasLarga.java
public class PalabraMasLarga {
public static void main(String[] args) {
String[] palabras = {"coche", "bicicleta", "motocicleta", "avión", "tren"};
// Asumimos que la primera palabra es la más larga para empezar
String masLarga = palabras[0];
// Recorremos el arreglo
for (String palabra : palabras) {
// Si la longitud de la palabra actual es mayor que la de 'masLarga'...
if (palabra.length() > masLarga.length()) {
masLarga = palabra; // ...la actualizamos.
}
}
System.out.println("La palabra más larga es: " + masLarga);
}
}
Ejercicio 10: Generar un Acrónimo
Problema: Escribe un programa que genere un acrónimo a partir de una frase. Un acrónimo se forma con la primera letra de cada palabra, en mayúsculas.
// Archivo: GeneradorAcronimo.java
public class GeneradorAcronimo {
public static void main(String[] args) {
String frase = "Organización de las Naciones Unidas";
String acronimo = "";
// 1. Dividimos la frase en palabras
String[] palabras = frase.split(" ");
// 2. Recorremos el arreglo de palabras
for (String palabra : palabras) {
// 3. Obtenemos la primera letra de cada palabra y la añadimos al acrónimo
acronimo += palabra.charAt(0);
}
// 4. Convertimos el resultado a mayúsculas
acronimo = acronimo.toUpperCase();
System.out.println("La frase es: '" + frase + "'");
System.out.println("El acrónimo es: " + acronimo); // Salida: ONU
}
}
Preguntas Frecuentes (FAQs)
¿Cuál es la diferencia entre String y char?
Un char es un tipo de dato primitivo que representa un único carácter (ej. 'a', '%', '7'). Un String es un objeto que representa una secuencia de caracteres (ej. "Hola"). Un String está compuesto, internamente, por muchos char.
¿Por qué el primer índice de un arreglo es 0 y no 1?
Esta convención, llamada «indexación basada en cero», proviene de los lenguajes de programación de bajo nivel como C. El índice en realidad representa un «desplazamiento» desde la dirección de memoria de inicio del arreglo. El primer elemento está a 0 posiciones de distancia del inicio, el segundo a 1 posición, y así sucesivamente. Aunque al principio puede ser confuso, es un estándar en la mayoría de los lenguajes de programación modernos.
¿Qué significa que un String es «inmutable»?
Significa que una vez que creas un objeto String, su valor (la secuencia de caracteres) no puede ser alterado. Cualquier método que parezca modificarlo, como toUpperCase() o replace(), no cambia el String original, sino que devuelve un nuevo objeto String con la modificación.
¡Has Desbloqueado un Nivel Clave!
¡Felicidades! Al completar estos ejercicios, has dado un paso gigante en tu camino con Java. Los arreglos y las cadenas son el pan de cada día en el desarrollo de software, y ahora tienes las herramientas prácticas para manejarlos con confianza. Has aprendido a recorrerlos, a buscar datos, a manipularlos y a resolver problemas lógicos con ellos.
No te detengas aquí. La clave es la práctica continua. Intenta modificar estos ejercicios o crea nuevos retos para ti mismo. ¡Cada línea de código que escribes te hace un mejor desarrollador!
¿Disfrutaste resolviendo estos problemas? ¿Quieres seguir aprendiendo y enfrentarte a desafíos más grandes? ¡Visita nuestro blog para encontrar más guías, tutoriales avanzados y ejercicios que llevarán tus habilidades en Java al siguiente nivel!
