Stampare correttamente le raccolte Java (toString non restituisce un output discreto)

Vorrei stampare un Stack<Integer>oggetto esattamente come fa il debugger di Eclipse (ovvero [1,2,3...]) ma stamparlo con out = "output:" + stacknon restituisce questo bel risultato.

Giusto per chiarire, sto parlando della collezione integrata di Java, quindi non posso ignorarla toString().

Come posso ottenere una bella versione stampabile dello stack?

È possibile convertirlo in un array e quindi stamparlo con Arrays.toString(Object[]):

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

String.join(",", yourIterable);

(Java 8)

Con java 8 stream e collezionisti si può fare facilmente:

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

prima usiamo mapconObject::toString per creare Collection<String>e poi uniamo il raccoglitore per unire ogni elemento della raccolta ,come delimitatore.

La classe MapUtils offerta dal progetto Apache Commons offre un MapUtils.debugPrintmetodo che stamperà la tua mappa.

System.out.println (Collection c) stampa già qualsiasi tipo di raccolta in formato leggibile. Solo se la raccolta contiene oggetti definiti dall'utente, è necessario implementare toString () nella classe definita dall'utente per visualizzare il contenuto.

Implementare toString () sulla classe.

Raccomando Apache Commons ToStringBuilder per rendere tutto più semplice. Con esso, devi solo scrivere questo tipo di metodo:

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

Per ottenere questo tipo di output:

Person @ 7f54 [name = Stephen, età = 29]

C'è anche un'implementazione riflessiva .

Guava sembra una buona opzione:

Iterables.toString(myIterable)

Concordo con i commenti di cui sopra sulla sostituzione toString()delle proprie classi (e sull'automazione di tale processo il più possibile).

Per le classi che non hai definito, potresti scrivere una ToStringHelperclasse con un metodo sovraccarico per ogni classe di libreria che desideri gestire secondo i tuoi gusti:

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

EDIT: rispondendo al commento di xukxpvfzflbbld, ecco una possibile implementazione per i casi menzionati in precedenza.

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

}

Questa non è un'implementazione completa, ma solo un antipasto.

Puoi usare la classe "Oggetti" di JAVA (che è disponibile dall'1.7)

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

Uscita: 1273, 123, 876, 897

Un'altra possibilità è quella di utilizzare la classe "MoreObjects" di Google Guave , che fornisce molte utili funzioni di supporto:

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

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

Documenti di guava

Con Apache Commons 3 , vuoi chiamare

StringUtils.join(myCollection, ",")

In Java8

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

o

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

È stato appena modificato l'esempio precedente per stampare anche la raccolta contenente oggetti definiti dall'utente.

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

}

la maggior parte delle raccolte ha un utile toString()in Java in questi giorni (Java7 / 8). Quindi non è necessario eseguire operazioni di streaming per concatenare ciò di cui hai bisogno, basta eseguire l'overridetoString tua classe di valore nella raccolta e ottenere ciò di cui hai bisogno.

sia AbstractMap che AbstractCollection implementano toString () chiamando toString per elemento.

di seguito è una lezione di prova per mostrare il comportamento.

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

Una soluzione alternativa potrebbe essere la conversione della raccolta nel formato JSON e la stampa della stringa Json. Il vantaggio è una stringa di oggetti ben formattata e leggibile senza la necessità di implementare toString().

Esempio usando Gson di 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);
}

Se questa è la tua classe di raccolta piuttosto che una incorporata, devi sovrascriverne il metodo toString. Eclipse chiama quella funzione per tutti gli oggetti per i quali non ha una formattazione cablata.

Fai attenzione quando chiami Sop su Collection, può generare ConcurrentModificationun'eccezione. Perché il toStringmetodo interno di ogni Collezione chiama internamente Iteratorla Collezione.

Dovrebbe funzionare per qualsiasi raccolta tranne Map, ma è anche facile da supportare. Modificare il codice per passare questi 3 caratteri come argomenti, se necessario.

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

Puoi provare a usare

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

Esistono due modi per semplificare il tuo lavoro. 1. importare la libreria Gson. 2. usa Lombok.

Entrambi aiutano a creare String dall'istanza dell'oggetto. Gson analizzerà il tuo oggetto, lombok sovrascriverà il tuo oggetto di classe sul metodo String.

Ho messo un esempio su Gson prettyPrint, creo una classe di supporto per stampare oggetti e raccolte di oggetti. Se stai usando lombok, puoi contrassegnare la tua classe come @ToString e stampare direttamente il tuo oggetto.

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

}