Operaciones comunes con cadenas en Java

Introducción

En pocas palabras, a Stringse utiliza para almacenar texto, es decir, una secuencia de caracteres. La clase más utilizada de Java es la Stringclase, sin duda, y con un uso tan elevado, es obligatorio que los desarrolladores de Java estén familiarizados a fondo con la clase y sus operaciones comunes.

String

Hay mucho que decir sobre los Strings, desde las formas en que puede inicializarlos en el String Literal Pool, sin embargo, en este artículo nos centraremos en operaciones comunes, en lugar de la clase en sí.

Aunque, si desea leer más sobre varias formas de crear cadenas en Java, debe consultar String vs StringBuilder vs StringBuffer.

Aquí, asumimos que está familiarizado con el hecho de que Stringlos correos electrónicos son inmutables, ya que es muy importante saberlo antes de manipularlos. Si no es así, consulte el artículo vinculado anteriormente donde se explica en detalle.

La Stringclase viene con muchos métodos auxiliares que nos ayudan a procesar nuestros datos textuales:

• Determinar la longitud de la String
• Encontrar personajes y subcadenas
• Comparación de cadenas
• Extraer subcadenas
• Cambio de caja de Strings
• Eliminar espacios en blanco
• Formateo de cadenas
• Regex y comprobación de subcadenas
• Reemplazo de caracteres y subcadenas
• División y unión de cadenas
• Crear matrices de caracteres
• Igualdad de Strings

Concatenación de cadenas

Antes de comenzar a usar cualquiera de estos métodos en cadenas, deberíamos echar un vistazo a la concatenación de cadenas, ya que es algo bastante común. Empecemos por el +operador. La Stringclase sobrecarga ese operador y se usa para concatenar dos cadenas:

String aplusb = "a" + "b";

// The operands can be String object reference variables as well
String a = "a";
String b = "b";
aplusb = a + b;

El +operador es muy lento. Stringlos objetos son inmutables, por lo que cada vez que deseamos concatenar n cadenas, Java tiene que copiar los caracteres de todas las cadenas en un nuevo Stringobjeto. Esto nos da una complejidad cuadrática (O (n ^ 2)).

Esto no es un problema con cadenas pequeñas, o cuando estamos concatenando solo varias cadenas al mismo tiempo ( String abcd = "a" + "b" + "c" + "d";). Java se utiliza automáticamente StringBuilderpara concatenar varias cadenas a la vez, por lo que la fuente de la pérdida de rendimiento es la concatenación en bucles. Por lo general, para algo así, usamos la StringBuilderclase antes mencionada .

Funciona como un Stringobjeto mutable . Omite todas las copias en la concatenación de cadenas y nos da una complejidad lineal (O (n)).

int n = 1000;

// Not a good idea! Gives the right result, but performs poorly.
String result = "";
for (int i = 0; i < n; i++) {
    result += Integer.valueOf(i);
}

// Better, performance-friendly version.
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < n; i++) {
    sb.append(i);
}

También podemos concatenar usando el concat()método:

String str1 = "Hello";
System.out.println(str1.concat("World"));

Salida:

Hello World

Nota : Cuando se usa la concatenación de cadenas con otros tipos de datos, implícitamente se convierten a su representación de cadena:

System.out.println("2 = " + 2); 

Esto da la salida esperada “2 = 2”.

System.out.println("2 = " + 1 + 1);

En circunstancias normales, 1+1se evaluaría primero ya que Java se ocupa de las operaciones de derecha a izquierda. Sin embargo, esta vez no será así: la salida es “2 = 11”. Esto se debe a algo llamado “precedencia de operadores”.

Básicamente, cuando se encuentran dos o más operadores “+” (sin otros operadores presentes, ni paréntesis), Java comenzará con el operador “+” más a la izquierda y continuará desde allí. Si quisiéramos que la salida fuera “2 = 2” nuevamente, necesitaríamos agregar paréntesis en el lugar apropiado.

System.out.println("2 = " + (1 + 1));

Por otro lado, si intentamos utilizar el concat()método con un tipo de datos diferente:

String str1 = "Hello";
System.out.println(str1.concat(53));

Seríamos recibidos con una excepción:

incompatible types: int cannot be converted to String

Cuando se usa el +operando, Java convierte automáticamente el tipo de datos en una Cadena, mientras que cuando se usa el método concat(), no lo hace.

Por cierto, con todos los métodos que exploraremos en este artículo, no necesitamos proporcionar una variable de referencia, a veces, por brevedad, es más fácil simplemente usarlos en un literal:

// Instead of this...
String ourString = "this is just some string";
System.out.println(ourString.substring(5,10));

// ...we can do this:
System.out.println("this is just some string".substring(5,10));

Realmente, de cualquier manera está bien, pero la segunda forma produce menos código.

Determinar la longitud de la String

length()devuelve el número total de caracteres en nuestro String.

isEmpty()devuelve trueo falsedependiendo de si nuestro Stringestá vacío o no. Entonces esto significa que isEmpty()regresa truepara el mismo caso que length()devuelve 0.

Por ejemplo:

if (s.length() == 0) // or s.isEmpty() {
    System.out.println("s is empty");
}
else System.out.println("s isn't empty, it's: " + s + "n");

Aquí mostramos cómo puede usar estos métodos para verificar si hay una cadena vacía. La verificación condicional también podría reemplazarse por s.isEmpty()y funcionaría de la misma manera.

Encontrar personajes y subcadenas

Dado que a Stringes una secuencia inmutable de caracteres, podemos preguntar qué personaje está en qué posición o encontrar la posición de un personaje. La indexación de a Stringcomienza en 0, como estamos acostumbrados con las matrices.

charAt(int index) devuelve el valor del carácter en un índice dado.

indexOf() está sobrecargado y, por lo tanto, tiene múltiples usos:

• indexOf(int ch) devuelve la primera posición de índice que coincide con el valor de carácter dado
• indexOf(int ch, int fromIndex) devuelve el primer índice que coincide con el valor de carácter dado DESPUÉS fromIndex
• indexOf(String substring)devuelve la (primera) posición inicial substringdel Stringobjeto en el que se llamó
• indexOf(String substring, int fromIndex)igual que el método anterior, pero la búsqueda comienza en en fromIndexlugar de 0

Todos los indexOf()métodos sobrecargados devuelven -1 si no se encontró el índice.

lastIndexOf()también está sobrecargado y tiene firmas de métodos equivalentes a indexOf(), y también devuelve -1 si no se encontró un índice apropiado. Busca el Stringobjeto hacia atrás a menos que fromIndexse especifique a.

El índice pasado al método debe estar dentro del rango [0, example.length() - 1]para ser válido. De lo contrario, StringIndexOutOfBoundsExceptionse lanza a.

String example = "This should be complicated enough to show some things we should show";

// Find the characters at the indexes given
System.out.println(example.charAt(0));
System.out.println(example.charAt(5));

// An StringIndexOutOfBoundsException is thrown in both these cases:
// System.out.println(example.charAt(-1));
// System.out.println(example.charAt(200));

// Find the index of characters or substrings
System.out.println(example.indexOf('s')); // returns the first occurence of 's'
System.out.println(example.indexOf('s', 4)); // the first 's' after index 4
System.out.println(example.indexOf("should")); // the index of the first "should" in our string
System.out.println(example.indexOf("should", 15)); // the index of the first "should" in our
                                                   // string _after_ index 15

// Find the last index of characters or substrings
System.out.println(example.lastIndexOf('s')); // returns the first occurence of 's' when we look backwards from the end of the string
System.out.println(example.lastIndexOf('s', 45)); // searches for 's' backwards from the position 45
System.out.println(example.lastIndexOf("should")); // returns the position at which the substring 'should' appears, looking backwards from the end of the string
System.out.println(example.lastIndexOf("should", 20)); // finds substring 'should' from position 20 backwards, and returns the position at which it begins

Esto generará lo siguiente:

T
s
3
5
5
57
64
42
57
5

Nota : indexOf(int ch, int fromIndex)se usa a menudo en bucles, cuando queremos hacer algo por cada aparición de un carácter en un String.

int foundAt = -1;
String example = "This should be complicated enough to show some things we should show";
while (true) {
    foundAt = example.indexOf('s', foundAt + 1);
    if (foundAt == -1)
        break;
    else {
        // do something with that information
    }
}

Comparación de cadenas

El compareTo()método compara lexicográficamente nuestro Stringcon otro. La comparación real de las dos cadenas se basa en el valor Unicode de cada carácter de la cadena. El método devuelve un número positivo, un número negativo o 0.

Si todos los caracteres de nuestra cadena fueran minúsculas (o mayúsculas), el valor de retorno del compareTo()método se puede interpretar como “si el valor de retorno fuera negativo, mi cadena vendría antes que la otra cadena en un diccionario”.

Enfatizo el punto de que las letras deberían estar en el mismo caso, ya que la función podría producir una salida inesperada de lo contrario.

El compareTo()método no pasa por todos los caracteres en nuestras cadenas, regresa tan pronto como llega al final de cualquiera de las cadenas, o tan pronto como encuentra un carácter que no coincide. En cuyo caso, la función devuelve (valor Unicode del carácter no coincidente en nuestra cadena) – (valor Unicode del carácter no coincidente en la cadena dada).

Para cualquiera que tenga curiosidad, ASCII es parte de Unicode. Lo que significa que az y AZ están en el mismo orden que en la codificación ASCII, es decir, están todos uno tras otro en sus respectivos casos. Es decir, az son códigos entre 97-122 y AZ es 65-90. Entonces, el valor de ‘a’ es 97, el valor de ‘b’ es 98 y así sucesivamente. De esta manera, cuando restamos el valor Unicode de ‘b’ de ‘a’, obtenemos -1. Lo que significa que ‘a’ es una letra antes de ‘b’, que es.

System.out.println("a".compareTo("a"));
System.out.println("a".compareTo("b"));
System.out.println("1".compareTo("12345678"));
System.out.println("2".compareTo("12345678"));
System.out.println("abcd".compareTo("abgggggggggg"));

0
-1
-7
1
-4

En la tercera línea del código anterior, en este caso, compareTodevuelve la diferencia en las longitudes de las cadenas, ya que no encontró un carácter no coincidente antes de “quedarse sin” caracteres en una cadena.

Y en la última línea vemos que se imprime -4 debido a 'c' - 'g', ya que esa es la primera falta de coincidencia que encontró, y no le importa el resto.

Nota : La parte “inesperada” al usar compareTo()ocurre cuando comparamos cadenas con diferentes casos.

System.out.println("ORANGE".compareTo("apple")); 

Podríamos esperar que el método devuelva un valor positivo, ya que “manzana” debe ir antes que “NARANJA”. Sin embargo, el valor Unicode de ‘O’ es menor que el valor Unicode de ‘a’.

A veces, este puede ser el comportamiento preferido, pero en caso de que no lo sea, usamos compareToIgnoreCase(). Ese método hace esencialmente lo mismo que compareTo(), simplemente pretende que todo está en el mismo caso, y nos da un orden de diccionario “adecuado”.

Nota : compareTo()y compareToIgnoreCase()se utilizan a menudo cuando creamos Comparatoruna clase personalizada.

Por ejemplo, digamos que tenemos un Personobjeto como el siguiente:

class Person {
    String firstName;
    String lastName;
    // ...
}

Ahora digamos que tenemos un ArrayList“pueblo” llamado de muchos Personobjetos, sin ningún orden en particular. Nos gustaría ordenar eso ArrayListpara que estén ordenados en orden lexicográfico según su apellido, y si las personas tienen el mismo apellido, nos gustaría ordenarlos según su nombre.

Comparator<Person> personComparator = new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        if (p1.firstName.compareTo(p2.firstName) != 0) {
            return p1.firstName.compareTo(p2.firstName);
        }
        else return p1.lastName.compareTo(p2.lastName);
    }
};
Collections.sort(people, personComparator);

Extraer subcadenas

Una “subcadena” es un subconjunto de (o parte de) otra cadena. El substring()método devuelve una nueva cadena que es una subcadena de la cadena en la que usamos el método.

En otras palabras, si quisiéramos una nueva cadena que contenga los primeros tres caracteres de nuestra cadena, usaríamos ourString.substring(0, 3).

El substring()método tiene dos variaciones:

• substring(int startIndex)devuelve un que Stringcontiene todos los caracteres desde startIndex(inclusive) hasta el final de nuestro String. Se comporta igual que substring(int startIndex, ourString.length()).
• substring(int startIndex, int endIndex)devuelve un que Stringcontiene todos los caracteres de startIndex(inclusive) a endIndex(exclusivo, es decir, el carácter en endIndexno se devuelve)

Nota : Los índices dados aún deben estar en el intervalo [0, ourString.length()-1]. Java, a diferencia de otros lenguajes, NO admite índices negativos en el substring()método. Java lanzará un StringIndexOutOfBoundsExceptionpor cualquiera de las siguientes razones:

• startIndex es negativo
• endIndexes mayor que la longitud de nuestro Stringobjeto
• startIndex Es mas grande que endIndex

Aunque la documentación no dice explícitamente que “no se permiten valores negativos en absoluto” (uno podría tener el hábito de dar -1 como el endIndexde otros lenguajes de programación), esa regla puede derivarse de ese hecho que startIndexno puede ser negativo , y endIndextiene que ser mayor que startIndex.

Sin embargo, Java simplemente nos hace dar el paso adicional de escribir ourString.length() - someNumbercomo en endIndexlugar de simplemente - someNumber.

String ourString = "abcdef";
System.out.println(ourString.substring(0,3));
System.out.println(ourString.substring(2));
System.out.println(ourString.substring(1,3));

// If we want the last few characters
System.out.println(ourString.substring(ourString.length()-3));

abc
cdef
bc
def

Cambio de caja de Strings

Estos dos métodos simples se utilizan para cambiar el caso de los caracteres dentro de una cadena.

• toLowerCase(): cambia todos los caracteres en mayúsculas a minúsculas (ignora todo lo demás)
• toUpperCase(): cambia todos los caracteres en minúsculas a mayúsculas (ignora todo lo demás)

String ourString = "ThInK oF a ClEvEr StRiNg";

System.out.println(ourString.toLowerCase());
System.out.println(ourString.toUpperCase());
System.out.println(ourString);

Esto dará como resultado lo siguiente:

think of a clever string
THINK OF A CLEVER STRING
ThInK oF a ClEvEr StRiNg

Observe que el Stringobjeto inicial en sí no se modifica.

Eliminar espacios en blanco

Este método devuelve una copia del Stringobjeto inicial en el que se eliminan los espacios en blanco iniciales y finales (espacios, tabulaciones, líneas nuevas).

String ourString = "      Any non-leading and non-trailing whitespace is  n  preserved       ";
System.out.println(ourString.trim());

Salida:

Any non-leading and non-trailing whitespace is  
  preserved

trim() se usa a menudo al procesar la entrada del usuario, ya que se asegura de que no tengamos espacios en blanco inútiles y no cambia la cadena si no los tenemos.

Un uso muy común de trim()la entrada del usuario es verificar si se ingresaron caracteres que no sean espacios en blanco:

// Usually we check for empty inputs like this:
if (userinput.isEmpty()) { ... }
// ...or the equivalent
if (userinput.length() != 0) { ... }

// But a better way to check would be this, which
// handles cases where the user entered only
// whitespace (i.e. "    ")
if (userinput.trim().isEmpty()) { ... }

Formateo de cadenas

El format()método devuelve una cadena formateada con un formato y argumentos determinados. Se utiliza para simplificar la vida al formatear cadenas complejas en Java. Funciona de manera similar a printfen C:

public static String format(String form, Object... args)

Esta declaración de método puede parecer complicada, pero echémosle un vistazo más de cerca:

• Para nuestros propósitos, la staticparte significa que este método se llama a través de la Stringclase y no a través de un objeto de la Stringclase. Lo que significa que cuando queremos usar este método escribimos String.format(...)y no ourString.format(...). Nos podemos llamar al método de la segunda manera, pero ourStringno vamos a jugar un papel en el método de todos modos.
• Los ...(tres puntos) posteriores Objectsolo dicen que aquí se puede pasar un número variable de argumentos. Uno o dos o cincuenta, todo depende del String form.

Comencemos con un ejemplo sencillo.

int a = 2;
int b = 3;
int c = 4;
int d = 1;

// %d indicates we want to print an integer
System.out.println(String.format("%d", a));

2

El format()método pasa por la formcadena, busca caracteres especiales y los reemplaza con argumentos en formato args.

Los caracteres especiales comienzan con a %. En nuestro ejemplo, usamos %d, que Java entiende como “Intentaré analizar el argumento proporcionado argscomo un número entero”.

Un ejemplo un poco más perspicaz de cuándo format()es útil:

// Very messy, hard to read, and hard to maintain
System.out.println("a = " + a + "n" + "b = " + b + "n" + "c = " + c + "n" + "d = " + d + "n");

// Much prettier
System.out.println(String.format("a = %d nb = %d nc = %d nd = %d", a, b, c, d));

Como podemos ver en este ejemplo, Java hace coincidir los caracteres especiales que comienzan %con los argumentos en orden. Lo que significa que cuando se ve la primera %dque va a coincidir con a, la segunda %da by así sucesivamente.

Hay muchos caracteres especiales para format()y puede encontrar la lista completa en los documentos (incluido un montón de opciones de fecha / hora), pero los que verá y usará con más frecuencia son:

• %d: tipos integrales (byte, short, int, long, BigInteger)
• %s: Strings
• %f: para floatcomo un número decimal, %eformateado como un número decimal en notación científica computarizada, e %gimprime lo mismo %fo %edependiendo del valor de precisión después del redondeo.
• %b: para Booleanvalores. Si el valor es null, se imprime “falso”

En términos generales, el format()método tiene una sintaxis aparentemente complicada:

%[argument_index$][flags][width][.precision]conversion

argument_index, flags, width, Y precisionson todos opcionales como se indica por [].

La precisión puede significar diferentes cosas para diferentes tipos de datos. Para flotantes / dobles, la precisión tiene el significado obvio de “cuántos dígitos se supone que debo mostrar después del punto decimal”. Aparte de eso, la precisión especifica el número máximo de caracteres que se escribirán en la salida.

double ourDouble = 1123.9303;
System.out.println(String.format("%f", ourDouble));
System.out.println(String.format("%.3f", ourDouble)); // specifies that we only want 3 digits after decimal point
System.out.println(String.format("%e", ourDouble));

String ourString  = "what does precision do with strings?";
System.out.println(String.format("%.8s", ourString)); // prints the first 8 characters of our string

int ourInt = 123456789;
// System.out.println(String.format("%.4d", ourInt)); // precision can't be used on ints

Esto dará como resultado:

1123.930300
1123.930
1.123930e+03
what doe

El opcional widthespecifica el ancho mínimo de la salida.

// If our number has less than 6 digits, this will
// add extra 0s to the beginning until it does
System.out.println(String.format("%06d", 12)); 

// If our number has more than 6 digits, it will just print it out
System.out.println(String.format("%06d", 1234567));

// We can specify output width, with the output being aligned
// to the right if it's shorter than the given space. If it's
// longer, everything gets printed. The || are added for
// demonstration purposes only
System.out.println(String.format("|%20d|", 12));
// Or we can align the output to the left
System.out.println(String.format("|%-20d|", 12));

// We can also easily print an octal/hexadecimal value of an integer
System.out.println(String.format("Octal: %o, Hex: %x", 10, 10));

La ejecución de este código producirá lo siguiente:

000012
1234567
|                  12|
|12                  |
Octal: 12, Hex: a

Regex y comprobación de subcadenas

contains(CharSequence s)devuelve truesi ses parte de nuestro Stringobjeto ( spuede ser un Stringmismo o un StringBuilderobjeto, o realmente cualquier cosa que implemente CharSequence), de lo contrario, devuelve false.

startsWith(String prefix)regresa truesi nuestro Stringobjeto comienza literalmente con lo dado prefix, de lo contrario regresa false.

endsWith(String suffix)regresa truesi nuestro Stringobjeto termina literalmente con lo dado suffix, de lo contrario regresa false.

matches(String regex)devuelve truesi todo nuestro Stringcoincide con la expresión regular dada .

Todos estos métodos son bastante sencillos. Aunque matches()presupone conocimiento de expresiones regulares.

String ourString = "This string contains a contains.";

System.out.println(ourString.contains("contains"));
System.out.println(ourString.startsWith("T"));
System.out.println(ourString.endsWith(":)"));
System.out.println(ourString.matches(".*string.*"));

Estas operaciones dan como resultado lo siguiente:

true
true
false
true

Reemplazo de caracteres y subcadenas

replace(char oldChar, char newChar)reemplaza todas las apariciones de oldCharcon newChar.

replace(CharSequence target, CharSequence replacement)reemplaza todas las ocurrencias de targetcadena con la replacementcadena (lo que significa que podemos reemplazar subcadenas completas en lugar de solo caracteres).

replaceAll(String regex, String replacement)reemplaza todas las subcadenas que coinciden con el regexargumento con la replacementcadena.

replaceFirst(String regex, String replacement)reemplaza solo la primera subcadena que coincide con el regexargumento con la replacementcadena.

Para evitar confusiones, replace()también reemplaza TODAS las ocurrencias de una secuencia de caracteres, aunque haya un método llamado replaceAll(). La diferencia es que replaceAll()y replaceFirst()usa expresiones regulares para encontrar las secuencias de caracteres que necesitan ser reemplazadas.

String ourString = "We really don't like the letter e here";

System.out.println(ourString.replace('e', 'a'));
System.out.println(ourString.replace("here", "there"));
System.out.println(ourString.replaceAll("e(r+)", "a"));
System.out.println(ourString.replaceFirst("e(r+)", "a"));

Wa raally don't lika tha lattar a hara
We really don't like the letter e there
We really don't like the letta e hae
We really don't like the letta e here, only the first occurrence was replaced

División y unión de cadenas

Los métodos split()y join()son dos caras de una misma moneda.

split(String regex) divide esta cadena usando una expresión regular dada y devuelve una matriz de caracteres.

split(String regex, int limit)es similar al método anterior, pero solo se divide limitvarias veces.

join(CharSequence delimiter, CharSequence... elements)por otro lado, devuelve un que Stringcontiene todos los elementsque enumeramos, unidos por delimiter.

join(CharSequence delimiter, Iterable<? extends CharSequence> elements)es una forma muy complicada de decir que podemos usar join()en cosas como listas, para combinar todos los elementos en un Stringuso dado delimiter.

String ourString = "apples, oranges, pears, pineapples";
String[] fruits = ourString.split(",");

System.out.println(Arrays.toString(fruits));

// This is a great place to use the aforementioned trim() method
// to remove the space at the beginning of some of the words
for(int i = 0; i < fruits.length; i++) {
    fruits[i] = fruits[i].trim();
}

System.out.println(Arrays.toString(fruits)); // Arrays.toString() formats the output array on its own

[apples,  oranges,  pears,  pineapples]
[apples, oranges, pears, pineapples]

Tenga en cuenta que se split()necesita una expresión regular para decidir dónde dividir la cadena, así que tenga cuidado al usar caracteres que tienen un significado especial en las expresiones regulares.

Dado que esos caracteres son comunes (un problema particular es “.” Ya que eso significa “cualquier carácter” en regex), una forma segura de usar split()es con la Pattern.quote(".")que se asegura de que nada se entienda como un carácter especial de regex.

String ourString = "apples.oranges.pears.pineapples";

// This returns then prints an empty array, since every
// character is interpreted as something to be split at
// and ignored
System.out.println(Arrays.toString(ourString.split(".")));

// The "regex safe" way of doing this would be
System.out.println(Arrays.toString(ourString.split(Pattern.quote("."))));

// Splits our string to two substrings at most,
// completely ignoring all other occurrences of "."
System.out.println(Arrays.toString(ourString.split(Pattern.quote("."), 2))); 

[]
[apples, oranges, pears, pineapples]
[apples, oranges.pears.pineapples]

join()hace exactamente lo contrario de split(). Usamos join()cuando tenemos una matriz / lista / etc. de cadenas (o StringBuilders/ StringBuffers) que queremos formar en una nueva Stringusando algún (o ningún) delimitador.

// A common use is to avoid repetitive concatenation,
// i.e. "1" + "," + "2" + "," + "3" + "," + "4"
System.out.println(String.join(",", "1", "2", "3", "4"));

// We can pass an array or any class that implements
// Iterable (containing character sequences) as the
// second parameter as well
String arrayOfStrings[] = {"1","2","3","4","5"};

System.out.println(String.join("-", arrayOfStrings));
System.out.println(String.join("-", Arrays.asList(arrayOfStrings))); // Works just fine with lists as well

// Join them with an empty string to convert an array
// of Strings to one single String without any extra data
System.out.println(String.join("", arrayOfStrings));

1,2,3,4
1-2-3-4-5
1-2-3-4-5
12345

Crear matrices de caracteres

Este método convierte el Stringque se usa en una matriz de caracteres. Devuelve una nueva matriz de caracteres, que contiene todos los caracteres (en orden) que están en String.

toCharArray() una firma de método sencillo.

String ourString = "These will all become separate characters";

System.out.println(Arrays.toString(ourString.toCharArray()));

Esto imprimirá lo siguiente:

[T, h, e, s, e,  , w, i, l, l,  , a, l, l,  , b, e, c, o, m, e,  , s, e, p, a, r, a, t, e,  , c, h, a, r, a, c, t, e, r, s]

Igualdad de Strings

equals(Object str)compara dos cadenas y devuelve truesi las cadenas contienen los mismos caracteres en el mismo orden y de lo falsecontrario. La comparación equalsIgnoreCase()distingue entre mayúsculas y minúsculas (se usa para comparaciones que no distinguen entre mayúsculas y minúsculas).

Es importante entender eso equals()y ==realizar dos operaciones diferentes. equals()compara los caracteres dentro de un Stringobjeto, como se mencionó anteriormente, mientras ==compara la igualdad de referencias de objeto, para ver si se refieren a la misma instancia. Mientras que declaraciones como la 1 == 1respuesta verdadera "string" == "string"podrían no serlo.

La parte complicada aquí es que la salida de ==depende de cómo inicializamos los Stringobjetos que estamos comparando:

String s1 = "Just a String";
String s2 = "Just a String";

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

s2 = new String("Just a String");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

true
true
false
true

equals()devuelve trueen ambos casos. Por lo tanto, siempre debe usarlo a equals()menos que realmente desee ver si dos variables de referencia hacen referencia a la misma instancia, aunque esto es bastante raro.

Conclusión

Es importante comprender los matices de los métodos Strings y String en Java. Pueden ocurrir errores sutiles y difíciles de encontrar con cosas como split()caracteres especiales específicos de expresiones regulares, o al usar por error ==cuando queríamos usar equals().

Lo mejor es mirar siempre cómo funciona un método, probarlo usted mismo para recordar las cosas que debe tener en cuenta. Además, saber qué métodos tiene a su disposición le ahorra el trabajo innecesario de implementar los métodos ya disponibles por sí mismo.