Métodos de la clase String - parte 1

Métodos de String parte 1

flowchart TB
    Str[String inmutable] --> Search[Búsqueda]
    Str --> Cmp[Comparación]
    Str --> Mod[Transformación]
    Search --> Idx[indexOf lastIndexOf]
    Search --> Cont[contains]
    Search --> Match[matches regex]
    Cmp --> Eq[equals equalsIgnoreCase]
    Cmp --> Co[compareTo]
    Mod --> Up[toUpperCase toLowerCase]
    Mod --> Trim[trim strip]
    Mod --> Sub[substring]

Métodos de manipulación básica (length, charAt, substring)

La clase String en Java proporciona un conjunto de métodos fundamentales para manipular cadenas de texto. Estos métodos básicos permiten examinar y extraer información de las cadenas sin modificar la cadena original, ya que los objetos String son inmutables en Java.

Método length()

El método length() se utiliza para obtener el número de caracteres que componen una cadena. Este método no recibe parámetros y devuelve un valor entero que representa la longitud de la cadena.

String texto = "Programación en Java";
int longitud = texto.length(); // Devuelve 20
System.out.println("La cadena tiene " + longitud + " caracteres");

length() cuenta todos los caracteres, incluyendo espacios en blanco y caracteres especiales. Este método resulta esencial cuando se necesita:

• Validar la longitud de entradas de usuario
• Iterar sobre cada carácter de una cadena
• Verificar si una cadena está vacía (cuando length() devuelve 0)

String password = "abc123";
if (password.length() < 8) {
    System.out.println("La contraseña debe tener al menos 8 caracteres");
}

Método charAt()

El método charAt(int index) permite acceder a un carácter específico dentro de una cadena mediante su posición o índice. Los índices en Java comienzan en 0, por lo que el primer carácter está en la posición 0, el segundo en la posición 1, y así sucesivamente.

String palabra = "Java";
char primeraLetra = palabra.charAt(0); // Devuelve 'J'
char ultimaLetra = palabra.charAt(palabra.length() - 1); // Devuelve 'a'

Si se intenta acceder a un índice fuera del rango válido (negativo o mayor o igual a la longitud de la cadena), se lanza una excepción StringIndexOutOfBoundsException. Por ello, se recomienda verificar siempre que el índice sea válido antes de llamar a este método.

String texto = "Hola";
int indice = 10;

if (indice >= 0 && indice < texto.length()) {
    char caracter = texto.charAt(indice);
    System.out.println("El carácter en la posición " + indice + " es: " + caracter);
} else {
    System.out.println("Índice fuera de rango");
}

El método charAt() se utiliza a menudo para:

• Recorrer una cadena carácter por carácter
• Verificar si una cadena contiene ciertos caracteres específicos
• Construir algoritmos de procesamiento de texto

String frase = "Java es un lenguaje de programación";
int contadorVocales = 0;

for (int i = 0; i < frase.length(); i++) {
    char c = Character.toLowerCase(frase.charAt(i));
    if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
        contadorVocales++;
    }
}

System.out.println("La frase contiene " + contadorVocales + " vocales");

Método substring()

El método substring() permite extraer una subcadena de una cadena existente. Existen dos variantes de este método:

• substring(int beginIndex): Extrae desde la posición indicada hasta el final de la cadena.
• substring(int beginIndex, int endIndex): Extrae desde la posición inicial hasta la posición final (sin incluir el carácter en la posición final).

String mensaje = "Aprendiendo Java";

// Extrae desde la posición 12 hasta el final
String lenguaje = mensaje.substring(12); // Devuelve "Java"

// Extrae desde la posición 0 hasta la 11 (sin incluir el carácter en la posición 11)
String accion = mensaje.substring(0, 11); // Devuelve "Aprendiendo"

El índice final no se incluye en el resultado. Si se quiere incluir el carácter en la posición n, se debe usar n+1 como índice final.

Al igual que con charAt(), si se proporcionan índices fuera del rango válido, se lanza una StringIndexOutOfBoundsException. Además, si el índice inicial es mayor que el índice final, también se produce una excepción.

String url = "https://www.ejemplo.com/recursos/archivo.pdf";

// Extraer el protocolo
int indiceSeparador = url.indexOf("://");
if (indiceSeparador != -1) {
    String protocolo = url.substring(0, indiceSeparador);
    System.out.println("Protocolo: " + protocolo); // Muestra "https"
}

// Extraer la extensión del archivo
int indicePunto = url.lastIndexOf(".");
if (indicePunto != -1) {
    String extension = url.substring(indicePunto + 1);
    System.out.println("Extensión: " + extension); // Muestra "pdf"
}

El método substring() se utiliza comúnmente para:

• Extraer partes significativas de una cadena (como dominios de URLs)
• Procesar formatos específicos (como fechas o códigos)
• Implementar algoritmos de análisis de texto

// Extraer componentes de una fecha en formato "dd/mm/aaaa"
String fecha = "23/04/2023";
String dia = fecha.substring(0, 2);
String mes = fecha.substring(3, 5);
String anio = fecha.substring(6);

System.out.println("Día: " + dia);
System.out.println("Mes: " + mes);
System.out.println("Año: " + anio);

Combinación de métodos básicos

Estos métodos de manipulación básica se pueden combinar para realizar operaciones más complejas sobre cadenas de texto:

String correo = "usuario@dominio.com";

// Verificar si es un correo válido (simplificado)
boolean esValido = correo.length() > 5 && 
                  correo.indexOf('@') > 0 && 
                  correo.indexOf('@') < correo.length() - 3;

// Extraer nombre de usuario y dominio
if (esValido) {
    int posicionArroba = correo.indexOf('@');
    String usuario = correo.substring(0, posicionArroba);
    String dominio = correo.substring(posicionArroba + 1);
    
    System.out.println("Usuario: " + usuario);
    System.out.println("Dominio: " + dominio);
    
    // Verificar primera letra del usuario
    char primeraLetra = usuario.charAt(0);
    if (Character.isLetter(primeraLetra)) {
        System.out.println("El nombre de usuario comienza con una letra");
    }
}

En este ejemplo se combinan los métodos length(), indexOf(), substring() y charAt() para analizar y validar una dirección de correo electrónico de forma básica.

Métodos de búsqueda y comparación

La clase String en Java ofrece un conjunto de métodos para buscar información dentro de cadenas y realizar comparaciones entre ellas. Estos métodos son fundamentales para el procesamiento de texto y la validación de datos en aplicaciones.

Métodos de búsqueda

Los métodos de búsqueda permiten localizar subcadenas o caracteres específicos dentro de un String. Estos métodos devuelven la posición donde se encuentra el elemento buscado o un valor negativo si no se encuentra.

indexOf() y lastIndexOf()

El método indexOf() busca la primera ocurrencia de un carácter o subcadena, mientras que lastIndexOf() busca la última ocurrencia:

String texto = "Java es un lenguaje versátil. Java es popular.";

// Búsqueda básica
int primera = texto.indexOf("Java");       // Devuelve 0
int ultima = texto.lastIndexOf("Java");    // Devuelve 25

// Búsqueda a partir de una posición específica
int segunda = texto.indexOf("Java", 1);    // Devuelve 25
int anterior = texto.lastIndexOf("es", 20); // Devuelve 6

Estos métodos son extremadamente útiles para analizar y extraer partes de textos estructurados:

String html = "<div><p>Contenido del párrafo</p></div>";

int inicioParrafo = html.indexOf("<p>") + 3;
int finParrafo = html.indexOf("</p>");

if (inicioParrafo != -1 && finParrafo != -1) {
    String contenido = html.substring(inicioParrafo, finParrafo);
    System.out.println("Texto extraído: " + contenido);
}

contains()

El método contains() verifica si una cadena contiene una subcadena específica, devolviendo un valor booleano:

String mensaje = "Aprende a programar en Java";
boolean contienePalabra = mensaje.contains("Java");    // true
boolean contienePython = mensaje.contains("Python");   // false

Se utiliza a menudo para validaciones simples:

String correo = "usuario@dominio.com";

if (!correo.contains("@")) {
    System.out.println("Correo electrónico inválido");
} else {
    System.out.println("Formato de correo válido");
}

startsWith() y endsWith()

Estos métodos verifican si una cadena comienza o termina con una subcadena específica:

String archivo = "documento.pdf";

if (archivo.startsWith("doc")) {
    System.out.println("El archivo comienza con 'doc'");
}

if (archivo.endsWith(".pdf")) {
    System.out.println("Es un archivo PDF");
}

También se pueden especificar posiciones de inicio para startsWith():

String url = "https://www.ejemplo.com";
boolean esSegura = url.startsWith("https");  // true

String ruta = "/usuarios/perfil/123";
boolean esPerfil = ruta.startsWith("/perfil", 9);  // true

Métodos de comparación

Los métodos de comparación permiten determinar la relación entre cadenas, lo que es esencial para ordenamiento, búsqueda y validación.

equals() y equalsIgnoreCase()

El método equals() compara si dos cadenas tienen exactamente el mismo contenido, mientras que equalsIgnoreCase() realiza la misma comparación ignorando mayúsculas y minúsculas:

String usuario1 = "admin";
String usuario2 = "Admin";

boolean sonIguales = usuario1.equals(usuario2);             // false
boolean sonIgualesIgnorandoMayus = usuario1.equalsIgnoreCase(usuario2);  // true

Nunca se debe usar el operador == para comparar el contenido de Strings, ya que este compara referencias de objetos, no su contenido:

String a = "hola";
String b = new String("hola");

System.out.println(a == b);           // false (referencias distintas)
System.out.println(a.equals(b));      // true (mismo contenido)

compareTo() y compareToIgnoreCase()

Estos métodos comparan cadenas lexicográficamente (orden alfabético) y devuelven un entero que indica su relación:

String palabra1 = "banana";
String palabra2 = "manzana";

int resultado = palabra1.compareTo(palabra2);  // Negativo: palabra1 va antes

El valor devuelto indica:

• Negativo: la primera cadena va antes alfabéticamente
• Cero: las cadenas son iguales
• Positivo: la primera cadena va después alfabéticamente

Estos métodos son fundamentales para ordenar colecciones de cadenas:

List<String> frutas = new ArrayList<>(List.of("Manzana", "banana", "Pera", "kiwi"));

// Ordenar ignorando mayúsculas y minúsculas
frutas.sort((a, b) -> a.compareToIgnoreCase(b));

System.out.println(frutas);  // [banana, kiwi, Manzana, Pera]

regionMatches()

Este método permite comparar regiones específicas de dos cadenas, ofreciendo gran flexibilidad:

String texto1 = "Programación en Java";
String texto2 = "Curso de JAVA avanzado";

// Comparar "Java" con "JAVA" ignorando mayúsculas
boolean coincide = texto1.regionMatches(
    true,       // ignorar mayúsculas/minúsculas
    15,         // índice de inicio en texto1
    texto2,     // segunda cadena
    9,          // índice de inicio en texto2
    4           // número de caracteres a comparar
);

System.out.println(coincide);  // true

Patrones de uso comunes

Validación de formatos

Se pueden combinar métodos de búsqueda y comparación para validar formatos específicos:

public boolean esFormatoFechaValido(String fecha) {
    // Verificar formato DD/MM/AAAA
    if (fecha.length() != 10) return false;
    if (fecha.charAt(2) != '/' || fecha.charAt(5) != '/') return false;
    
    try {
        int dia = Integer.parseInt(fecha.substring(0, 2));
        int mes = Integer.parseInt(fecha.substring(3, 5));
        int anio = Integer.parseInt(fecha.substring(6));
        
        return dia >= 1 && dia <= 31 && mes >= 1 && mes <= 12 && anio > 0;
    } catch (NumberFormatException e) {
        return false;
    }
}

Búsqueda de patrones simples

public List<Integer> encontrarTodasLasOcurrencias(String texto, String patron) {
    List<Integer> posiciones = new ArrayList<>();
    int indice = 0;
    
    while ((indice = texto.indexOf(patron, indice)) != -1) {
        posiciones.add(indice);
        indice += patron.length();
    }
    
    return posiciones;
}

Extracción de información estructurada

public Map<String, String> extraerParametrosURL(String url) {
    Map<String, String> parametros = new HashMap<>();
    
    int indiceQuery = url.indexOf('?');
    if (indiceQuery == -1) return parametros;
    
    String query = url.substring(indiceQuery + 1);
    String[] pares = query.split("&");
    
    for (String par : pares) {
        int indiceIgual = par.indexOf('=');
        if (indiceIgual != -1) {
            String clave = par.substring(0, indiceIgual);
            String valor = par.substring(indiceIgual + 1);
            parametros.put(clave, valor);
        }
    }
    
    return parametros;
}

Consideraciones de rendimiento

Al trabajar con métodos de búsqueda y comparación, se deben tener en cuenta algunas consideraciones de rendimiento:

• Los métodos indexOf() y contains() tienen una complejidad de O(n*m) donde n es la longitud de la cadena y m la longitud del patrón.
• Para búsquedas complejas o múltiples en el mismo texto, se recomienda utilizar Pattern y Matcher de la API de expresiones regulares.
• Las comparaciones con equalsIgnoreCase() son más costosas que con equals() debido a la conversión de caracteres.

// Para búsquedas repetitivas, compilar el patrón mejora el rendimiento
Pattern patron = Pattern.compile("Java", Pattern.CASE_INSENSITIVE);
Matcher matcher = patron.matcher(textoLargo);

while (matcher.find()) {
    System.out.println("Encontrado en posición: " + matcher.start());
}