simples - Usar Java 8 para convertir una lista de objetos en una cadena obtenida del método toString()
ejercicios resueltos de programación orientada a objetos en java (9)
¿Podemos intentar esto?
public static void main(String []args){
List<String> stringList = new ArrayList<>();
for(int i=0;i< 10;i++){
stringList.add(""+i);
}
String stringConcated = String.join(",", stringList);
System.out.println(stringConcated);
}
Hay muchas cosas nuevas útiles en Java 8. Por ejemplo, puedo iterar con una secuencia sobre una lista de objetos y luego sumar los valores de un campo específico de las instancias del Object . P.ej
public class AClass {
private int value;
public int getValue() { return value; }
}
Integer sum = list.stream().mapToInt(AClass::getValue).sum();
Por lo tanto, estoy preguntando si hay alguna manera de construir un String que concatene la salida del método toString() de las instancias en una sola línea.
List<Integer> list = ...
String concatenated = list.stream().... //concatenate here with toString() method from java.lang.Integer class
Supongamos que esa list contiene los enteros 1 , 2 y 3 , espero que concatenated sea "123" o "1,2,3" .
Además, puedes hacer esto.
List<String> list = Arrays.asList("One", "Two", "Three");
String result = String.join(", ", list);
System.out.println(result);
Con Java 8+
String s = Arrays.toString(list.stream().toArray(AClass[]::new));
No es el más eficiente, pero es una solución con una pequeña cantidad de código.
En caso de que alguien intente hacer esto sin Java 8, hay un truco bastante bueno. List.toString () ya devuelve una colección que se ve así:
[1,2,3]
Dependiendo de sus requisitos específicos, esto se puede procesar posteriormente a lo que desee, siempre y cuando los elementos de su lista no contengan [] o,.
Por ejemplo:
list.toString().replace("[","").replace("]","")
o si sus datos pueden contener corchetes esto:
String s=list.toString();
s = s.substring(1,s.length()-1)
obtendrá un resultado bastante razonable.
Un elemento de matriz en cada línea se puede crear de esta manera:
list.toString().replace("[","").replace("]","").replaceAll(",","/r/n")
Utilicé esta técnica para crear información sobre herramientas html de una lista en una aplicación pequeña, con algo como:
list.toString().replace("[","<html>").replace("]","</html>").replaceAll(",","<br>")
Si tiene una matriz, empiece con Arrays.asList (list) .toString () en su lugar
Reconoceré por completo que esto no es óptimo, pero no es tan ineficiente como podría pensar y es bastante fácil de leer y entender. Sin embargo, es bastante inflexible; en particular, no intente separar los elementos con replaceAll si sus datos pueden contener comas y usar la versión de subcadena si tiene corchetes en sus datos, pero para una matriz de números es más o menos Perfecto.
Hay un colector que se joining a la API. Es un método estático en Collectors .
list.stream ().map (i -> i.toString ()).collect (Collectors.joining (","))
No es perfecto debido a la llamada necesaria de toString , pero funciona. Diferentes delimitadores son posibles.
Las otras respuestas están bien. Sin embargo, también puede pasar Collectors.toList() como parámetro a Stream.collect() para devolver los elementos como ArrayList.
System.out.println( list.stream().map( e -> e.toString() ).collect( toList() ) );
Una forma simple es agregar los elementos de tu lista en un StringBuilder
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
StringBuilder b = new StringBuilder();
list.forEach(b::append);
System.out.println(b);
también puedes probar:
String s = list.stream().map(e -> e.toString()).reduce("", String::concat);
Explicación: el mapa convierte una secuencia de enteros a una cadena de transmisión, luego se reduce como una concatenación de todos los elementos.
Nota: Esta es normal reduction que se realiza en O (n 2 )
para un mejor rendimiento utilice una mutable reduction StringBuilder o mutable reduction similar a la respuesta de F. Böller.
String s = list.stream().map(Object::toString).collect(Collectors.joining(","));
List<String> list = Arrays.asList("One", "Two", "Three");
list.stream()
.reduce("", org.apache.commons.lang3.StringUtils::join);
O
List<String> list = Arrays.asList("One", "Two", "Three");
list.stream()
.reduce("", (s1,s2)->s1+s2);
Este enfoque también le permite construir un resultado de cadena a partir de una lista de objetos Ejemplo
List<Wrapper> list = Arrays.asList(w1, w2, w2);
list.stream()
.map(w->w.getStringValue)
.reduce("", org.apache.commons.lang3.StringUtils::join);
Aquí la función de reducción le permite tener un valor inicial al que desea agregar una nueva cadena Ejemplo:
List<String> errors = Arrays.asList("er1", "er2", "er3");
list.stream()
.reduce("Found next errors:", (s1,s2)->s1+s2);
String actual = list.stream().reduce((t, u) -> t + "," + u).get();