Introducción a Strings
En los programas escritos hasta ahora hemos utilizado los tipos primitivos:char,byte,int,float,double yboolean. Estos bastan para implementar muchas aplicaciones, sobre todo las relacionadas con datos numéricos, pero proporcionan pocas herramientas para trabajar con texto.
El tipo char, que almacena un solo carácter, es insuficiente para manejar textos complejos. Por texto entendemos una palabra, una frase e incluso uno o más párrafos de cualquier longitud.
¿Qué es una cadena de caracteres?
Para manipular textos disponemos en la API de las clases Charactery String, que proporcionan multitud de funcionalidades para trabajar con un solo carácter la primera y con textos de cualquier longitud la segunda.
1// Variable char: solo UN carácter
2char letra = 'A';
3
4// Variable String: MÚLTIPLES caracteres (texto)
5String palabra = "Hola";
6String frase = "Este es un texto completo";
7String parrafo = "Java es un lenguaje de programación orientado " +
8 "a objetos que permite crear aplicaciones robustas.";
9
10// La clase Character trabaja con char
11boolean esDigito = Character.isDigit('5'); // true
12
13// La clase String trabaja con cadenas
14int longitud = palabra.length(); // 4
15String mayusculas = palabra.toUpperCase(); // "HOLA"Clase Character
El tipo char es insuficiente, por sí solo, para realizar operaciones con caracteres. La clase Character amplía su funcionalidad para trabajar con caracteres simplificando mucho el trabajo.
Pensemos en lo engorroso que puede ser, por ejemplo, decidir si un carácter dado es una letra minúscula: para ello, tendríamos que realizar una serie de comprobaciones. Por el contrario, esta funcionalidad se encuentra enCharacter, que dispone de una batería de métodos estáticos, útiles para clasificar y convertir valores de tipo char.
1// Sin la clase Character (tedioso y propenso a errores)
2char c = 'a';
3boolean esMinuscula = (c >= 'a' && c <= 'z'); // Solo funciona para ASCII básico
4
5// Con la clase Character (simple y correcto)
6boolean esMinuscula2 = Character.isLowerCase(c); // Funciona con todos los idiomasVentajas de la clase Character
Character proporciona:- Métodos estáticos: No necesitas crear objetos
- Funciona con Unicode: Soporta caracteres internacionales
- Código más limpio: Más legible y mantenible
- Menos errores: Validaciones robustas incorporadas
Clasificación de Caracteres
Un carácter puede clasificarse dentro de algunos de los grupos siguientes:
- Dígitos: Este grupo está formado por los caracteres '0', '1', ..., '9'.
- Letras: Formado por todos los elementos del alfabeto, tanto en minúscula ('a', 'b', ...) como en mayúscula ('A', 'B', ...).
- Caracteres blancos: Como el espacio o el tabulador, entre otros.
- Otros caracteres: Signos de puntuación, matemáticos, etcétera.
Los métodos de Character para verificar si un carácter pertenece a alguno de estos grupos devuelven un boolean:true en caso de que pertenezca ofalse en caso contrario.
isDigit() - Verificar si es un Dígito
1boolean isDigit(char c)
2// Indica si el carácter c es un dígito (0-9)
3// Devuelve true en caso afirmativo y false en caso contrario1char c1 = '8';
2char c2 = 'p';
3
4boolean b;
5b = Character.isDigit(c1); // b vale true, ya que '8' es un dígito
6b = Character.isDigit(c2); // b es false, 'p' no es un dígito
7
8// Más ejemplos
9System.out.println(Character.isDigit('0')); // true
10System.out.println(Character.isDigit('9')); // true
11System.out.println(Character.isDigit('5')); // true
12System.out.println(Character.isDigit('a')); // false
13System.out.println(Character.isDigit(' ')); // false
14System.out.println(Character.isDigit('-')); // false (el signo no es un dígito)isLetter() - Verificar si es una Letra
1boolean isLetter(char c)
2// Determina si el carácter pasado como parámetro es una letra
3// (minúscula o mayúscula)1System.out.println(Character.isLetter('8')); // false: '8' no es una letra
2System.out.println(Character.isLetter('e')); // true: 'e' sí es una letra
3System.out.println(Character.isLetter('Z')); // true: 'Z' sí es una letra
4System.out.println(Character.isLetter('ñ')); // true: 'ñ' es una letra
5System.out.println(Character.isLetter('@')); // false: '@' no es una letraisLetterOrDigit() - Verificar si es Alfanumérico
1boolean isLetterOrDigit(char c)
2// Indica si el carácter es una letra o un dígito
3// El conjunto de estos caracteres se conoce como caracteres alfanuméricos1boolean b;
2
3b = Character.isLetterOrDigit('%'); // false: '%' no es alfanumérico
4b = Character.isLetterOrDigit('p'); // true: 'p' es una letra
5b = Character.isLetterOrDigit('2'); // true: '2' es un dígito
6
7// Más ejemplos
8System.out.println(Character.isLetterOrDigit('A')); // true
9System.out.println(Character.isLetterOrDigit('9')); // true
10System.out.println(Character.isLetterOrDigit(' ')); // false
11System.out.println(Character.isLetterOrDigit('!')); // falseisLowerCase() - Verificar si es Minúscula
1boolean isLowerCase(char c)
2// Especifica si c es una letra y, además, está en minúscula1char c1 = 'q';
2char c2 = 'Q';
3
4System.out.println(Character.isLowerCase('*')); // false: ni siquiera es una letra
5System.out.println(Character.isLowerCase(c1)); // true: es una letra en minúscula
6System.out.println(Character.isLowerCase(c2)); // false: es una letra, pero no minúscula
7System.out.println(Character.isLowerCase('a')); // true
8System.out.println(Character.isLowerCase('Z')); // false
9System.out.println(Character.isLowerCase('5')); // false: no es una letraisUpperCase() - Verificar si es Mayúscula
1boolean isUpperCase(char c)
2// Funciona igual que isLowerCase(), pero indicando si el carácter
3// es una letra mayúscula1System.out.println(Character.isUpperCase('t')); // false
2System.out.println(Character.isUpperCase('T')); // true
3System.out.println(Character.isUpperCase('A')); // true
4System.out.println(Character.isUpperCase('z')); // false
5System.out.println(Character.isUpperCase('3')); // false: no es una letraisSpaceChar() - Verificar si es Espacio
1boolean isSpaceChar(char c)
2// Devolverá true si el carácter utilizado como parámetro de entrada
3// es el espacio (' '), que se consigue pulsando en la barra espaciadora1System.out.println(Character.isSpaceChar(' ')); // true (espacio)
2System.out.println(Character.isSpaceChar('a')); // false: es obvio que no es un espacio
3System.out.println(Character.isSpaceChar(' ')); // false: el tabulador NO es un "space char"
4System.out.println(Character.isSpaceChar('
5')); // false: nueva línea NO es un "space char"isWhitespace() - Verificar si es Carácter Blanco
1boolean isWhitespace(char c)
2// Amplía el método isSpaceChar() y determina si el carácter pasado
3// es cualquier carácter blancoLos caracteres que hacen que el método devuelva true son:
- Espacio en blanco (' '): Se teclea mediante la barra espaciadora.
- Retorno de carro ('\r'): Dependiendo del sistema operativo, este carácter tendrá distinto comportamiento al imprimirse.
- Nueva línea ('\n'): Es el carácter que se consigue al pulsar la tecla Intro.
- Tabulador ('\t'): Equivale a varios espacios en blanco. Se genera con la tecla Tab.
- Otros: Existen otros caracteres considerados blancos como el tabulador vertical, el separador de ficheros, etc., aunque están en desuso.
1char c = ' ';
2
3System.out.println(Character.isWhitespace(c)); // true: tabulador
4System.out.println(Character.isWhitespace('
5')); // true: carácter nueva línea
6System.out.println(Character.isWhitespace(' ')); // true: espacio
7System.out.println(Character.isWhitespace('
')); // true: retorno de carro
8System.out.println(Character.isWhitespace('a')); // false: evidentemente no es un blanco| Método | Verifica | Ejemplo true | Ejemplo false |
|---|---|---|---|
| isDigit() | Es dígito (0-9) | '5' | 'a' |
| isLetter() | Es letra | 'A', 'z' | '7' |
| isLetterOrDigit() | Es letra o dígito | 'A', '9' | '@' |
| isLowerCase() | Es minúscula | 'a', 'z' | 'A', '5' |
| isUpperCase() | Es mayúscula | 'A', 'Z' | 'a', '5' |
| isSpaceChar() | Es espacio | ' ' | '\t', 'a' |
| isWhitespace() | Es carácter blanco | ' ', '\t', '\n' | 'a' |
1// Ejemplo práctico: Analizar un carácter
2Scanner sc = new Scanner(System.in);
3System.out.print("Introduce un carácter: ");
4char c = sc.next().charAt(0);
5
6System.out.println("
7=== ANÁLISIS DEL CARÁCTER '" + c + "' ===");
8
9if (Character.isDigit(c)) {
10 System.out.println("✓ Es un dígito");
11}
12
13if (Character.isLetter(c)) {
14 System.out.println("✓ Es una letra");
15 if (Character.isLowerCase(c)) {
16 System.out.println(" → En minúscula");
17 } else if (Character.isUpperCase(c)) {
18 System.out.println(" → En mayúscula");
19 }
20}
21
22if (Character.isWhitespace(c)) {
23 System.out.println("✓ Es un carácter blanco");
24}
25
26if (!Character.isLetterOrDigit(c) && !Character.isWhitespace(c)) {
27 System.out.println("✓ Es un carácter especial");
28}Conversión entre Caracteres
Son los métodos que transforman un carácter en otro. Cuando la conversión no es posible, por ejemplo, no se puede transformar un número a mayúscula, se devuelve el mismo carácter pasado como parámetro.
toLowerCase()
1char toLowerCase(char c)
2// Si el carácter pasado es una letra, lo devuelve convertido a minúscula
3// En otro caso, devuelve el mismo carácter1char c1 = 'A';
2char c2;
3
4c2 = Character.toLowerCase(c1); // c2 toma el valor 'a'
5c2 = Character.toLowerCase('3'); // al no ser una letra, devuelve '3'
6
7// Más ejemplos
8System.out.println(Character.toLowerCase('Z')); // 'z'
9System.out.println(Character.toLowerCase('m')); // 'm' (ya era minúscula)
10System.out.println(Character.toLowerCase('5')); // '5' (no es letra)
11System.out.println(Character.toLowerCase('@')); // '@' (no es letra)toUpperCase()
1char toUpperCase(char c)
2// Similar al anterior método, pero convierte el carácter,
3// si es una letra, a mayúscula. En otro caso devuelve el mismo carácter1char c1 = 'g';
2char c2 = Character.toUpperCase(c1); // a c2 se le asigna el valor 'G'
3
4// Más ejemplos
5System.out.println(Character.toUpperCase('a')); // 'A'
6System.out.println(Character.toUpperCase('H')); // 'H' (ya era mayúscula)
7System.out.println(Character.toUpperCase('7')); // '7' (no es letra)
8System.out.println(Character.toUpperCase('!')); // '!' (no es letra)1// Ejemplo práctico: Convertir texto carácter por carácter
2String texto = "HoLa MuNdO 123";
3
4System.out.println("Original: " + texto);
5
6// Convertir a mayúsculas carácter por carácter
7String mayusculas = "";
8for (int i = 0; i < texto.length(); i++) {
9 char c = texto.charAt(i);
10 mayusculas += Character.toUpperCase(c);
11}
12System.out.println("Mayúsculas: " + mayusculas); // "HOLA MUNDO 123"
13
14// Convertir a minúsculas carácter por carácter
15String minusculas = "";
16for (int i = 0; i < texto.length(); i++) {
17 char c = texto.charAt(i);
18 minusculas += Character.toLowerCase(c);
19}
20System.out.println("Minúsculas: " + minusculas); // "hola mundo 123"Clase String
Las cadenas, conjuntos secuenciales de caracteres, se manipulan mediante la clase String, que funciona de forma dual. Por un lado, de manera general, tiene un funcionamiento no estático; pero a su vez, dispone de algunos métodos que sí lo son.
Declaración de Variables String
Es posible definir variables de tipo String de la forma habitual:
1// Declaración de una variable String
2String cad; // cad es una variable de tipo cadena
3
4// Declaración e inicialización
5String nombre = "Juan";
6String apellido = "García";
7String mensaje = "Hola, mundo!";
8
9// String vacío
10String vacio = "";
11
12// String con múltiples líneas (Java 15+)
13String textoLargo = """
14 Este es un texto
15 que ocupa varias
16 líneas.
17 """;Literales de Cadena
Una variable de tipo String almacenará una cadena de caracteres, que provendrá de la manipulación de otra cadena o de un literal. Un literal cadena consiste en un texto entre comillas dobles ("). Es posible utilizar cualquier carácter.
1// Ejemplos de literales de cadena
2String saludo = "Hola
3"; // Con salto de línea
4String frase = "En un lugar de la mancha";
5String corazon = "Un corazón: ♡"; // Con carácter Unicode
6
7// Concatenación de literales
8String completo = "Primera parte " + "segunda parte";
9
10// Diferencia entre char y String
11char letra = 'a'; // Comillas simples: UN carácter
12String cadena = "a"; // Comillas dobles: CADENA de un carácter
13
14// Son tipos DIFERENTES
15// char letra2 = "a"; // ERROR: tipos incompatibles
16// String texto = 'a'; // ERROR: tipos incompatiblesDiferencia importante: char vs String
'a'es un carácter (tipochar)"a"es una cadena (tipoString) que está compuesta por un único carácter
Con una cadena de caracteres se pueden realizar multitud de operaciones. Algunas trabajan con la cadena como un todo y otras trabajan carácter a carácter.
Métodos Útiles de la Clase String
A continuación vamos a ver una gran cantidad de métodos que vamos a poder utilizar a lo largo de nuestros programas para mejorar el rendimiento y nuestro código y poder utilizar los strings de una manera cómoda.
length() - Obtener la Longitud
Devuelve la longitud de la cadena (número de caracteres).
1String texto = "Hola, mundo!";
2int longitud = texto.length();
3
4System.out.println(texto.length()); // Salida: 12
5
6// Más ejemplos
7System.out.println("Java".length()); // 4
8System.out.println("".length()); // 0 (cadena vacía)
9System.out.println(" ".length()); // 3 (tres espacios)
10System.out.println("Año 2024".length()); // 8
11
12// Uso práctico: validar longitud
13String password = "abc123";
14if (password.length() < 8) {
15 System.out.println("La contraseña debe tener al menos 8 caracteres");
16}charAt() - Obtener un Carácter
Devuelve el carácter en la posición especificada por el índice.
1String texto = "Hola";
2
3System.out.println(texto.charAt(0)); // 'H' (primer carácter, índice 0)
4System.out.println(texto.charAt(1)); // 'o'
5System.out.println(texto.charAt(2)); // 'l'
6System.out.println(texto.charAt(3)); // 'a' (último carácter)
7
8// Recorrer una cadena carácter por carácter
9String palabra = "Java";
10for (int i = 0; i < palabra.length(); i++) {
11 char c = palabra.charAt(i);
12 System.out.println("Posición " + i + ": " + c);
13}
14// Salida:
15// Posición 0: J
16// Posición 1: a
17// Posición 2: v
18// Posición 3: a
19
20// ERROR: índice fuera de rango
21// System.out.println(texto.charAt(10)); // StringIndexOutOfBoundsExceptionCuidado con los índices
StringIndexOutOfBoundsException.toUpperCase() y toLowerCase() - Convertir Mayúsculas/Minúsculas
Convierte la cadena a mayúsculas(toUpperCase()) o minúsculas(toLowerCase()).
1String texto = "Hola Mundo";
2
3System.out.println(texto.toUpperCase()); // "HOLA MUNDO"
4System.out.println(texto.toLowerCase()); // "hola mundo"
5
6// El original NO cambia (los Strings son inmutables)
7System.out.println(texto); // "Hola Mundo"
8
9// Para guardar el resultado
10String mayusculas = texto.toUpperCase();
11String minusculas = texto.toLowerCase();
12
13// Uso práctico: comparación sin importar mayúsculas
14String usuario1 = "ADMIN";
15String usuario2 = "admin";
16
17if (usuario1.toLowerCase().equals(usuario2.toLowerCase())) {
18 System.out.println("Los usuarios son iguales (ignorando mayúsculas)");
19}substring() - Extraer Subcadena
Extrae una subcadena de la cadena original.
1String texto = "Hola Mundo";
2
3// substring(start): Desde start hasta el final
4System.out.println(texto.substring(5)); // "Mundo"
5
6// substring(start, end): Desde start hasta end (sin incluir end)
7System.out.println(texto.substring(0, 4)); // "Hola"
8System.out.println(texto.substring(5, 10)); // "Mundo"
9
10// Más ejemplos
11String email = "usuario@ejemplo.com";
12
13// Extraer el nombre de usuario (antes del @)
14int posArroba = email.indexOf('@');
15String usuario = email.substring(0, posArroba); // "usuario"
16
17// Extraer el dominio (después del @)
18String dominio = email.substring(posArroba + 1); // "ejemplo.com"
19
20System.out.println("Usuario: " + usuario);
21System.out.println("Dominio: " + dominio);equals() y equalsIgnoreCase() - Comparar Cadenas
1String texto1 = "Hola";
2String texto2 = "hola";
3
4// equals(): Compara dos cadenas (sensible a mayúsculas)
5System.out.println(texto1.equals(texto2)); // false
6
7// equalsIgnoreCase(): Compara ignorando mayúsculas/minúsculas
8System.out.println(texto1.equalsIgnoreCase(texto2)); // true
9
10// Más ejemplos
11String pass1 = "Password123";
12String pass2 = "Password123";
13String pass3 = "password123";
14
15System.out.println(pass1.equals(pass2)); // true
16System.out.println(pass1.equals(pass3)); // false
17System.out.println(pass1.equalsIgnoreCase(pass3)); // true¡NUNCA uses == para comparar Strings!
if (texto1 == texto2)CORRECTO:
if (texto1.equals(texto2))El operador
== compara referencias (direcciones de memoria), NO el contenido de las cadenas. Usa siempre equals() o equalsIgnoreCase().contains() - Verificar si Contiene
Devuelve true si la cadena contiene la secuencia de caracteres especificada.
1String texto = "Hola Mundo";
2
3System.out.println(texto.contains("Mundo")); // true
4System.out.println(texto.contains("Java")); // false
5System.out.println(texto.contains("la")); // true
6System.out.println(texto.contains("LA")); // false (sensible a mayúsculas)
7
8// Uso práctico: filtrar
9String email = "info@ejemplo.com";
10if (email.contains("@") && email.contains(".")) {
11 System.out.println("Email parece válido");
12} else {
13 System.out.println("Email inválido");
14}
15
16// Búsqueda de palabras clave
17String mensaje = "Oferta especial: descuento del 50%";
18if (mensaje.contains("oferta") || mensaje.contains("descuento")) {
19 System.out.println("Es un mensaje promocional");
20}startsWith() y endsWith() - Verificar Inicio y Final
1String texto = "Hola Mundo";
2
3// startsWith(): Verifica si comienza con el prefijo
4System.out.println(texto.startsWith("Hola")); // true
5System.out.println(texto.startsWith("Mundo")); // false
6
7// endsWith(): Verifica si termina con el sufijo
8System.out.println(texto.endsWith("Mundo")); // true
9System.out.println(texto.endsWith("Hola")); // false
10
11// Ejemplos prácticos
12String archivo = "documento.pdf";
13if (archivo.endsWith(".pdf")) {
14 System.out.println("Es un archivo PDF");
15}
16
17String url = "https://www.ejemplo.com";
18if (url.startsWith("https://")) {
19 System.out.println("Es una conexión segura");
20}
21
22// Verificar prefijos de teléfono
23String telefono = "+34 666 123 456";
24if (telefono.startsWith("+34")) {
25 System.out.println("Teléfono de España");
26}replace() - Reemplazar Subcadenas
Reemplaza todas las apariciones de una subcadena por otra.
1String texto = "Hola Mundo";
2
3System.out.println(texto.replace("Mundo", "Java")); // "Hola Java"
4System.out.println(texto.replace("o", "0")); // "H0la Mund0"
5System.out.println(texto.replace(" ", "_")); // "Hola_Mundo"
6
7// El original NO cambia
8System.out.println(texto); // "Hola Mundo"
9
10// Más ejemplos
11String frase = "Java es Java y Java es genial";
12String nueva = frase.replace("Java", "Python");
13System.out.println(nueva); // "Python es Python y Python es genial"
14
15// Eliminar espacios (reemplazar por vacío)
16String conEspacios = "H o l a";
17String sinEspacios = conEspacios.replace(" ", "");
18System.out.println(sinEspacios); // "Hola"
19
20// Censurar palabras
21String mensaje = "Este es un mensaje malo";
22String censurado = mensaje.replace("malo", "****");
23System.out.println(censurado); // "Este es un mensaje ****"trim() - Eliminar Espacios en Blanco
Elimina los espacios en blanco al principio y al final de la cadena.
1String texto = " Hola Mundo ";
2
3System.out.println(texto); // " Hola Mundo "
4System.out.println(texto.trim()); // "Hola Mundo"
5
6// Longitud antes y después
7System.out.println(texto.length()); // 16
8System.out.println(texto.trim().length()); // 10
9
10// Uso práctico: limpiar entrada del usuario
11Scanner sc = new Scanner(System.in);
12System.out.print("Introduce tu nombre: ");
13String nombre = sc.nextLine().trim(); // Elimina espacios extras
14
15// Más ejemplos
16String email = " usuario@ejemplo.com ";
17String emailLimpio = email.trim();
18System.out.println("[" + email + "]"); // "[ usuario@ejemplo.com ]"
19System.out.println("[" + emailLimpio + "]"); // "[usuario@ejemplo.com]"
20
21// NOTA: trim() NO elimina espacios del medio
22String medio = "Hola Mundo";
23System.out.println(medio.trim()); // "Hola Mundo" (no cambia)split() - Dividir Cadena
Divide la cadena en un array de subcadenas, usando un delimitador.
1String texto = "Java,Python,C++";
2String[] lenguajes = texto.split(",");
3
4for (String lenguaje : lenguajes) {
5 System.out.println(lenguaje);
6}
7// Salida:
8// Java
9// Python
10// C++
11
12// Más ejemplos
13String frase = "Hola que tal estás";
14String[] palabras = frase.split(" "); // Dividir por espacios
15System.out.println("Número de palabras: " + palabras.length); // 4
16
17for (int i = 0; i < palabras.length; i++) {
18 System.out.println("Palabra " + (i + 1) + ": " + palabras[i]);
19}
20
21// Dividir por diferentes delimitadores
22String fecha = "15/02/2024";
23String[] partes = fecha.split("/");
24String dia = partes[0]; // "15"
25String mes = partes[1]; // "02"
26String año = partes[2]; // "2024"
27
28// CSV (valores separados por comas)
29String linea = "Juan,García,25,España";
30String[] datos = linea.split(",");
31System.out.println("Nombre: " + datos[0]);
32System.out.println("Apellido: " + datos[1]);
33System.out.println("Edad: " + datos[2]);
34System.out.println("País: " + datos[3]);isEmpty() y isBlank() - Verificar si está Vacía
1String texto1 = "";
2String texto2 = " ";
3String texto3 = "Hola";
4
5// isEmpty(): Verifica si está vacía (longitud = 0)
6System.out.println(texto1.isEmpty()); // true
7System.out.println(texto2.isEmpty()); // false (tiene espacios)
8System.out.println(texto3.isEmpty()); // false
9
10// isBlank(): Verifica si está vacía O solo tiene espacios (Java 11+)
11System.out.println(texto1.isBlank()); // true
12System.out.println(texto2.isBlank()); // true (solo espacios)
13System.out.println(texto3.isBlank()); // false
14
15// Uso práctico: validación de formularios
16String nombre = sc.nextLine().trim();
17if (nombre.isEmpty()) {
18 System.out.println("El nombre no puede estar vacío");
19}
20
21// Diferencia entre isEmpty() e isBlank()
22String espacios = " ";
23System.out.println("isEmpty: " + espacios.isEmpty()); // false
24System.out.println("isBlank: " + espacios.isBlank()); // true| Cadena | isEmpty() | isBlank() |
|---|---|---|
| "" | true | true |
| " " | false | true |
| "Hola" | false | false |
concat() - Concatenar Cadenas
Concatena la cadena actual con la cadena especificada.
1String texto = "Hola";
2
3System.out.println(texto.concat(" Mundo")); // "Hola Mundo"
4
5// Alternativa con el operador +
6String resultado1 = texto + " Mundo"; // Más común
7String resultado2 = texto.concat(" Mundo"); // Equivalente
8
9// Concatenación múltiple
10String nombre = "Juan";
11String apellido = "García";
12String completo = nombre.concat(" ").concat(apellido);
13System.out.println(completo); // "Juan García"
14
15// Más fácil con +
16String completo2 = nombre + " " + apellido;
17
18// Concatenar con números
19String mensaje = "Tienes ".concat(String.valueOf(5)).concat(" mensajes");
20// Más fácil:
21String mensaje2 = "Tienes " + 5 + " mensajes";valueOf() - Convertir a String
Convierte un valor primitivo u objeto en una cadena.
1// Convertir int a String
2int numero = 123;
3String texto = String.valueOf(numero);
4System.out.println(texto); // "123"
5
6// Convertir diferentes tipos
7String strDouble = String.valueOf(3.14); // "3.14"
8String strBoolean = String.valueOf(true); // "true"
9String strChar = String.valueOf('A'); // "A"
10
11// Uso práctico: concatenar números como texto
12int edad = 25;
13String mensaje = "Tengo " + String.valueOf(edad) + " años";
14// O más simple:
15String mensaje2 = "Tengo " + edad + " años"; // Conversión automática
16
17// Convertir arrays
18char[] letras = {'J', 'a', 'v', 'a'};
19String palabra = String.valueOf(letras);
20System.out.println(palabra); // "Java"compareTo() - Comparar Alfabéticamente
Compara dos cadenas alfabéticamente.
1String texto1 = "Hola";
2String texto2 = "Mundo";
3
4int resultado = texto1.compareTo(texto2);
5System.out.println(resultado); // Número negativo (Hola < Mundo alfabéticamente)
6
7// Interpretación del resultado:
8// = 0: las cadenas son iguales
9// > 0: la primera cadena es mayor (viene después alfabéticamente)
10// < 0: la primera cadena es menor (viene antes alfabéticamente)
11
12// Ejemplos
13System.out.println("abc".compareTo("abc")); // 0 (iguales)
14System.out.println("abc".compareTo("abd")); // -1 (abc < abd)
15System.out.println("abd".compareTo("abc")); // 1 (abd > abc)
16System.out.println("Apple".compareTo("Banana")); // Negativo
17System.out.println("Z".compareTo("A")); // Positivo
18
19// Uso práctico: ordenar
20String[] nombres = {"María", "Ana", "Carlos", "Beatriz"};
21
22// Ordenar manualmente
23for (int i = 0; i < nombres.length - 1; i++) {
24 for (int j = 0; j < nombres.length - i - 1; j++) {
25 if (nombres[j].compareTo(nombres[j + 1]) > 0) {
26 // Intercambiar
27 String temp = nombres[j];
28 nombres[j] = nombres[j + 1];
29 nombres[j + 1] = temp;
30 }
31 }
32}
33
34System.out.println(Arrays.toString(nombres));
35// ["Ana", "Beatriz", "Carlos", "María"]Resumen de Métodos String
| Método | Descripción | Ejemplo |
|---|---|---|
| length() | Longitud de la cadena | "Hola".length() → 4 |
| charAt(i) | Carácter en posición i | "Hola".charAt(1) → 'o' |
| toUpperCase() | Convertir a mayúsculas | "hola".toUpperCase() → "HOLA" |
| toLowerCase() | Convertir a minúsculas | "HOLA".toLowerCase() → "hola" |
| substring(s, e) | Extraer subcadena | "Hola".substring(0,2) → "Ho" |
| equals(s) | Comparar cadenas | "a".equals("a") → true |
| contains(s) | Contiene subcadena | "Hola".contains("ol") → true |
| replace(v, n) | Reemplazar texto | "Hola".replace("o","a") → "Hala" |
| trim() | Eliminar espacios extremos | " Hola ".trim() → "Hola" |
| split(d) | Dividir en array | "a,b".split(",") → ["a","b"] |
1// Ejemplo completo usando múltiples métodos
2String texto = " Java es GENIAL para programar ";
3
4System.out.println("Original: [" + texto + "]");
5System.out.println("Longitud: " + texto.length());
6
7// Limpiar espacios
8String limpio = texto.trim();
9System.out.println("Limpio: [" + limpio + "]");
10
11// Convertir a minúsculas
12String minusculas = limpio.toLowerCase();
13System.out.println("Minúsculas: " + minusculas);
14
15// Reemplazar palabras
16String cambiado = minusculas.replace("java", "python");
17System.out.println("Reemplazado: " + cambiado);
18
19// Verificar contenido
20if (texto.contains("Java")) {
21 System.out.println("Contiene la palabra Java");
22}
23
24// Dividir en palabras
25String[] palabras = limpio.split(" ");
26System.out.println("Número de palabras: " + palabras.length);
27
28for (String palabra : palabras) {
29 System.out.println("- " + palabra);
30}
31
32// Extraer subcadena
33String primeras4 = limpio.substring(0, 4);
34System.out.println("Primeras 4 letras: " + primeras4);Ejercicios Prácticos
Contador de Vocales y Consonantes
Crea un programa que: 1. Solicite una frase al usuario 2. Cuente cuántas vocales tiene (a, e, i, o, u) sin importar mayúsculas 3. Cuente cuántas consonantes tiene 4. Cuente cuántos espacios tiene 5. Cuente cuántos dígitos tiene 6. Muestre estadísticas completas Requisitos: - Usar Character.isLetter() para identificar letras - Usar Character.isDigit() para identificar dígitos - Recorrer la cadena carácter por carácter con charAt() - Convertir a minúsculas para comparar vocales Ejemplo: Introduce una frase: Hola Mundo 2024 Vocales: 5 Consonantes: 6 Espacios: 2 Dígitos: 4 Total caracteres: 15
Validador de Contraseñas Robusto
Crea un validador de contraseñas que verifique: 1. Longitud mínima de 8 caracteres 2. Al menos una letra mayúscula 3. Al menos una letra minúscula 4. Al menos un dígito 5. Al menos un carácter especial (!@#$%^&*) 6. No contiene espacios El programa debe: - Solicitar una contraseña al usuario - Verificar cada requisito usando métodos de Character y String - Mostrar qué requisitos cumple y cuáles no - Indicar si la contraseña es válida o no - Permitir intentar de nuevo hasta que sea válida Usa: - Character.isUpperCase(), isLowerCase(), isDigit() - String.length(), charAt(), contains() - Bucles para recorrer la contraseña
Palíndromo Detector
Un palíndromo es una palabra o frase que se lee igual de izquierda a derecha que de derecha a izquierda (ignorando espacios, tildes y mayúsculas). Ejemplos: "anilina", "radar", "Anita lava la tina" Crea un programa que: 1. Solicite una palabra o frase al usuario 2. Elimine espacios, convierta a minúsculas 3. Verifique si es un palíndromo comparando: - El primer carácter con el último - El segundo con el penúltimo - Y así sucesivamente 4. Muestre el resultado Requisitos: - Usar toLowerCase() y replace() para normalizar - Usar charAt() para acceder a posiciones específicas - Comparar desde ambos extremos hacia el centro Bonus: También detecta palíndromos con tildes (á→a, é→e, etc.)
Cifrado César
El cifrado César desplaza cada letra del alfabeto un número fijo de posiciones. Ejemplo con desplazamiento 3: A → D, B → E, C → F, ..., X → A, Y → B, Z → C "HOLA" → "KROD" Crea un programa que: 1. Solicite un texto al usuario 2. Solicite el desplazamiento (número de posiciones) 3. Cifre el texto: - Las letras se desplazan en el alfabeto - Mantener mayúsculas/minúsculas - Los espacios y números NO se cifran 4. Muestre el texto cifrado 5. Opción para descifrar (desplazamiento negativo) Pistas: - Usar Character.isLetter() para detectar letras - Usar aritmética de caracteres: 'A' + 3 = 'D' - Manejar el "wrap around" (Z + 1 = A) - Fórmula: nuevoChar = ((charActual - 'A' + desplaz) % 26) + 'A'
Generador de Acrónimos
Crea un programa que genere acrónimos a partir de frases. Ejemplos: "Organización de las Naciones Unidas" → "ONU" "Objeto Volador No Identificado" → "OVNI" "La Rioja España" → "LRE" El programa debe: 1. Solicitar una frase al usuario 2. Dividir la frase en palabras usando split() 3. Tomar la primera letra de cada palabra 4. Convertirla a mayúscula 5. Formar el acrónimo 6. Ignorar palabras muy cortas (de, la, el, etc.) opcionalmente Requisitos: - Usar split(" ") para dividir - Usar charAt(0) para obtener primera letra - Usar toUpperCase() para convertir - Validar que la palabra no esté vacía Bonus: Ignorar artículos y preposiciones comunes
Analizador de Nombres
Crea un programa que analice nombres completos y extraiga información: 1. Solicita un nombre completo (nombre y apellidos) 2. Extrae: - Nombre - Primer apellido - Segundo apellido (si existe) - Iniciales 3. Genera: - Nombre en formato oficial: "APELLIDO1 APELLIDO2, Nombre" - Usuario sugerido: primera letra nombre + primer apellido en minúsculas - Email sugerido: nombre.apellido1@ejemplo.com 4. Valida: - Que tenga al menos 2 palabras - Que no contenga números - Que cada palabra comience con mayúscula Usa: - split() para dividir el nombre - substring() y indexOf() para extraer partes - toLowerCase() y toUpperCase() para formatear - Character.isDigit() para validar
Procesador de Texto
Crea un mini procesador de texto con menú que permita: 1. **Contar palabras** - usando split() 2. **Contar caracteres** (con y sin espacios) 3. **Buscar y reemplazar** - palabra específica 4. **Convertir caso** - mayúsculas, minúsculas, título 5. **Invertir texto** - de derecha a izquierda 6. **Eliminar espacios extras** - múltiples espacios → uno solo 7. **Estadísticas completas** - vocales, consonantes, palabras más larga/corta El programa debe: - Mostrar un menú interactivo - Permitir introducir texto inicial - Aplicar operaciones múltiples - Mostrar el texto modificado después de cada operación - Opción para salir Este ejercicio integra TODO lo aprendido sobre Strings.
Practica con el IDE
Escribe tu solución directamente en el editor y pulsa Ejecutar: el programa se compila y se prueba con varios casos de prueba, algunos ocultos. Tu programa lee los datos de la entrada estándar con Scanner, así que funciona con cualquier valor.
Lee una frase y di si es palíndroma ignorando espacios y mayúsculas. Muestra 'Es palindromo' o 'No es palindromo'.
Lee una frase y cuenta cuántas vocales (a, e, i, o, u, en mayúscula o minúscula) contiene. Formato: 'Vocales: N'.