En PC Resumen vamos a hablar de la clase String, de sus constructores, de los métodos y de sus utilidades en Java.

Constructores de String

La clase String proporciona constructores para inicializar los objetos de varias formas. Cuatro de los constructores los veremos en el siguiente programa:

public class ConstructoresString {

    public static void main(String args[]) {
        char arrayChar[] = {'b', 'u', 'e', 'n', ' ', 'a', 'n', 'i', 'v', 'e', 'r', 's', 'a', 'r', 'i', 'o'};
        String s = new String("hola");
        String s1 = new String();
        String s2 = new String(s);
        String s3 = new String(arrayChar);
        String s4 = new String(arrayChar, 5, 15);
        System.out.printf("s1 = %s \n s2 = %s \n s3 = %s \n s4 = %s \n",s1, s2, s3, s4);
    }
}

Si ejecutamos obtendremos el siguiente resultado:

s1 =
s2 = hola
s3 = buen aniversario
s4 = aniversario

Métodes length, charAt y getChars

Estos métodos determinan la longitud de la cadena, obtienen el carácter que se encuentra en una posición específica de una cadena y recuperan el conjunto completo de caracteres de una cadena, respectivamente. El programa siguiente muestra cada uno de estos métodos:

public class VariosString {

    public static void main(String args[]) {
        String s1 = "hola a todos";
        char arrayChar[] = new char[4];
        System.out.printf("s1: %s", s1);
        System.out.printf("\nLongitud de s1: %d", s1.length());
        System.out.print("\nLa cadena invertida es: ");
        for (int i = s1.length() - 1; i >= 0; i--) {
            System.out.printf("%s ", s1.charAt(i));
        }
        s1.getChars(0, 4, arrayChar, 0);
        System.out.print("\nLa cadena de carácteres es: ");
        for (char caracter : arrayChar) {
            System.out.print(caracter);
        }
        System.out.println();
    }
}

En primer lugar con el método length determinamos el número de caracteres de la cadena.

Después imprimimos los caracteres de la cadena en orden inverso y separados por espacios. El método chatAt devuelve el carácter ubicado en una posición específica de la cadena, recibiendo como argumento un entero que se utiliza como índice.

Finalmente utilizamos el método getChars para copiar los caracteres de una cadena en una tabla de caracteres. El primer argumento es el índice inicial de la cadena a partir de la cual se copiarán los caracteres. El segundo argumento es el índice que está en una posición más adelante del último carácter que se copiará. El tercero es la mesa donde se copiarán y el último es el índice inicial donde se colocarán los caracteres copiados.

Comparación de cadenas

Todos los caracteres se representan en el ordenador como códigos numéricos. Cuando el ordenador compara cadenas, en realidad compara los códigos numéricos de los caracteres de las cadenas. El código siguiente muestra los métodos equals, equalsIgnoreCase, compareTo y regionMatches de la clase String y muestra el uso del operador == para comparar objetos String.

public class CompararCadenas {

    public static void main(String args[]) {
        String s1 = new String("hola");
        String s2 = "adios";
        String s3 = "Buen aniversario";
        String s4 = "buen aniversario";
        System.out.printf("s1 = %s\ns2 = %s\ns3 = %s\ns4 = %s\n\n", s1, s2, s3, s4);
        if (s1.equals("hola")) {
            System.out.println("s1 es igual a \"hola\"");
        } else {
            System.out.println("s1 no es igual a \"hola\"");
        }
        if (s1 == "hola") {
            System.out.println("s1 es el mismo objeto que \"hola\"");
        } else {
            System.out.println("s1 no es el mismo objeto que \"hola\"");
        }
        if (s3.equalsIgnoreCase(s4)) {
            System.out.printf("%s es igual a %s si ignora el uso de mayúsculas/minúsculas\n", s3, s4);
        } else {
            System.out.println("s3 no és igual a s4");
        }
        System.out.printf("\ns1.compareTo(s2) es %d", s1.compareTo(s2));
        System.out.printf("\ns2.compareTo(s1) es %d", s2.compareTo(s1));
        System.out.printf("\ns1.compareTo(s1) es %d", s1.compareTo(s1));
        System.out.printf("\ns3.compareTo(s4) es %d", s3.compareTo(s4));
        System.out.printf("\ns4.compareTo(s3) és %d\n\n", s4.compareTo(s3));
        if (s3.regionMatches(0, s4, 0, 5)) {
            System.out.println("Los primeros 5 carácteres de s3 y s4 coinciden");
        } else {
            System.out.println("Los primeros 5 carácteres de s3 y s4 no coinciden");
        }
        if (s3.regionMatches(true, 0, s4, 0, 5)) {
            System.out.println("Los primeros 5 carácteres de s3 y s4 coinciden");
        } else {
            System.out.println("Los primeros 5 carácteres de s3 y s4 no coinciden");
        }
    }
}

Si ejecutamos el resultado será:

s1 = hola
s2 = adios
s3 = Buen aniversario
s4 = buen aniversario

s1 es igual a "hola"
s1 no es el mismo objeto que "hola"
Buen aniversario es igual a buen aniversario si ignora el uso de mayúsculas/minúsculas

s1.compareTo(s2) es 7
s2.compareTo(s1) es -7
s1.compareTo(s1) es 0
s3.compareTo(s4) es -32
s4.compareTo(s3) és 32

Los primeros 5 carácteres de s3 y s4 no coinciden
Los primeros 5 carácteres de s3 y s4 coinciden

En primer lugar utilizamos el método equals para comparar la igualdad entre s1 y el literal de cadena "hola". Este método prueba que el contenido de las dos cadenas sea idéntico. Hay que ver que la comparación es entre códigos numéricos y por tanto no es lo mismo "hola" que "HOLA".

Después utilizamos el operador de igualdad ==. Este operador tiene diferente funcionalidad cuando se trata de comparar referencias que cuando se utiliza para comparar valores primitivos. Cuando se comparan referencias, el resultado es cierto si las dos referencias se refieren al mismo objeto en memoria. Por lo tanto en este caso nos dará valor falso.

Curiosamente si s1 hubiera inicializado con la instrucción:

s1= “hola”;

La condición hubiera sido cierta.

Java trata a todos los literales de cadena con el mismo contenido como un solo objeto String que tiene muchas referencias. Esto ayuda a ahorrar memoria.

Cuando se comparan referencias con == se pueden producir errores lógicos, ya que == compara las referencias para determinar si se refieren al mismo objeto, no si dos objetos tienen el mismo contenido. Si se comparan dos objetos idénticos (pero separados) con == el resultado será falso. Si se han de comparar objetos para determinar si tienen el mismo contenido hay que utilizar el método equals.

Si hemos de ordenar objetos String se pueden comparar si son iguales con el método equalsIgnoreCase, el cual ignora si las letras son mayúsculas o minúsculas.

El método comparó tiene el mismo funcionamiento que la función strcmp de C.

Finalmente utilizamos el método regionMatches para comparar si ciertas partes de dos cadenas son iguales. El primer argumento es el índice inicial en la cadena que invoca al método. El segundo es la cadena de comparación. El tercero es el índice inicial en la cadena de comparación y el último es el número de caracteres a comparar.

Este método también tiene una versión con cinco argumentos: cuando el primer argumento es true el método ignora el uso de mayúsculas y minúsculas.

En el siguiente ejemplo mostrará los métodos startsWith y endsWith

public class CadenaInicioFinal {

    public static void main(String args[]) {
        String cadenas[] = {"empieza", "empezando", "termina", "terminando"};
        for (String cadena : cadenas) {
            if (cadena.startsWith("em")) {
                System.out.printf("\"%s\" empieza con \"em\"\n", cadena);
            }
        }
        System.out.println();
        for (String cadena : cadenas) {
            if (cadena.startsWith("iez", 3)) {
                System.out.printf(
                        "\"%s\" empieza con \"iez\" a la posición 3\n", cadena);
            }
        }
        System.out.println();
        for (String cadena : cadenas) {
            if (cadena.endsWith("do")) {
                System.out.printf("\"%s\" termina con \"do\"\n", cadena);
            }
        }
    }
}

Si lo ejecutamos el resultado será:

"empieza" empieza con "em"
"empezando" empieza con "em"

"empieza" empieza con "iez" a la posición 3

"empezando" termina con "do"
"terminando" termina con "do"

La versión más simple del método startsWith sólo recibe un parámetro y nos indica si el objeto String comienza con los caracteres indicados. La versión con dos parámetros recibe un entero que especifica el índice a partir de donde debe comenzar la comparación.

El método endsWith sólo tiene una versión y determina si el objeto String acaba con los caracteres indicados.

Localización de cadenas y subcadenas

A veces es útil buscar un carácter o un conjunto de caracteres en una cadena. En el programa siguiente se muestran las diversas versiones de los métodos indexOf y lastIndexOf de la clase String los que buscan un carácter o una subcadena especificados dentro de una cadena.

public class MetodosIndexString {

    public static void main(String args[]) {
        String letras = "abcdefghijklmabcdefghijklm";
        System.out.printf("'c' se encuentra al índice %d\n", letras.indexOf('c'));
        System.out.printf("'a' se encuentra al índice %d\n", letras.indexOf('a', 1));
        System.out.printf("'$' se encuentra al índice %d\n\n", letras.indexOf('$'));
        System.out.printf("La última 'c' se encuentra al índice %d\n", letras.lastIndexOf('c'));
        System.out.printf("La última 'a' se encuentra al índice %d\n", letras.lastIndexOf('a', 25));
        System.out.printf("La última '$' se encuentra al índice %d\n\n", letras.lastIndexOf('$'));
        System.out.printf("\"def\"  se encuentra al índice %d\n", letras.indexOf("def"));
        System.out.printf("\"def\" se encuentra al índice %d\n", letras.indexOf("def", 7));
        System.out.printf("\"hola\" se encuentra al índice %d\n\n", letras.indexOf("hola"));
        System.out.printf("La última ocurrencia de \"def\" se encuentra al índice %d\n", letras.lastIndexOf("def"));
        System.out.printf("La última ocurrencia de \"def\" se encuentra al índice %d\n", letras.lastIndexOf("def", 25));
        System.out.printf("La última ocurrencia de \"hola\" se encuentra al índice %d\n", letras.lastIndexOf("hola"));
    }
}

Si lo ejecutamos el resultado será:

La última 'c' se encuentra al índice 15
La última 'a' se encuentra al índice 13
La última '$' se encuentra al índice -1

"def"  se encuentra al índice 3
"def" se encuentra al índice 16
"hola" se encuentra al índice -1

La última ocurrencia de "def" se encuentra al índice 16
La última ocurrencia de "def" se encuentra al índice 16
La última ocurrencia de "hola" se encuentra al índice -1

En primer lugar utilizamos el método indexOf para localizar la primera ocurrencia de un carácter dentro de una cadena. Si encuentra el carácter, devuelve el índice de este carácter, de lo contrario devuelve -1. Hay dos versiones del método para buscar un carácter. La primera sólo recibe el carácter buscar, en la segunda además se le pasa el índice inicial a partir del cual comenzará a buscar.

Después utilizamos el método lastIndexOf para localizar la última ocurrencia de un carácter en una cadena. Este método hace la búsqueda desde el final de la cadena. Si lo encuentra devuelve el índice y sino devuelve -1. Este método también tiene una versión con dos parámetros para indicarle el índice a partir del cual hará la búsqueda inversa.

Finalmente vemos las versiones de los métodos indexOf y lastIndexOf que reciben cada una, un objeto String como primer argumento. Estas versiones de los métodos se ejecutan de forma idéntica a las anteriores, excepto que buscan subcadenas.

Extracción de subcadenas

La clase String proporciona dos métodos substring para permitir la creación de un nuevo objeto String copiando una parte de un String existente. Cada método devuelve un nuevo objeto String. Estos métodos se muestran en el código siguiente.

public class SubString {

    public static void main(String args[]) {
        String letras = "abcdefghijklmabcdefghijklm";
        System.out.printf("La subcadena desde el índice 20 hasta el final es \"%s\"\n", letras.substring(20));
        System.out.printf("%s \"%s\"\n", "La subcadena desde el índice 3 hasta, pero sin incluir el 6 es", letras.substring(3, 6));
    }
}

Si lo ejecutamos el resultado será:

La subcadena desde el índice 20 hasta el final es "hijklm"
La subcadena desde el índice 3 hasta, pero sin incluir el 6 es "def"

La expresión letras.substring(20) utiliza el método que recibe un argumento entero. Este argumento especifica el índice inicial a partir del cual se copian los caracteres. La subcadena devuelta contiene una copia de los caracteres desde el índice inicial hasta el final de la cadena. En la versión que acepta dos argumentos, el segundo especifica el índice que está una posición más allá del último carácter a copiar.

Concatenación de cadenas

Para concatenar cadenas se utiliza el método concat. Este método concatena dos objetos String y devuelve un nuevo objeto String que contiene los caracteres de los dos objetos originales. La expresión s1.concat (s2) forma una cadena, anexando los carácter de la cadena s2 los caracteres de la cadena s1. Los objetos originales no son modificados.

Diversos métodos

La clase String proporciona varios métodos que devuelven copias modificadas de cadenas o que devuelven tablas de caracteres. Estos métodos se muestran en el siguiente programa.

public class VariosStrings {

    public static void main(String args[]) {
        String s1 = new String("hola");
        String s2 = new String("ADIOS");
        String s3 = new String(" espacios ");
        System.out.printf("s1 = %s\ns2 = %s\ns3 = %s\n\n", s1, s2, s3);
        System.out.printf("Remplazar 'l' con 'L' a s1: %s\n\n", s1.replace('l', 'L'));
        System.out.printf("s1.toUpperCase() = %s\n", s1.toUpperCase());
        System.out.printf("s2.toLowerCase() = %s\n\n", s2.toLowerCase());
        System.out.printf("s3 después de trim = \"%s\"\n\n", s3.trim());
        char arregloChar[] = s1.toCharArray();
        System.out.print("s1 como a tabla de carácteres = ");
        for (char caracter : arregloChar) {
            System.out.print(caracter);
        }
        System.out.println();
    }
}

Si lo ejecutamos el resultado será:

s1 = hola
s2 = ADIOS
s3 =  espacios 

Remplazar 'l' con 'L' a s1: hoLa

s1.toUpperCase() = HOLA
s2.toLowerCase() = adios

s3 después de trim = "espacios"

s1 como a tabla de carácteres = hola

En primer lugar utilizamos el método replace para devolver un nuevo objeto en el que cada ocurrencia del primer carácter es reemplaza por el segundo carácter. Si no hay ocurrencias del primer argumento, el método devuelve la cadena original.

Después utilizamos los métodos toUpperCase y toLowerCase para crear dos objetos con mayúsculas y en minúsculas.

Después utilizamos el método trim el cual elimina todos los espacios en blanco que haya al principio o al final de la cadena. La cadena original no se cambia.

Finalmente se utiliza el método toCharArray para crear una nueva tabla de caracteres que contiene una copia de los caracteres de la cadena.

El método valueOf

Como sabéis, todo objeto Java tiene un método toString que permite a un programa obtener la representación de cadena del objeto. Desgraciadamente, esta técnica no puede utilizarse con tipos primitivos, ya que éstos no tienen métodos. La clase String proporciona métodos estáticos que reciben un argumento de cualquier tipo y lo convierten en un objeto String. En el programa siguiente se muestra el uso de estos métodos.

public class StringValueOf {

    public static void main(String args[]) {
        char tablaChar[] = {'a', 'b', 'c', 'd', 'e', 'f'};
        boolean valorBoolean = true;
        char valorCaracter = 'Z';
        int valorEnter = 7;
        long valorLong = 10000000000L; //L indica long
        float valorFloat = 2.5f; // f indica que 2.5 es un float
        double valorDouble = 33.333;
        Object refObjecte = "hola"; // asigna la cadena a una referencia Object
        System.out.printf("tabla de valores char = %s\n", String.valueOf(tablaChar));
        System.out.printf("parte de la tabla char = %s\n", String.valueOf(tablaChar, 3, 3));
        System.out.printf("boolean = %s\n", String.valueOf(valorBoolean));
        System.out.printf("char = %s\n", String.valueOf(valorCaracter));
        System.out.printf("int = %s\n", String.valueOf(valorEnter));
        System.out.printf("long = %s\n", String.valueOf(valorLong));
        System.out.printf("float = %s\n", String.valueOf(valorFloat));
        System.out.printf("double = %s\n", String.valueOf(valorDouble));
        System.out.printf("Object = %s\n", String.valueOf(refObjecte));
    }
}

En la declaración de variables se utilizan los valores literales 10000000000L y 2.5f como valores iniciales de las variables. De forma predeterminada, Java trata los literales enteros como tipo int y los literales en coma flotante como tipo double. Si se anexa la letra L indica el compilador que debe tratarse como long y si se anexa f indica que debe tratarse como float. En cualquiera de los casos la letra puede estar en mayúsculas o en minúsculas.

Pin It