Introducción
Contenido
- 1 Introducción
- 2 String
- 3 Concatenación de cadenas
- 4 Determinar la longitud de la String
- 5 Encontrar personajes y subcadenas
- 6 Comparación de cadenas
- 7 Extraer subcadenas
- 8 Cambio de caja de Strings
- 9 Eliminar espacios en blanco
- 10 Formateo de cadenas
- 11 Regex y comprobación de subcadenas
- 12 Reemplazo de caracteres y subcadenas
- 13 División y unión de cadenas
- 14 Crear matrices de caracteres
- 15 Igualdad de Strings
- 16 Conclusión
En pocas palabras, a String
se utiliza para almacenar texto, es decir, una secuencia de caracteres. La clase más utilizada de Java es la String
clase, 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 String
s, 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 String
los 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 String
clase 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 String
clase 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. String
los 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 String
objeto. 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 StringBuilder
para 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 StringBuilder
clase antes mencionada .
Funciona como un String
objeto 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+1
se 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 true
o false
dependiendo de si nuestro String
está vacío o no. Entonces esto significa que isEmpty()
regresa true
para 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 String
es 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 String
comienza 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 dadoindexOf(int ch, int fromIndex)
devuelve el primer índice que coincide con el valor de carácter dado DESPUÉSfromIndex
indexOf(String substring)
devuelve la (primera) posición inicialsubstring
delString
objeto en el que se llamóindexOf(String substring, int fromIndex)
igual que el método anterior, pero la búsqueda comienza en enfromIndex
lugar 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 String
objeto hacia atrás a menos que fromIndex
se especifique a.
El índice pasado al método debe estar dentro del rango [0, example.length() - 1]
para ser válido. De lo contrario, StringIndexOutOfBoundsException
se 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 String
con 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, compareTo
devuelve 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 Comparator
una clase personalizada.
Por ejemplo, digamos que tenemos un Person
objeto como el siguiente:
class Person {
String firstName;
String lastName;
// ...
}
Ahora digamos que tenemos un ArrayList
«pueblo» llamado de muchos Person
objetos, sin ningún orden en particular. Nos gustaría ordenar eso ArrayList
para 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 queString
contiene todos los caracteres desdestartIndex
(inclusive) hasta el final de nuestroString
. Se comporta igual quesubstring(int startIndex, ourString.length())
.substring(int startIndex, int endIndex)
devuelve un queString
contiene todos los caracteres destartIndex
(inclusive) aendIndex
(exclusivo, es decir, el carácter enendIndex
no 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 StringIndexOutOfBoundsException
por cualquiera de las siguientes razones:
startIndex
es negativoendIndex
es mayor que la longitud de nuestroString
objetostartIndex
Es mas grande queendIndex
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 endIndex
de otros lenguajes de programación), esa regla puede derivarse de ese hecho que startIndex
no puede ser negativo , y endIndex
tiene que ser mayor que startIndex
.
Sin embargo, Java simplemente nos hace dar el paso adicional de escribir ourString.length() - someNumber
como en endIndex
lugar 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 String
objeto inicial en sí no se modifica.
Eliminar espacios en blanco
Este método devuelve una copia del String
objeto 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 printf
en 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
static
parte significa que este método se llama a través de laString
clase y no a través de un objeto de laString
clase. Lo que significa que cuando queremos usar este método escribimosString.format(...)
y noourString.format(...)
. Nos podemos llamar al método de la segunda manera, peroourString
no vamos a jugar un papel en el método de todos modos. - Los
...
(tres puntos) posterioresObject
solo dicen que aquí se puede pasar un número variable de argumentos. Uno o dos o cincuenta, todo depende delString 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 form
cadena, 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 args
como 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 %d
que va a coincidir con a
, la segunda %d
a b
y 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
: parafloat
como un número decimal,%e
formateado como un número decimal en notación científica computarizada, e%g
imprime lo mismo%f
o%e
dependiendo del valor de precisión después del redondeo.%b
: paraBoolean
valores. Si el valor esnull
, 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 precision
son 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 width
especifica 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 true
si s
es parte de nuestro String
objeto ( s
puede ser un String
mismo o un StringBuilder
objeto, o realmente cualquier cosa que implemente CharSequence
), de lo contrario, devuelve false
.
startsWith(String prefix)
regresa true
si nuestro String
objeto comienza literalmente con lo dado prefix
, de lo contrario regresa false
.
endsWith(String suffix)
regresa true
si nuestro String
objeto termina literalmente con lo dado suffix
, de lo contrario regresa false
.
matches(String regex)
devuelve true
si todo nuestro String
coincide 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 oldChar
con newChar
.
replace(CharSequence target, CharSequence replacement)
reemplaza todas las ocurrencias de target
cadena con la replacement
cadena (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 regex
argumento con la replacement
cadena.
replaceFirst(String regex, String replacement)
reemplaza solo la primera subcadena que coincide con el regex
argumento con la replacement
cadena.
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 limit
varias veces.
join(CharSequence delimiter, CharSequence... elements)
por otro lado, devuelve un que String
contiene todos los elements
que 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 String
uso 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 String
usando 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 String
que 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 true
si las cadenas contienen los mismos caracteres en el mismo orden y de lo false
contrario. 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 String
objeto, 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 == 1
respuesta verdadera "string" == "string"
podrían no serlo.
La parte complicada aquí es que la salida de ==
depende de cómo inicializamos los String
objetos 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 true
en 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.