漂亮地打印Java集合（toString不会返回漂亮的输出）
我希望像Eclipse调试器一样漂亮地打印漂亮地打印Java集合（toString不会返回漂亮的输出）,java,debugging,pretty-print,Java,Debugging,Pretty Print,我希望像Eclipse调试器一样漂亮地打印Stack对象（即[1,2,3…]），但使用out=“output:“+Stack打印它不会返回这个好结果 我只是想澄清一下，我说的是Java的内置集合，所以我不能覆盖它的toString（） 如何获得一个好的可打印版本的堆栈？您可以将其转换为数组，然后使用数组打印出来。toString（Object[]）： 如果这是您自己的集合类而不是内置的集合类，则需要重写其toString方法。Eclipse为其没有硬连线格式的任何对象调用该函数。在类上实现toS
Stack[1,2,3…]out=“output:“+StacktoString（）如何获得一个好的可打印版本的堆栈？您可以将其转换为数组，然后使用
数组打印出来。toString（Object[]）如果这是您自己的集合类而不是内置的集合类，则需要重写其toString方法。Eclipse为其没有硬连线格式的任何对象调用该函数。在类上实现toString（） 我建议您使用更简单的方法。使用它，您只需编写这种方法：
public String toString() {
return new ToStringBuilder(this).
append("name", name).
append("age", age).
toString();
}
还有一个问题。我同意上面关于在您自己的类上重写
toString（）ToStringHelperpublic 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.
}
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();
}
}
package com.so.demos；
导入java.util.List；
导入java.util.Map；
导入java.util.Set；
公共类ToStringHelper{
专用字符串分隔符；
私有字符串箭头；
public-ToString-Helper（字符串分隔符、字符串箭头）{
this.separator=分隔符；
这个箭头=箭头；
}
公共字符串toString（列表l）{
StringBuilder sb=新的StringBuilder（“”）；
字符串sep=“”；
用于（对象：l）{
sb.append（sep.append（object.toString（））；
sep=分离器；
}
返回某人。追加（“）”。toString（）；
}
公共字符串到字符串（映射m）{
StringBuilder sb=新的StringBuilder（“[”）；
字符串sep=“”；
对于（对象：m.keySet（））{
某人（九月）
.append（object.toString（））
.append（箭头）
.append（m.get（object.toString（））；
sep=分离器；
}
返回sb.append（“]”）.toString（）；
}
公共字符串到字符串（集合s）{
StringBuilder sb=新的StringBuilder（“{”）；
字符串sep=“”；
用于（对象：s）{
sb.append（sep.append（object.toString（））；
sep=分离器；
}
返回sb.append（“}”）.toString（）；
}
}
这不是一个完整的实现，只是一个开始。System.out.println（Collection c）已经以可读的格式打印了任何类型的集合。只有当集合包含用户定义的对象时，才需要在用户定义的类中实现toString（），以显示内容。刚刚修改了前面的示例，以打印包含用户定义对象的集合
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));
}
}
public类到stringhelper{
专用静态字符串分隔符=“\n”；
公用串分离器（串分离器）{
超级（）；
ToStringHelper.分离器=分离器；
}
公共静态字符串toString（列表l）{
StringBuilder sb=新的StringBuilder（）；
字符串sep=“”；
用于（对象：l）{
String v=ToStringBuilder.reflectionString（对象）；
int start=v.indexOf（“[”）；
int end=v.indexOf（“]”）；
字符串st=v.子字符串（开始、结束+1）；
某人附加（九月）附加（九月）；
sep=分离器；
}
使某人返回字符串（）；
}
公共静态字符串到字符串（映射m）{
StringBuilder sb=新的StringBuilder（）；
字符串sep=“”；
对于（对象：m.keySet（））{
String v=ToStringBuilder.reflectionString（m.get（object））；
int start=v.indexOf（“[”）；
int end=v.indexOf（“]”）；
字符串st=v.子字符串（开始、结束+1）；
某人附加（九月）附加（九月）；
sep=分离器；
}
使某人返回字符串（）；
}
公共静态字符串到字符串（集合s）{
StringBuilder sb=新的StringBuilder（）；
字符串sep=“”；
用于（对象：s）{
String v=ToStringBuilder.reflectionString（对象）；
int start=v.indexOf（“[”）；
int end=v.indexOf（“]”）；
字符串st=v.子字符串（开始、结束+1）；
某人附加（九月）附加（九月）；
sep=分离器；
}
使某人返回字符串（）；
}
公共静态无效打印（列表l）{
System.out.println（toString（l））；
}
公共静态无效打印（地图m）{
System.out.println（toString（m））；
}
公共静态无效打印（套）{
System.out.println（toString（s））；
}
}
MapUtils.debugPrintConcurrentModificationtoString迭代器。应该适用于除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();
}
静态字符串seqToString（Iterable项）{
StringBuilder sb=新的StringBuilder（）；
某人附加（“[”）；
布尔值=false；
对于（T x：项目）{
如果（需要分隔符）
某人附加（“”）；
sb.append（x.toString（））；
needSeparator=true；
}
某人附加（']'）；
使某人返回字符串（）；
}
使用java 8流和收集器，它可以
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();
}
String format(Collection<?> c) {
String s = c.stream().map(Object::toString).collect(Collectors.joining(","));
return String.format("[%s]", s);
}
String.join(",", yourIterable);
//will prints each element line by line
stack.forEach(System.out::println);
//to print with commas
stack.forEach(
(ele) -> {
System.out.print(ele + ",");
}
);
org.apache.commons.lang3.builder.ToStringBuilder.reflectionToString(yourCollection);
Collection<String> myCollection = Arrays.asList("1273","123","876","897");
Objects.toString(myCollection);
MoreObjects.toStringHelper(this).add("NameOfYourObject", myCollection).toString());
StringUtils.join(myCollection, ",")
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 }}
}
}
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]}
}
}
@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(","));
}
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(' ');
}
}