Impresión de colecciones de Java de forma agradable (toString no devuelve resultados bonitos)

Deseo imprimir un Stack<Integer>objeto tan bien como lo hace el depurador Eclipse (es decir [1,2,3...]), pero imprimirlo out = "output:" + stackno devuelve este buen resultado.

Solo para aclarar, estoy hablando de la colección incorporada de Java, así que no puedo anularla toString().

¿Cómo puedo obtener una buena versión imprimible de la pila?

Puede convertirlo en una matriz y luego imprimirlo con Arrays.toString(Object[]):

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

String.join(",", yourIterable);

(Java 8)

Con java 8 streams y recopiladores se puede hacer fácilmente:

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

primero usamos mapcon Object::toStringpara crear Collection<String>y luego usamos unir colector para unir cada elemento de la colección con un ,delimitador.

La clase MapUtils ofrecida por el proyecto Apache Commons ofrece un MapUtils.debugPrintmétodo que imprimirá bastante su mapa.

System.out.println (Colección c) ya imprime cualquier tipo de colección en formato legible. Solo si la colección contiene objetos definidos por el usuario, debe implementar toString () en la clase definida por el usuario para mostrar el contenido.

Implemente toString () en la clase.

Recomiendo el Apache Commons ToStringBuilder para hacer esto más fácil. Con él, solo tienes que escribir este tipo de método:

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

Para obtener este tipo de salida:

Persona @ 7f54 [nombre = Stephen, edad = 29]

También hay una implementación reflexiva .

La guayaba parece una buena opción:

Iterables.toString(myIterable)

Estoy de acuerdo con los comentarios anteriores sobre anular toString()en sus propias clases (y sobre automatizar ese proceso tanto como sea posible).

Para las clases que no definió, puede escribir una ToStringHelperclase con un método sobrecargado para cada clase de biblioteca que desee manejar según sus propios gustos:

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

EDITAR: respondiendo al comentario de xukxpvfzflbbld, aquí hay una posible implementación para los casos mencionados anteriormente.

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

}

Esta no es una implementación completa, sino solo un comienzo.

Puede usar la clase "Objetos" de JAVA (que está disponible desde 1.7)

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

Salida: 1273, 123, 876, 897

Otra posibilidad es usar la clase "MoreObjects" de Google Guave , que proporciona muchas funciones útiles de ayuda:

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

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

Documentos de guayaba

Con Apache Commons 3 , quieres llamar

StringUtils.join(myCollection, ",")

En 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 + ",");
    }
);

Acaba de modificar el ejemplo anterior para imprimir incluso colecciones que contienen objetos definidos por el usuario.

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 mayoría de las colecciones tienen una utilidad toString()en Java en estos días (Java7 / 8). Por lo tanto, no es necesario realizar operaciones continuas para concatenar lo que necesita, simplemente anule toStringsu clase de valor en la colección y obtendrá lo que necesita.

tanto AbstractMap y AbstractCollection implementan toString () llamando a toString por elemento.

a continuación hay una clase de prueba para mostrar el comportamiento.

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 solución alternativa podría ser convertir su colección en formato JSON e imprimir Json-String. La ventaja es un Object-String bien formateado y legible sin necesidad de implementar el toString().

Ejemplo usando el Gson de 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);
}

Si esta es su propia clase de colección en lugar de una clase integrada, debe anular su método toString. Eclipse llama a esa función para cualquier objeto para el que no tiene un formato cableado.

Tenga cuidado al llamar a Sop en Collection, puede lanzar ConcurrentModificationException. Porque el toStringmétodo interno de cada Colección internamente llama Iteratora la Colección.

Debería funcionar para cualquier colección excepto Map, pero también es fácil de soportar. Modifique el código para pasar estos 3 caracteres como argumentos si es necesario.

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

Puedes intentar usar

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

Hay dos formas de simplificar su trabajo. 1. importar la biblioteca de Gson. 2. usa Lombok.

Ambos te ayudan a crear String desde la instancia del objeto. Gson analizará su objeto, lombok anulará su objeto de clase al método String.

Pongo un ejemplo sobre Gson prettyPrint, creo una clase auxiliar para imprimir objetos y colecciones de objetos. Si está utilizando lombok, puede marcar su clase como @ToString e imprimir su objeto directamente.

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

}