Antes de Java 8, cuando necesitamos concatenar un grupo de strings, necesitamos escribir ese código manualmente, además de esto, necesitábamos usar delimitador repetidamente y, a veces, conduce a varios errores, pero después de Java 8 podemos concatenar las strings usando la clase StringJoiner y String.join() entonces podemos lograr nuestro objetivo fácilmente.
Ejemplo: sin la clase StringJoiner y sin el método String.join()
Acercarse :
- En este programa no usaremos Java 8, intentaremos hacerlo manualmente e intentaremos entender para esta simple operación de concatenación de strings con delimitador cuánto código/pasos más grandes necesitábamos para lograr nuestro objetivo.
- Primero, uniremos tres strings «DSA», «FAANG», «ALGO», y el delimitador será «gfg». Para hacer esto, debemos escribir el delimitador cada vez antes de agregar la siguiente string.
- A continuación, uniremos los elementos de una ArrayList que contiene las strings «DSA», «FAANG», «ALGO» y el delimitador será «gfg» y, para hacer esto, necesitábamos iterar sobre ArrayList y luego agregar strings usando un delimitador.
- Tenga en cuenta aquí que para i=0 asignamos directamente la string unida2 al primer elemento de ArrayList porque si no establecimos esta condición, obtendremos una salida como esta «gfg DSA gfg FAANG gfg ALGO» mientras que la salida real no tenía un delimitador antes del primer elemento de ArrayList “DSA gfg FAANG gfg ALGO”.
- A partir del código, puede ver cuánto código se escribe para realizar esta tarea simple para realizar la tarea. Ahora buscaremos usar la clase StringJoiner y el método String.join().
Java
// Java program for joining the strings before Java8
// by simple method using '+' to concatenate
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
class GFG {
public static void main(String[] args)
{
// Here we need to join strings "DSA","FAANG","ALGO"
// and with delimiter " gfg "
String joined = "DSA"
+ " gfg "
+ "FAANG"
+ " gfg "
+ "ALGO";
// Here we created an ArrayList of strings
// ArrayList contains "DSA","FAANG","ALGO"
ArrayList<String> gfgstrings = new ArrayList<>(
Arrays.asList("DSA", "FAANG", "ALGO"));
String joined2 = "";
// Now we will iterate over ArrayList
for (int i = 0; i < gfgstrings.size(); i++) {
// for i== 0 we do not want to add space before
// first word thats why we checked for i=0
if (i == 0) {
joined2 = gfgstrings.get(i);
}
else {
joined2
= joined2 + " gfg " + gfgstrings.get(i);
}
}
// printing the first output
System.out.println(joined);
System.out.println("--------------------");
// printing the second output
System.out.println(joined2);
}
}
DSA gfg FAANG gfg ALGO -------------------- DSA gfg FAANG gfg ALGO
StringJoiner se utiliza para construir una secuencia de caracteres separados por un delimitador y, opcionalmente, comenzando con un prefijo proporcionado y terminando con un sufijo proporcionado. En palabras simples, en el constructor de llamadas StringJoiner podemos pasar tres parámetros delimitador, sufijo, prefijo. El prefijo se agregará al comienzo de una string y el sufijo estará al final. Para agregar las strings, simplemente necesitaremos llamar al método add() en la clase StringJoiner.
Sintaxis:
Si tenemos sufijo y prefijo
StringJoiner joined=StringJoiner(delimiter,prefix,suffix) joined.add(string1); joined.add(string2); joined.add(string3);
Si no tenemos sufijo y prefijo
StringJoiner joined=StringJoiner(delimiter) joined.add(string1); joined.add(string2); joined.add(string3);
Acercarse:
- Si está agregando un grupo de strings, debe crear el objeto de clase StringJoiner y pasar el delimitador, el prefijo y el sufijo.
- Aquí el delimitador es la string «gfg» y el prefijo es «[» y el sufijo es «]». Ahora necesitamos agregar strings en la clase StringJoiner usando el método add().
- Finalmente, convertiremos el objeto StringJoiner en un objeto String usando el método toString().
- En caso de que tengamos una ArrayList de strings, el delimitador es «gfg» y el prefijo es «[» y el sufijo es «]» e iteraremos sobre la Arraylist y los elementos en StringJoiner y luego los convertiremos en un objeto String.
- Finalmente, imprimiremos la salida.
Programa de unión de strings usando la clase StringJoiner:
Java
// Java program for joining the strings
// Using StringJoiner class
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringJoiner;
class GFG {
public static void main(String[] args)
{
// Here we need to join strings "DSA","FAANG","ALGO"
// and with delimiter " gfg "
StringJoiner sj
= new StringJoiner(" gfg ", "[", "]");
sj.add("DSA");
sj.add("FAANG");
sj.add("ALGO");
// Convert StringJoiner to String
String joined = sj.toString();
// Here we created an ArrayList of strings
ArrayList<String> gfgstrings = new ArrayList<>(
Arrays.asList("DSA", "FAANG", "ALGO"));
// StringJoiner class having parameters
// delimiter,prefix,suffix
StringJoiner sj2
= new StringJoiner(" gfg ", "[", "]");
// Now we will iterate over ArrayList
// and adding in string Joiner class
for (String arl : gfgstrings) {
sj2.add(arl);
}
// convert StringJoiner object to String
String joined2 = sj2.toString();
// printing the first output
System.out.println(joined);
System.out.println("--------------------");
// printing the second output
System.out.println(joined2);
}
}
[DSA gfg FAANG gfg ALGO] -------------------- [DSA gfg FAANG gfg ALGO]
El método java.lang.string.join() concatena el elemento dado con el delimitador y devuelve la string concatenada. Tenga en cuenta que si un elemento es nulo, se agrega nulo. El método join() se introdujo en java string desde JDK 1.8. El método String.join() toma dos parámetros, primero es un delimitador y el segundo puede ser una lista o array de elementos o elementos separados por, (coma).
Sintaxis:
En el caso de elementos individuales
String joined=String.join("delimiter","element1","element2,"element3"...);
En el caso de Lista
String joined2=String.join("delimiter",listObject);
Tipo de devolución: devuelve la string unida mediante el uso de delimitador
Ejemplo:
Enfoque: unir strings usando el método String.join()
- En este ejemplo para la string individual, necesitamos pasar el delimitador y las strings en el método join(). Aquí el delimitador es «gfg» y las strings son «DSA», «FAANG», «ALGO».
- String.join() devolverá la string unida usando un delimitador.
- Para ArrayList, simplemente debemos pasar el delimitador y el objeto de la lista en el método de unión join(” gfg “,listObject) esto devolverá la string unida usando el delimitador en cada elemento de ArrayList.
Java
// Java program for joining the strings
// Using String.join() method
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringJoiner;
class GFG {
public static void main(String[] args)
{
// Here we need to join strings "DSA","FAANG","ALGO"
// and with delimiter " gfg "
String joined
= String.join(" gfg ", "DSA", "FAANG", "ALGO");
// Here we created an ArrayList of strings
ArrayList<String> gfgstrings = new ArrayList<>(
Arrays.asList("DSA", "FAANG", "ALGO"));
String joined2 = String.join(" gfg ", gfgstrings);
// printing the first output
System.out.println(joined);
System.out.println("--------------------");
// printing the second output
System.out.println(joined2);
}
}
DSA gfg FAANG gfg ALGO -------------------- DSA gfg FAANG gfg ALGO
Publicación traducida automáticamente
Artículo escrito por rajatagrawal5 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA