很好地打印 Java 集合（toString 不返回漂亮的输出）

Question

我希望像 Eclipse 调试器那样打印 Stack 对象（即 [1,2,3...]），但使用 out = "output:" + stack 不会返回这个好的结果。

只是为了澄清一下，我正在谈论 Java 的内置集合，因此我无法重写其 toString()。

如何获得堆栈的精美可打印版本？

Answer 1

您可以将其转换为数组，然后使用 Arrays.toString(Object[]) 打印出来：

System.out.println(Arrays.toString(stack.toArray()));

Answer 2

String.join(",", yourIterable);

（Java 8）

Answer 3

使用 java 8 流和收集器可以轻松完成：

String format(Collection<?> c) {
  String s = c.stream().map(Object::toString).collect(Collectors.joining(","));
  return String.format("[%s]", s);
}

首先我们使用 map 和 Object::toString 来创建 Collection，然后使用连接收集器以 , 作为分隔符连接集合中的每个项目。

Answer 4

Apache Commons 项目提供的 MapUtils 类提供了一个 MapUtils.debugPrint 方法，可以漂亮地打印您的地图。

Answer 5

番石榴看起来是一个不错的选择：

Iterables.toString(myIterable)

Answer 6

System.out.println(Collection c) 已经以可读格式打印任何类型的集合。 仅当集合包含用户定义的对象时，才需要在用户定义的类中实现 toString() 来显示内容。

Answer 7

在类上实现 toString()。

我推荐 Apache Commons ToStringBuilder 使这变得更容易。 有了它，您只需编写这种方法：

public String toString() {
     return new ToStringBuilder(this).
       append("name", name).
       append("age", age).
       toString(); 
}

为了获得这种输出：

人@7f54[姓名=斯蒂芬，年龄=29]

还有一个 反射实现。

Answer 8

我同意上面关于在您自己的类上覆盖 toString() 的评论（以及尽可能自动化该过程）。

对于您没有定义的类，您可以为您想要根据自己的喜好处理的每个库类编写一个带有重载方法的ToStringHelper类：

public class ToStringHelper {
    //... instance configuration here (e.g. punctuation, etc.)
    public toString(List m) {
        // presentation of List content to your liking
    }
    public toString(Map m) {
        // presentation of Map content to your liking
    }
    public toString(Set m) {
        // presentation of Set content to your liking
    }
    //... etc.
}

编辑：响应xukxpvfzflbbld 的评论，这是前面提到的情况的可能实现。

package com.so.demos;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class ToStringHelper {

    private String separator;
    private String arrow;

    public ToStringHelper(String separator, String arrow) {
        this.separator = separator;
        this.arrow = arrow;
    }

   public String toString(List<?> l) {
        StringBuilder sb = new StringBuilder("(");
        String sep = "";
        for (Object object : l) {
            sb.append(sep).append(object.toString());
            sep = separator;
        }
        return sb.append(")").toString();
    }

    public String toString(Map<?,?> m) {
        StringBuilder sb = new StringBuilder("[");
        String sep = "";
        for (Object object : m.keySet()) {
            sb.append(sep)
              .append(object.toString())
              .append(arrow)
              .append(m.get(object).toString());
            sep = separator;
        }
        return sb.append("]").toString();
    }

    public String toString(Set<?> s) {
        StringBuilder sb = new StringBuilder("{");
        String sep = "";
        for (Object object : s) {
            sb.append(sep).append(object.toString());
            sep = separator;
        }
        return sb.append("}").toString();
    }

}

这不是一个完整的实现，而只是一个开始。

Answer 9

您可以使用 JAVA 中的“Objects”类（自 1.7 起可用）

Collection<String> myCollection = Arrays.asList("1273","123","876","897");
Objects.toString(myCollection);

输出：1273, 123, 876, 897

另一种可能性是使用 Google Guave 中的“MoreObjects”类< /strong>，它提供了许多有用的辅助函数：

MoreObjects.toStringHelper(this).add("NameOfYourObject", myCollection).toString());

输出：
NameOfYourObject=[1273, 123, 876, 897]

番石榴文档

Answer 10

使用Apache Commons 3，您想要调用

StringUtils.join(myCollection, ",")

Answer 11

在Java8

//will prints each element line by line
stack.forEach(System.out::println);

或

//to print with commas
stack.forEach(
    (ele) -> {
        System.out.print(ele + ",");
    }
);

Answer 12

如今，大多数集合在 Java 中（Java7/8）都有一个有用的 toString()。
因此，无需执行流操作来连接您需要的内容，只需覆盖集合中值类的 toString 即可获得您需要的内容。

AbstractMap 和 < a href="https://docs.oracle.com/javase/8/docs/api/java/util/AbstractCollection.html#toString--" rel="nofollow noreferrer">AbstractCollection 实现 toString()通过对每个元素调用 toString 。

下面是一个显示行为的测试类。

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class ToString {
  static class Foo {
    int i;
    public Foo(int i) { this.i=i; }
    @Override
    public String toString() {
        return "{ i: " + i + " }";
    }
  }
  public static void main(String[] args) {
    List<Foo> foo = new ArrayList<>();
    foo.add(new Foo(10));
    foo.add(new Foo(12));
    foo.add(new Foo(13));
    foo.add(new Foo(14));
    System.out.println(foo.toString());
    // prints: [{ i: 10 }, { i: 12 }, { i: 13 }, { i: 14 }]

    Map<Integer, Foo> foo2 = new HashMap<>();
    foo2.put(10, new Foo(10));
    foo2.put(12, new Foo(12));
    foo2.put(13, new Foo(13));
    foo2.put(14, new Foo(14));
    System.out.println(foo2.toString());
    // prints: {10={ i: 10 }, 12={ i: 12 }, 13={ i: 13 }, 14={ i: 14 }}
  }
}

更新 Java 14（2020 年 3 月）

如果您的类仅保存数据，记录现在是一项预览功能，不需要您重写 toString()。 记录实现了数据契约，允许公众对其字段进行只读访问，并实现默认函数以方便您使用，例如比较、toString 和 hashcode。

因此，一旦可以实现 Foo ，其行为如下：

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class ToString {
  static record Foo(int i) { }
  
  public static void main(String[] args) {
    Foo f = new Foo(10);
    System.out.println(f.toString());
    // prints: Foo[i=10]

    List<Foo> foo = new ArrayList<>();
    foo.add(new Foo(10));
    foo.add(new Foo(12));
    foo.add(new Foo(13));
    foo.add(new Foo(14));
    System.out.println(foo.toString());
    // prints: [Foo[i=10], Foo[i=12], Foo[i=13], Foo[i=14]]

    Map<Integer, Foo> foo2 = new HashMap<>();
    foo2.put(10, new Foo(10));
    foo2.put(12, new Foo(12));
    foo2.put(13, new Foo(13));
    foo2.put(14, new Foo(14));
    System.out.println(foo2.toString());
    // prints: {10=Foo[i=10], 12=Foo[i=12], 13=Foo[i=13], 14=Foo[i=14]}
  }
}

Answer 13

较新的 JDK 已经实现了 AbstractCollection.toString()，并且 Stack 扩展了 AbstractCollection，因此您只需调用 toString()代码> 在您的收藏中：

    public abstract class AbstractCollection<E> implements Collection<E> {
    ...
    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";
    
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

Answer 14

如果这是您自己的集合类而不是内置集合类，则需要重写其 toString 方法。 Eclipse 会为任何没有硬连线格式的对象调用该函数。

Answer 15

只是修改了前面的示例以打印包含用户定义对象的集合。

public class ToStringHelper {

    private  static String separator = "\n";

    public ToStringHelper(String seperator) {
        super();
        ToStringHelper.separator = seperator;

    }

    public  static String toString(List<?> l) {
        StringBuilder sb = new StringBuilder();
        String sep = "";
        for (Object object : l) {
            String v = ToStringBuilder.reflectionToString(object);
            int start = v.indexOf("[");
            int end = v.indexOf("]");
            String st =  v.substring(start,end+1);
            sb.append(sep).append(st);
            sep = separator;
        }
        return sb.toString();
    }

    public static String toString(Map<?,?> m) {
        StringBuilder sb = new StringBuilder();
        String sep = "";
        for (Object object : m.keySet()) {
            String v = ToStringBuilder.reflectionToString(m.get(object));
            int start = v.indexOf("[");
            int end = v.indexOf("]");
            String st =  v.substring(start,end+1);
            sb.append(sep).append(st);
            sep = separator;
        }
        return sb.toString();
    }

    public static String toString(Set<?> s) {
        StringBuilder sb = new StringBuilder();
        String sep = "";
        for (Object object : s) {
            String v = ToStringBuilder.reflectionToString(object);
            int start = v.indexOf("[");
            int end = v.indexOf("]");
            String st =  v.substring(start,end+1);
            sb.append(sep).append(st);
            sep = separator;
        }
        return sb.toString();
    }

    public static void print(List<?> l) {
        System.out.println(toString(l));    
    }
    public static void print(Map<?,?> m) {
        System.out.println(toString(m));    
    }
    public static void print(Set<?> s) {
        System.out.println(toString(s));    
    }

}

Answer 16

在 Collection 上调用 Sop 时要小心，它可能会抛出 ConcurrentModification 异常。 因为每个 Collection 的内部 toString 方法内部都会调用 Collection 上的 Iterator 。

Answer 17

应该适用于除 Map 之外的任何集合，但它也很容易支持。
如果需要，修改代码以将这 3 个字符作为参数传递。

static <T> String seqToString(Iterable<T> items) {
    StringBuilder sb = new StringBuilder();
    sb.append('[');
    boolean needSeparator = false;
    for (T x : items) {
        if (needSeparator)
            sb.append(' ');
        sb.append(x.toString());
        needSeparator = true;
    }
    sb.append(']');
    return sb.toString();
}

Answer 18

您可以尝试使用

org.apache.commons.lang3.builder.ToStringBuilder.reflectionToString(yourCollection);

Answer 19

有两种方法可以简化您的工作。
1.导入Gson库。
2.使用龙目岛。

它们都可以帮助您从对象实例创建字符串。 Gson将解析你的对象，lombok将重写你的类对象的toString方法。

我举了一个关于 Gson PrettyPrint 的例子，我创建了辅助类来打印对象和对象集合。 如果您使用 lombok，您可以将您的类标记为 @ToString 并直接打印您的对象。

@Scope(value = "prototype")
@Component
public class DebugPrint<T> {
   public String PrettyPrint(T obj){
      Gson gson = new GsonBuilder().setPrettyPrinting().create();
      return gson.toJson(obj);
   }
   public String PrettyPrint(Collection<T> list){
      Gson gson = new GsonBuilder().setPrettyPrinting().create();
      return list.stream().map(gson::toJson).collect(Collectors.joining(","));
   }

}

Answer 20

JSON

另一种解决方案可以将您的集合转换为 JSON 格式并打印Json 字符串。 优点是格式良好且可读的对象字符串，无需实现 toString() 。

使用 Google 的 Gson 的示例：

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

...

    printJsonString(stack);

...
public static void printJsonString(Object o) {
    GsonBuilder gsonBuilder = new GsonBuilder();
    /*
     * Some options for GsonBuilder like setting dateformat or pretty printing
     */
    Gson gson = gsonBuilder.create();
    String json= gson.toJson(o);
    System.out.println(json);
}