Java-Sammlungen gut drucken (toString liefert keine hübsche Ausgabe)

Ich möchte ein Stack<Integer>Objekt so schön drucken wie der Eclipse-Debugger (dh [1,2,3...]), aber das Drucken mit out = "output:" + stackliefert nicht dieses schöne Ergebnis.

Zur Verdeutlichung spreche ich von Javas integrierter Sammlung, damit ich sie nicht überschreiben kann toString().

Wie kann ich eine schöne druckbare Version des Stapels erhalten?

Sie können es in ein Array konvertieren und dann ausdrucken mit Arrays.toString(Object[]):

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

String.join(",", yourIterable);

(Java 8)

Mit Java 8 Streams und Sammlern geht das ganz einfach:

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

Zuerst verwenden wir mapmit Object::toString, um Collection<String>einen Join-Collector zu erstellen, und verwenden dann Joining Collector, um jedes Element in der Sammlung mit einem ,Trennzeichen zu verbinden.

Die vom Apache Commons-Projekt angebotene MapUtils-Klasse bietet eine MapUtils.debugPrintMethode, mit der Ihre Karte hübsch gedruckt werden kann.

System.out.println (Sammlung c) druckt bereits jede Art von Sammlung in lesbarem Format. Nur wenn die Sammlung benutzerdefinierte Objekte enthält, müssen Sie toString () in einer benutzerdefinierten Klasse implementieren, um Inhalte anzuzeigen.

Implementieren Sie toString () in der Klasse.

Ich empfehle den Apache Commons ToStringBuilder , um dies zu vereinfachen. Damit müssen Sie nur diese Art von Methode schreiben:

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

Um diese Art von Ausgabe zu erhalten:

Person @ 7f54 [Name = Stephen, Alter = 29]

Es gibt auch eine reflektierende Implementierung .

Guave sieht nach einer guten Option aus:

Iterables.toString(myIterable)

Ich stimme den obigen Kommentaren zum Überschreiben toString()Ihrer eigenen Klassen zu (und zur weitestgehenden Automatisierung dieses Prozesses).

Für Klassen, die Sie nicht definiert haben, können Sie ToStringHelperfür jede Bibliotheksklasse, die Sie nach Ihrem Geschmack behandeln möchten , eine Klasse mit einer überladenen Methode schreiben :

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.
}

BEARBEITEN: Als Antwort auf den Kommentar von xukxpvfzflbbld ist hier eine mögliche Implementierung für die zuvor genannten Fälle.

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

}

Dies ist keine vollständige Implementierung, sondern nur ein Anfang.

Sie können die Klasse "Objekte" von JAVA verwenden (verfügbar seit 1.7).

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

Ausgabe: 1273, 123, 876, 897

Eine andere Möglichkeit ist die Verwendung der Klasse "MoreObjects" von Google Guave , die viele nützliche Hilfsfunktionen bietet:

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

Ausgabe: NameOfYourObject = [1273, 123, 876, 897]

Guavendokumente

Mit Apache Commons 3 möchten Sie anrufen

StringUtils.join(myCollection, ",")

In Java8

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

oder

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

Das vorherige Beispiel wurde so geändert, dass sogar eine Sammlung mit benutzerdefinierten Objekten gedruckt wird.

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

}

Die meisten Sammlungen haben toString()heutzutage eine nützliche Java-Version (Java7 / 8). Sie müssen also keine Stream-Vorgänge ausführen, um das zu verketten, was Sie benötigen. Überschreiben Sie einfach toStringIhre Wertklasse in der Sammlung, und Sie erhalten das, was Sie benötigen.

Sowohl AbstractMap als auch AbstractCollection implementieren toString (), indem sie toString pro Element aufrufen.

Unten finden Sie eine Testklasse, um das Verhalten zu zeigen.

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 }}
  }
}

JSON

Eine alternative Lösung könnte darin bestehen, Ihre Sammlung in das JSON- Format zu konvertieren und den Json-String zu drucken. Der Vorteil ist ein gut formatierter und lesbarer Object-String, ohne dass der implementiert werden muss toString().

Beispiel mit Gson von Google :

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

Wenn dies Ihre eigene Auflistungsklasse ist und keine eingebaute, müssen Sie die toString-Methode überschreiben. Eclipse ruft diese Funktion für alle Objekte auf, für die es keine fest verdrahtete Formatierung gibt.

Seien Sie vorsichtig, wenn Sie Sop on Collection aufrufen, da dies eine ConcurrentModificationAusnahme auslösen kann . Weil die interne toStringMethode jeder Sammlung die Sammlung intern aufruft Iterator.

Sollte für jede Sammlung funktionieren, außer Map, aber es ist auch einfach zu unterstützen. Ändern Sie den Code, um diese 3 Zeichen bei Bedarf als Argumente zu übergeben.

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

Sie können versuchen, mit

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

Es gibt zwei Möglichkeiten, wie Sie Ihre Arbeit vereinfachen können. 1. Importieren Sie die Gson-Bibliothek. 2. Verwenden Sie Lombok.

Beide helfen Ihnen beim Erstellen eines Strings aus einer Objektinstanz. Gson analysiert Ihr Objekt, lombok überschreibt Ihr Klassenobjekt in der String-Methode.

Ich habe ein Beispiel für Gson PrettyPrint gegeben. Ich erstelle eine Hilfsklasse zum Drucken von Objekten und zum Sammeln von Objekten. Wenn Sie Lombok verwenden, können Sie Ihre Klasse als @ToString markieren und Ihr Objekt direkt drucken.

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

}}