Strings

Cadenas

Previamente hemos utilizado cadenas para representar mensajes en la consola, pero apenas hemos visto una parte de lo que podemos hacer con ellas. Por lo cual, en este tema veremos más a fondo el uso del tipo de dato String.

Formalmente, una cadena es una representación de una secuencia de caracteres.

Hasta el momento solo vimos una manera de crear cadenas, empleando comillas dobles ("). Sin embargo, dado que en Java String es un tipo de dato no primitivo, podemos crear cadenas empleando la palabra reservada new (al igual que con los arreglos).

String cadena = new String("Hola mundo");

En este caso, estamos creando una cadena a partir de una literal. Para esto, indicaos que el tipo de dato es String y, entre paréntesis, la cadena que deseamos crear.

En el futuro veremos que algunas operaciones que realizamos necesitarán que les pasemos ciertos datos. Este es el caso de new, quien necesita que le pasemos la cadena que deseamos crear. Los datos que requieren las operaciones se conocen como parámetros.

En la práctica, veremos que una cadena es equivalente a un arreglo de caracteres. Por lo cual, podemos crear una cadena a partir de un arreglo de caracteres.

char[] ch = {'H', 'o', 'l', 'a', ' ', 'm', 'u', 'n', 'd', 'o'};

String cadena = new String(ch);

O bien, podemos crear una cadena a partir de una literal mediante el uso de comillas dobles (").

String cadena = "Hola mundo";

Por otro lado, podemos crear una cadena vacía, es decir, una cadena que no contiene ningún caracter. Para ello, podemos emplear de nuevo new sin pasarle ningún parámetro, o bien, podemos emplear comillas dobles (") sin escribir nada entre ellas.

String cadena1 = new String();
String cadena2 = "";

En el ejemplo anterior, creamos dos cadenas vacías.

Operaciones con cadenas

Existen muchas operaciones que podemos realizar con cadenas. Para ello, debemos invocar a la operación que deseamos realizar anteponiendo el nombre de la cadena y un punto (.). Estas operaciones se conocen como métodos y, al igual que vimos al inicializar una cadena, pueden recibir parámetros.

String cadena = "Cadena de ejemplo";

cadena.<nombre del método>(<parámetros>);

A continuación, veremos algunas de las operaciones que podemos realizar con cadenas.

Concatenación

La concatenación es una operación que nos permite crear una cadena nueva a partir de la unión de dos cadenas. En Java, la concatenación se realiza mediante el operador +, encerrándolo entre las cadenas que deseamos unir.

String cadena1 = "Hola";
String cadena2 = "mundo";

String cadena3 = cadena1 + cadena2; // "Holamundo"

Por supuesto, como el resultado de la concatenación es también una cadena, podemos concatenar más de dos cadenas.

String cadena1 = "Hola";
String cadena2 = "mundo";

String cadena3 = cadena1 + " " + cadena2; // "Hola mundo"

En este caso, la concatenación se realiza de izquierda a derecha. Por lo cual, la primera concatenación que se realiza es "Hola" + " ", dando como resultado "Hola ". Posteriormente, se concatena "Hola " + "mundo", dando como resultado "Hola mundo".

Así mismo, podemos concatenar la cantidad de cadenas que deseemos.

String cadena1 = "Hola";

String cadena2 = cadena1 + " " + "mundo" + " " + "cruel" + " " + "y" + " " + "despiadado";

Longitud

La longitud de una cadena, al igual que la longitud de un arreglo, es la cantidad de elementos que contiene.

Sin embargo, a diferencia de un arreglo, la longitud de una cadena no es una propiedad de String. En su lugar, debemos invocar un método que nos permita obtener la longitud de la cadena.

Curiosamente, el método que nos permite obtener la longitud de una cadena se llama length(). Este método no recibe ningún parámetro y devuelve un entero que representa la longitud de la cadena.

public class EjemploLongitudCadena{
    public static void main(String[] args) {
        String cadena = "Hola mundo";

        System.out.println(cadena.length()); // 10
    }
}

Esto puede parecer confuso a primera vista, pero podemos pensar que length() es una operación que se ejecuta independientemente del flujo de nuestro programa y se encarga de contar la cantidad de caracteres que contiene la cadena.

Proponemos el siguiente ejemplo para ilustrar lo que sucede. Para ello emplearemos un arreglo de caracteres para representar una cadena.

public class EjemploLongitudCadena{
    public static void main(String[] args) {
        char[] ch = {'H', 'o', 'l', 'a', ' ', 'm', 'u', 'n', 'd', 'o'};

        int longitud = 0;

        for (int i = 0; i < ch.length; i++) {
            longitud++;
        }

        System.out.println(longitud); // 10
    }
}

Como vemos, a partir del arreglo de caracteres nos disponemos a contar la cantidad de caracteres que contiene empleando un ciclo for. Algo similar a lo que hace el método length() del tipo de dato String.

Al igual que con length(), podemos encontrar otros métodos que realizan alguna tarea sobre una cadena y que nos resultan útiles. No obstante, de momento, nos centraremos en lo que realiza cada operación y no en cómo lo realiza internamente.

Sólo necesitamos entender cuál es el resultado de cada operación y qué parámetros necesita para realizar su tarea.

Obtener un caracter

Cabe mencionar que, así como los arreglos, las cadenas identifican cada uno de sus elementos mediante un índice. Por lo cual, podemos acceder a cada uno de los caracteres que contiene una cadena mediante su índice.

Sin embargo, no podemos emplear la misma sintaxis que utilizamos con los arreglos. En su lugar, debemos emplear el método charAt().

Este método recibe como parámetro un número entero que representa la posición del caracter que deseamos obtener.

public class EjemploObtenerCaracter{
    public static void main(String[] args) {
        String cadena = "Hola mundo";

        System.out.println(cadena.charAt(0)); // 'H'
        System.out.println(cadena.charAt(1)); // 'o'
        System.out.println(cadena.charAt(2)); // 'l'
        System.out.println(cadena.charAt(3)); // 'a'
        System.out.println(cadena.charAt(4)); // ' '
        System.out.println(cadena.charAt(5)); // 'm'
        System.out.println(cadena.charAt(6)); // 'u'
        System.out.println(cadena.charAt(7)); // 'n'
        System.out.println(cadena.charAt(8)); // 'd'
        System.out.println(cadena.charAt(9)); // 'o'
    }
}

Como vemos, podemos obtener cada uno de los caracteres que contiene la cadena mediante su índice. En este caso, el índice de la cadena cadena va desde 0 hasta 9.

Anticipamos que, al igual que con los arreglos, si intentamos obtener un caracter mediante un índice que no existe, obtendremos un error.

Obtener una subcadena

Una subcadena es una cadena que se obtiene a partir de una cadena más grande.

Para ello, empleamos el método substring(). En este método debemos indicar el índice del caracter con el que deseamos iniciar la subcadena y el índice del caracter con el que deseamos terminar la subcadena.

public class EjemploSubcadena{
    public static void main(String[] args) {
        String cadena = "Hola mundo";

        System.out.println(cadena.substring(0, 4)); // "Hola"
        System.out.println(cadena.substring(5, 10)); // "mundo"
    }
}

En base al ejemplo anterior, podemos establecer que:

• El primer parámetro de substring() indica el índice del caracter con el que deseamos iniciar la subcadena. Además, este caracter se incluye en la subcadena.
• El segundo parámetro de substring() indica el índice del caracter con el que deseamos terminar la subcadena. Sin embargo, este caracter no se incluye en la subcadena.

Cabe destacar que, podemos omitir el segundo parámetro de substring() y, en este caso, la subcadena se creará a partir del caracter indicado en el primer parámetro hasta el final de la cadena.

public class EjemploSubcadena{
    public static void main(String[] args) {
        String cadena = "Hola mundo";

        System.out.println(cadena.substring(0)); // "Hola mundo"
        System.out.println(cadena.substring(5)); // "mundo"
    }
}

Comparar cadenas

Si bien podríamos inferir que, para comparar dos cadenas, podemos emplear el operador ==, esto nos llevaría a cometer un error.

Los operadores relacionales (==, !=, <, >, <=, >=) nos permiten comparar dos valores y obtener un resultado de tipo boolean. Sin embargo, esto sólo es posible con los tipos de datos primitivos, mientras que String no lo es. Por dicho motivo existen métodos que nos permiten comparar cadenas.

En este caso, emplearemos el método compareTo(), el cual recibe como parámetro la cadena con la que deseamos comparar lexográficamente.

<cadena1>.compareTo(<cadena2>);

Este método devuelve un número entero que representa el resultado de la comparación.

• Si el resultado es menor a 0, entonces la cadena cadena1 es lexográficamente menor a la cadena cadena2.
• Si el resultado es igual a 0, entonces la cadena cadena1 es lexográficamente idéntica a la cadena segunda cadena.
• Si el resultado es mayor a 0, entonces la cadena cadena1 es lexográficamente mayor a la cadena cadena2.

public class EjemploCompararCadenas{
    public static void main(String[] args) {
        String cadena1 = "Ana";
        String cadena2 = "Beto";
        String cadena3 = "Zoe";

        System.out.println(cadena1.compareTo(cadena2)); // -1
        System.out.println(cadena1.compareTo(cadena3)); // -24
        System.out.println(cadena2.compareTo(cadena1)); // 1
        System.out.println(cadena2.compareTo(cadena3)); // -22
        System.out.println(cadena3.compareTo(cadena1)); // 24
        System.out.println(cadena3.compareTo(cadena2)); // 22
    }
}

Entonces, si deseamos establecer algún tipo de orden entre cadenas, podemos emplear el método compareTo().

Convertir a mayúsculas o minúsculas

Para convertir una cadena a mayúsculas o minúsculas, podemos emplear los métodos toUpperCase() y toLowerCase(), respectivamente.

public class EjemploMayusculasMinusculas{
    public static void main(String[] args) {
        String cadena = "Hola mundo";

        System.out.println(cadena.toUpperCase()); // "HOLA MUNDO"
        System.out.println(cadena.toLowerCase()); // "hola mundo"
    }
}

En caso de que la cadena contenga caracteres que no se puedan convertir a mayúsculas o minúsculas, estos caracteres se conservarán.

public class EjemploMayusculasMinusculas{
    public static void main(String[] args) {
        String cadena = "Hola mundo 123";

        System.out.println(cadena.toUpperCase()); // "HOLA MUNDO 123"
        System.out.println(cadena.toLowerCase()); // "hola mundo 123"
    }
}

Eliminar espacios en blanco

Algunas cadenas pueden tener espacios en blanco al inicio o al final, los cuales pueden ser un problema si la cadena representa un dato relevante, como el nombre de una persona, el email de un usuario, su contraseña, etc.

Para resolver este problema, podemos emplear el método trim(), el cual elimina los espacios en blanco al inicio y al final de la cadena.

public class EjemploEliminarEspacios{
    public static void main(String[] args) {
        String cadena = "   Hola mundo   ";

        System.out.println(cadena.trim()); // "Hola mundo"
    }
}

Reemplazar caracteres

Así también, podemos necesitar modificar una cadena reemplazando ciertos caracteres por otros. Para ello, podemos emplear el método replace(), el cual recibe como parámetros el caracter que deseamos reemplazar y el caracter por el que deseamos reemplazarlo.

public class EjemploReemplazarCaracteres{
    public static void main(String[] args) {
        String cadena = "Hola mundo";

        System.out.println(cadena.replace('o', 'x')); // "Hxla mundx"
    }
}

Podemos notar que el método replace() no modifica la cadena original, sino que devuelve una nueva cadena con los cambios realizados.

Buscar subcadenas

Por otro lado, podemos necesitar saber si una cadena contiene una subcadena en particular. Para ello, podemos emplear el método indexOf(), el cual recibe como parámetro la subcadena que deseamos buscar y devuelve un número entero que representa el índice del caracter con el que inicia la subcadena.

public class EjemploBuscarSubcadenas{
    public static void main(String[] args) {
        String cadena = "Pablito clavó un clavito en la calva de un calvito. ¿Qué clavito clavó Pablito?";

        System.out.println(cadena.indexOf("clavito")); // 17
        System.out.println(cadena.indexOf("Pedrito")); // -1
    }
}

Es importante mencionar que, si la subcadena se repite en la cadena, el método indexOf() nos devuelve el índice de la primera aparición de la subcadena. Además, si la subcadena no se encuentra en la cadena, el método indexOf() nos devuelve -1.

Extraer subcadenas

Finalmente, podemos necesitar extraer una subcadena de una cadena. Para ello, podemos emplear el método split(), el cual recibe como parámetro una expresión que nos indica el criterio que se empleará para separar la cadena y como resultado obtenemos un arreglo de cadenas.

Por ejemplo, podríamos desear extraer cada palabra de oración, la cual almacenamos en una cadena. Para ello, podemos emplear un espacio en blanco como criterio de separación.

public class EjemploExtraerSubcadenas{
    public static void main(String[] args) {
        String cadena = "Pablito clavó un clavito en la calva de un calvito. ¿Qué clavito clavó Pablito?";

        String[] palabras = cadena.split(" ");

        for (int i = 0; i < palabras.length; i++) {
            System.out.println(palabras[i]);
        }
    }
}

En este caso, asignamos al arreglo palabras el resultado de invocar al método split() sobre una cadena. Como resultado tendremos un arreglo con 14 cadenas, cada una de ellas representa una palabra de la oración.