使用流将对象列表转换为从 toString 方法获得的字符串

Question

Java 8 中有很多有用的新东西。例如，我可以用流遍历对象列表，然后对 Object 实例的特定字段中的值求和。例如

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

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

因此，我想问是否有任何方法可以构建 String，将 toString() 方法的输出从实例中连接到一行中。

List<Integer> list = ...

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

假设list 包含整数1、2 和3，我希望concatenated 是"123" 或"1,2,3"。

Answer 1

一种简单的方法是将列表项附加到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);

你也可以试试：

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

说明：map 将 Integer 流转换为 String 流，然后将其归约为所有元素的串联。

注意：这是normal reduction，执行时间为 O(n²)

为了获得更好的性能，请使用类似于 F. Böller 的答案的 StringBuilder 或 mutable reduction。

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

参考：Stream Reduction

Answer 2

我将使用流 api 将整数流转换为单个字符串。一些提供的答案的问题是，由于字符串构建，它们产生了 O(n^2) 运行时。更好的解决方案是使用 StringBuilder，然后将字符串连接在一起作为最后一步。

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

您可以通过将对象集合转换为单个字符串来进一步处理此过程。

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

Answer 3

对于那些“加入字符串列表”的用例，String API 中有一个方法，你甚至不需要 Stream。

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

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

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

Answer 4

API 中有一个收集器joining。 这是Collectors中的静态方法。

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

由于toString 的必要调用，并不完美，但可以。可以使用不同的分隔符。

Answer 5

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

Answer 6

在for 循环中测试Shail016 和bpedroso 答案(https://stackoverflow.com/a/24883180/2832140) 中建议的两种方法，简单的StringBuilder + append(String) 似乎比list.stream().map([...] 执行得快得多。

示例：此代码遍历 Map<Long, List<Long>> 构建一个 json 字符串，使用 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());
}

在我的开发虚拟机上，junit 通常需要 0.35 到 1.2 秒来执行测试。而使用以下代码，需要 0.15 到 0.33 秒：

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

Answer 7

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

或者

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

此方法还允许您从对象列表构建字符串结果 示例

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

这里的reduce函数允许你有一些你想附加新字符串的初始值 示例：

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

Answer 8

以防万一有人在没有 java 8 的情况下尝试这样做，有一个非常好的技巧。 List.toString() 已经返回一个如下所示的集合：

[1,2,3]

根据您的具体要求，只要您的列表项不包含 [] 或 , ，就可以将其后处理为您想要的任何内容。

例如：

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

或者如果您的数据可能包含方括号：

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

会给你一个相当合理的输出。

每行的一个数组项可以这样创建：

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

我使用这种技术从一个小应用程序中的列表制作 html 工具提示，类似于：

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

如果你有一个数组，那么从 Arrays.asList(list).toString() 开始

我完全承认这不是最优的，但它并没有你想象的那么低效，而且阅读和理解起来非常简单。但是，它非常不灵活 - 特别是如果您的数据可能包含逗号，请不要尝试使用 replaceAll 分隔元素，如果您的数据中有方括号，请使用子字符串版本，但对于数字数组，它几乎完美。

Answer 9

使用 Java 8+

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

不是最高效的，但它是一个用少量代码的解决方案。

Answer 10

另外，你也可以这样做。

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

Answer 11

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

Answer 12

我们可以试试这个吗？

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

    }

Answer 13

其他答案都很好。但是，您也可以将Collectors.toList() 作为参数传递给Stream.collect()，以将元素作为ArrayList 返回。

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