Ładne drukowanie kolekcji Java (toString nie zwraca ładnych wyników)

Chcę wydrukować Stack<Integer>obiekt tak ładnie, jak robi to debugger Eclipse (tj. [1,2,3...]), Ale wydrukowanie go za pomocą out = "output:" + stacknie zwraca tego miłego wyniku.

Dla wyjaśnienia mówię o wbudowanej kolekcji Java, więc nie mogę jej zastąpić toString().

Jak mogę uzyskać ładną wersję stosu do wydruku?

Możesz przekonwertować go na tablicę, a następnie wydrukować to za pomocą Arrays.toString(Object[]):

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

String.join(",", yourIterable);

(Java 8)

Dzięki strumieniom i kolektorom Java 8 można to łatwo zrobić:

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

najpierw używamy mapz Object::toStringdo tworzenia, Collection<String>a następnie używamy łączenia kolekcjonera, aby łączyć każdy element w kolekcji ,jako separator.

Klasa MapUtils oferowana przez projekt Apache Commons oferuje MapUtils.debugPrintmetodę, która całkiem wydrukuje twoją mapę.

System.out.println (kolekcja c) już drukuje dowolny typ kolekcji w czytelnym formacie. Tylko jeśli kolekcja zawiera obiekty zdefiniowane przez użytkownika, należy zaimplementować metodę toString () w klasie zdefiniowanej przez użytkownika, aby wyświetlić zawartość.

Zaimplementuj toString () w klasie.

Polecam Apache Commons ToStringBuilder, aby to ułatwić. Dzięki temu wystarczy napisać ten rodzaj metody:

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

Aby uzyskać tego rodzaju dane wyjściowe:

Osoba @ 7f54 [imię = Stephen, wiek = 29]

Istnieje również refleksyjne wdrożenie .

Guawa wygląda na dobrą opcję:

Iterables.toString(myIterable)

Zgadzam się z powyższymi komentarzami na temat przesłonięcia toString()własnych klas (i na temat automatyzacji tego procesu w jak największym stopniu).

W przypadku klas, których nie zdefiniowałeś, możesz napisać ToStringHelperklasę z przeciążoną metodą dla każdej klasy biblioteki, którą chcesz obsługiwać według własnych upodobań:

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

EDYCJA: Odpowiadając na komentarz xukxpvfzflbbld, oto możliwe wdrożenie dla wyżej wymienionych przypadków.

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

}

To nie jest pełna implementacja, ale tylko starter.

Możesz użyć klasy „Objects” z JAVA (która jest dostępna od 1.7)

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

Wyjście: 1273, 123, 876, 897

Inną możliwością jest użycie klasy „MoreObjects” od Google Guave , która zapewnia wiele przydatnych funkcji pomocniczych:

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

Dane wyjściowe: NameOfYourObject = [1273, 123, 876, 897]

Dokumenty Guava

Z Apache Commons 3 chcesz zadzwonić

StringUtils.join(myCollection, ",")

W Javie 8

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

lub

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

Właśnie zmodyfikowałem poprzedni przykład, aby wydrukować nawet kolekcję zawierającą obiekty zdefiniowane przez użytkownika.

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

}

obecnie większość kolekcji jest przydatna toString()w Javie (Java 7/8). Nie ma więc potrzeby wykonywania operacji strumieniowych w celu konkatenacji tego, czego potrzebujesz, wystarczy zastąpić toStringklasę wartości w kolekcji i uzyskać to, czego potrzebujesz.

zarówno AbstractMap, jak i AbstractCollection implementują toString (), wywołując toString dla każdego elementu.

poniżej znajduje się klasa testowa pokazująca zachowanie.

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

Alternatywnym rozwiązaniem może być konwersja kolekcji w formacie JSON i wydrukowanie ciągu Json. Zaletą jest dobrze sformatowany i czytelny ciąg obiektowy bez potrzeby implementowania toString().

Przykład korzystania z 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);
}

Jeśli jest to Twoja własna klasa kolekcji, a nie wbudowana, musisz przesłonić jej metodę toString. Eclipse wywołuje tę funkcję dla wszystkich obiektów, dla których nie ma wbudowanego formatowania.

Zachowaj ostrożność, dzwoniąc do Sop na Collection, może rzucić ConcurrentModificationwyjątek. Ponieważ wewnętrznie toStringmetoda każdej kolekcji wywołuje wewnętrznie Iteratorkolekcję.

Powinien działać z każdą kolekcją oprócz Map, ale jest również łatwy do obsługi. W razie potrzeby zmodyfikuj kod, aby przekazać te 3 znaki jako argumenty.

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

Możesz spróbować użyć

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

Istnieją dwa sposoby uproszczenia pracy. 1. zaimportuj bibliotekę Gson. 2. użyj Lombok.

Oba z nich pomagają stworzyć String z instancji obiektu. Gson parsuje twój obiekt, lombok zastąpi twój obiekt klasy na metodę Strings.

Podaję przykład Gson prettyPrint, tworzę klasę pomocniczą do drukowania obiektów i kolekcji obiektów. Jeśli używasz lombok, możesz oznaczyć swoją klasę jako @ToString i wydrukować swój obiekt bezpośrednio.

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

}