Korzystanie z Java 8 do konwersji listy obiektów na ciąg uzyskany z metody toString ()

W Javie jest wiele przydatnych nowych rzeczy. Np. Mogę iterować ze strumieniem nad listą obiektów, a następnie sumować wartości z określonego pola Objectinstancji. Na przykład

public class AClass {
  private int value;
  public int getValue() { return value; }
}

Integer sum = list.stream().mapToInt(AClass::getValue).sum();

Dlatego pytam, czy jest jakiś sposób na zbudowanie, Stringktóry konkatenuje wynik toString()metody z instancji w jednym wierszu.

List<Integer> list = ...

String concatenated = list.stream().... //concatenate here with toString() method from java.lang.Integer class

Załóżmy, że listzawiera liczby całkowite 1, 2i 3oczekuję, że concatenatedjest "123"albo "1,2,3".

Jednym prostym sposobem jest dołączenie elementów listy do 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);

możesz także spróbować:

String s = list.stream().map(e -> e.toString()).reduce("", String::concat);

Objaśnienie: mapa konwertuje strumień liczb całkowitych na strumień ciągów, a następnie jest redukowany jako konkatenacja wszystkich elementów.

Uwaga: To normal reductiondziała w O (n ² )

dla lepszej wydajności użyj StringBuilderlub mutable reductionpodobny do odpowiedzi F. Böllera.

String s = list.stream().map(Object::toString).collect(Collectors.joining(","));

Ref: Redukcja strumienia

joiningInterfejs API zawiera moduł zbierający . Jest to metoda statyczna w Collectors.

list.stream().map(Object::toString).collect(Collectors.joining(","))

Nie idealny z powodu koniecznego wezwania toString, ale działa. Możliwe są różne ograniczniki.

Na wypadek, gdyby ktoś próbował to zrobić bez java 8, istnieje całkiem niezła sztuczka. List.toString () już zwraca kolekcję, która wygląda następująco:

[1,2,3]

W zależności od konkretnych wymagań można to przetworzyć dowolnie, o ile elementy listy nie zawierają [] lub,.

Na przykład:

list.toString().replace("[","").replace("]","") 

lub jeśli twoje dane mogą zawierać nawiasy kwadratowe:

String s=list.toString();
s = s.substring(1,s.length()-1) 

da ci całkiem rozsądną wydajność.

W każdym wierszu można utworzyć jeden element tablicy w następujący sposób:

list.toString().replace("[","").replace("]","").replaceAll(",","\r\n")

Użyłem tej techniki do tworzenia podpowiedzi HTML z listy w małej aplikacji, z czymś takim jak:

list.toString().replace("[","<html>").replace("]","</html>").replaceAll(",","<br>")

Jeśli masz tablicę, zacznij od Arrays.asList (list) .toString ()

Całkowicie posiadam fakt, że nie jest to optymalne, ale nie jest tak nieefektywne, jak mogłoby się wydawać, i jest łatwe do odczytania i zrozumienia. Jest jednak dość nieelastyczny - w szczególności nie próbuj oddzielać elementów poleceniem replaceAll, jeśli dane mogą zawierać przecinki, i użyj wersji podłańcuchowej, jeśli masz w nawiasach kwadratowych dane, ale dla tablicy liczb jest to w zasadzie idealny.

Inne odpowiedzi są w porządku. Można jednak również przekazać Collectors.toList () jako parametr do Stream.collect (), aby zwrócić elementy jako ArrayList.

System.out.println( list.stream().map( e -> e.toString() ).collect( toList() ) );

StringListName = ObjectListName.stream (). Map (m -> m.toString ()) .collect (Collectors.toList ());

W interfejsie API String istnieje metoda dla przypadków użycia „dołączania listy ciągów”, nawet nie potrzebujesz Stream.

List<String> myStringIterable = Arrays.asList("baguette", "bonjour");

String myReducedString = String.join(",", myStringIterable);

// And here you obtain "baguette,bonjour" in your myReducedString variable

List<String> list = Arrays.asList("One", "Two", "Three");
    list.stream()
            .reduce("", org.apache.commons.lang3.StringUtils::join);

Lub

List<String> list = Arrays.asList("One", "Two", "Three");
        list.stream()
                .reduce("", (s1,s2)->s1+s2);

Podejście to pozwala również zbudować ciąg znaków z listy obiektów Przykład

List<Wrapper> list = Arrays.asList(w1, w2, w2);
        list.stream()
                .map(w->w.getStringValue)
                .reduce("", org.apache.commons.lang3.StringUtils::join);

Tutaj funkcja zmniejszania pozwala uzyskać pewną wartość początkową, do której chcesz dołączyć nowy ciąg Przykład:

 List<String> errors = Arrays.asList("er1", "er2", "er3");
            list.stream()
                    .reduce("Found next errors:", (s1,s2)->s1+s2);

Testowanie obu podejść sugerowanych w Shail016 i odpowiedzi bpedroso ( https://stackoverflow.com/a/24883180/2832140 ), prosta StringBuilder+ append(String)w forpętli, wydaje się działać znacznie szybciej niż list.stream().map([...].

Przykład: ten kod przechodzi przez Map<Long, List<Long>>kompilację łańcucha json, używając list.stream().map([...]:

if (mapSize > 0) {
    StringBuilder sb = new StringBuilder("[");

    for (Map.Entry<Long, List<Long>> entry : threadsMap.entrySet()) {

        sb.append("{\"" + entry.getKey().toString() + "\":[");
        sb.append(entry.getValue().stream().map(Object::toString).collect(Collectors.joining(",")));
    }
    sb.delete(sb.length()-2, sb.length());
    sb.append("]");
    System.out.println(sb.toString());
}

Na mojej maszynie deweloperskiej junit zwykle wykonuje od 0,35 do 1,2 sekundy. Podczas korzystania z tego kodu zajmuje od 0,15 do 0,33 sekundy:

if (mapSize > 0) {
    StringBuilder sb = new StringBuilder("[");

    for (Map.Entry<Long, List<Long>> entry : threadsMap.entrySet()) {

        sb.append("{\"" + entry.getKey().toString() + "\":[");

        for (Long tid : entry.getValue()) {
            sb.append(tid.toString() + ", ");
        }
        sb.delete(sb.length()-2, sb.length());
        sb.append("]}, ");
    }
    sb.delete(sb.length()-2, sb.length());
    sb.append("]");
    System.out.println(sb.toString());
}

Czy możemy tego spróbować?

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);

    }

String actual = list.stream().reduce((t, u) -> t + "," + u).get();

Zamierzam użyć interfejsu API strumieni do konwersji strumienia liczb całkowitych na pojedynczy ciąg. Problem z niektórymi z podanych odpowiedzi polega na tym, że wytwarzają one środowisko wykonawcze O (n ^ 2) z powodu budowania ciągów. Lepszym rozwiązaniem jest użycie StringBuilder, a następnie połączenie ciągów razem jako ostatni krok.

//              Create a stream of integers 
    String result = Arrays.stream(new int[]{1,2,3,4,5,6 })                
            // collect into a single StringBuilder
            .collect(StringBuilder::new, // supplier function
                    // accumulator - converts cur integer into a string and appends it to the string builder
                    (builder, cur) -> builder.append(Integer.toString(cur)),
                    // combiner - combines two string builders if running in parallel
                    StringBuilder::append) 
            // convert StringBuilder into a single string
            .toString();

Możesz pójść o krok dalej, konwertując kolekcję obiektów na pojedynczy ciąg.

// Start with a class definition
public static class AClass {
    private int value;
    public int getValue() { return value; }
    public AClass(int value) { this.value = value; }

    @Override
    public String toString() {
        return Integer.toString(value);
    }
}

// Create a stream of AClass objects
        String resultTwo = Arrays.stream(new AClass[]{
                new AClass(1),
                new AClass(2),
                new AClass(3),
                new AClass(4)
        })
                // transform stream of objects into a single string
                .collect(StringBuilder::new,
                        (builder, curObj) -> builder.append(curObj.toString()),
                        StringBuilder::append
                )
            // finally transform string builder into a single string
            .toString();

Z Javą 8+

String s = Arrays.toString(list.stream().toArray(AClass[]::new));

Nie jest najbardziej wydajny, ale jest to rozwiązanie z niewielką ilością kodu.

Możesz to zrobić w ten sposób.

    List<String> list = Arrays.asList("One", "Two", "Three");
    String result = String.join(", ", list);
    System.out.println(result);