Cómo imprimir todos los elementos de una Lista en Java?

Lo siguiente es compacto y evita el bucle en su código de ejemplo (y le da buenas comas):

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

Sin embargo, como otros han señalado, si no tienes implementados métodos toString() sensibles para los objetos dentro de la lista, obtendrás los punteros de objetos (códigos hash, de hecho) que estás observando. Esto es cierto si están en una lista o no.

Desde Java 8, List hereda un método predeterminado "forEach" que puede combinar con el sistema de referencia del método".out:: println " así:

list.forEach(System.out::println);

System.out.println(list);//toString() is easy and good enough for debugging.

toString() de AbstractCollection estará limpio y bastante fácil de hacer que. AbstractList es una subclase de AbstractCollection, así que no hay necesidad de for loop y no se necesita toArray ().

Devuelve una representación de cadena de esta colección. La representación de cadena consiste en una lista de los elementos de la colección orden en que son devueltos por su iterador, encerrados entre corchetes ("[]"). Los elementos adyacentes están separados por los caracteres", " (coma y espacio). Los elementos se convierten en cadenas como por Cadena.valueOf(Objeto).

Si está utilizando cualquier objeto personalizado en su lista, por ejemplo Student, necesita anular su método toString() (siempre es bueno anular este método) para tener una salida significativa

Vea el siguiente ejemplo:

public class TestPrintElements {

    public static void main(String[] args) {

        //Element is String, Integer,or other primitive type
        List<String> sList = new ArrayList<String>();
        sList.add("string1");
        sList.add("string2");
        System.out.println(sList);

        //Element is custom type
        Student st1=new Student(15,"Tom");
        Student st2=new Student(16,"Kate");
        List<Student> stList=new ArrayList<Student>();
        stList.add(st1);
        stList.add(st2);
        System.out.println(stList);
   }
}


public  class Student{
    private int age;
    private String name;

    public Student(int age, String name){
        this.age=age;
        this.name=name;
    }

    @Override
    public String toString(){
        return "student "+name+", age:" +age;
    }
}

Salida:

[string1, string2]
[student Tom age:15, student Kate age:16]

El enfoque Java 8 Streams...

list.stream().forEach(System.out::println);

Los objetos de la lista deben tener toString implementados para que impriman algo significativo en la pantalla.

Aquí hay una prueba rápida para ver las diferencias:

public class Test {

    public class T1 {
        public Integer x;
    }

    public class T2 {
        public Integer x;

        @Override
        public String toString() {
            return x.toString();
        }
    }

    public void run() {
        T1 t1 = new T1();
        t1.x = 5;
        System.out.println(t1);

        T2 t2 = new T2();
        t2.x = 5;
        System.out.println(t2);

    }

    public static void main(String[] args) {        
        new Test().run();
    }
}

Y cuando esto se ejecuta, los resultados impresos en la pantalla son:

t1 = Test$T1@19821f
t2 = 5

Dado que T1 no anula el método toString, su instancia t1 se imprime como algo que no es muy útil. Por otro lado, T2 anula toString, por lo que controlamos lo que imprime cuando se usa en E / S, y vemos algo un poco mejor en pantalla.

Usando las características de java 8.

import java.util.Arrays;
import java.util.List;

/**
 * @author AJMAL SHA
 *
 */
public class ForEach {

    public static void main(String[] args) {

        List<String> features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
        (features).forEach(System.out::println);

    }

}

Considere un List<String> stringList que se puede imprimir de muchas maneras usando construcciones Java 8 :

stringList.forEach(System.out::println);                            // 1) Iterable.forEach
stringList.stream().forEach(System.out::println);                   // 2) Stream.forEach (order maintained generally but doc does not guarantee)
stringList.stream().forEachOrdered(System.out::println);            // 3) Stream.forEachOrdered (order maintained always)
stringList.parallelStream().forEach(System.out::println);           // 4) Parallel version of Stream.forEach (order not maintained)
stringList.parallelStream().forEachOrdered(System.out::println);    // 5) Parallel version ofStream.forEachOrdered (order maintained always)

¿En qué se diferencian estos enfoques unos de otros?

Primer Enfoque (Iterable.forEach)- El iterador de la colección se usa generalmente y está diseñado para ser fail-fast lo que significa que lanzará ConcurrentModificationExceptionsi la colección subyacente está modificada estructuralmente durante la iteración. Como se menciona en el doc para ArrayList:

Una modificación estructural es cualquier operación que agrega o elimina una o más elementos, o redimensiona explícitamente la matriz de respaldo; simplemente estableciendo el valor de un elemento no es una modificación estructural.

Significa que para ArrayList.forEach establecer el valor se permite sin ningún problema. Y en caso de colección concurrente, por ejemplo, ConcurrentLinkedQueue el iterador sería débilmente consistente {[27] } lo que significa que las acciones pasadas en forEach se les permite hacer incluso cambios estructurales sin ConcurrentModificationException se lanza una excepción. Pero aquí las modificaciones podrían o no ser visibles en esa iteración.

Segundo Enfoque (Stream.forEach)- El orden no está definido. Aunque puede no ocurrir para secuencias secuenciales, la especificación no lo garantiza. También se requiere que la acción no interfiera en la naturaleza. Como se menciona en doc :

El comportamiento de esta operación es explícitamente no determinista. Para tuberías de flujo paralelo, esta operación no garantiza a respetar el orden de encuentro de la corriente, ya que hacerlo sacrificaría el beneficio del paralelismo.

Tercer Enfoque (Stream.forEachOrdered)- La acción se realizaría en el orden de encuentro de la corriente. Así que cuando el orden importa use forEachOrdered sin pensarlo dos veces. Como se menciona en el doc :

Realiza una acción para cada elemento de esta secuencia, en el encuentro orden de la corriente si la corriente tiene un orden de encuentro definido.

Mientras se itera sobre una colección sincronizada, el primer acercamiento tomaría el bloqueo de la colección una vez y lo mantendría en todas las llamadas al método de acción, pero en el caso de flujos utilizan el spliterador de la colección, que no se bloquea y se basa en las reglas ya establecidas de no interferencia. En caso de que la copia de respaldo de la colección se modifique durante la iteración, se lanzaría un ConcurrentModificationException o podría ocurrir un resultado inconsistente.

Cuarto Enfoque (Paralelo Stream.forEach)- Como ya se mencionó, no hay garantía de respetar el orden de encuentro como se espera en caso de corrientes paralelas. Es posible que la acción se realice en diferentes subprocesos para diferentes elementos que nunca puede ser el caso con forEachOrdered.

Quinto Enfoque (Paralelo Stream.forEachOrdered)- El forEachOrdered procesará los elementos en el orden especificado por la fuente independientemente del hecho de si el flujo es secuencial o paralelo. Así que no tiene sentido usar esto con flujos paralelos.

1. No ha especificado qué tipo de elementos contiene la lista, si es un tipo de datos primitivo entonces puede imprimir los elementos.

2. Pero si los elementos son objetos, entonces como Kshitij Mehta mencionó, debe implementar (anular) el método "toString" dentro de ese objeto, si no está ya implementado , y dejar que devuelva algo que significa completo desde dentro del objeto, ejemplo:

   class Person {
       private String firstName;
       private String lastName;
   
       @Override
       public String toString() {
           return this.firstName + " " + this.lastName;
       }
   }
   

O simplemente podría usar las utilidades Apache Commons:

Https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/ArrayUtils.html#toString-java.lang.Object-

List<MyObject> myObjects = ...
System.out.println(ArrayUtils.toString(myObjects));

Escribí una función de volcado, que básicamente imprime los miembros públicos de un objeto si no ha anulado toString(). Uno podría expandirlo fácilmente para llamar a los captadores. Javadoc:

Vuelca un Objeto dado al Sistema.fuera, usando las siguientes reglas:

• Si el objeto es iterable, todos sus componentes son volcados.
• Si el Objeto o una de sus superclases anula toString (), el" toString " es volcado
• De lo contrario el método se llama recursivamente para todos los miembros públicos del Objeto

/**
 * Dumps an given Object to System.out, using the following rules:<br>
 * <ul>
 * <li> If the Object is {@link Iterable}, all of its components are dumped.</li>
 * <li> If the Object or one of its superclasses overrides {@link #toString()}, the "toString" is dumped</li>
 * <li> Else the method is called recursively for all public members of the Object </li>
 * </ul>
 * @param input
 * @throws Exception
 */
public static void dump(Object input) throws Exception{
    dump(input, 0);
}

private static void dump(Object input, int depth) throws Exception{
    if(input==null){
        System.out.print("null\n"+indent(depth));
        return;
    }

    Class<? extends Object> clazz = input.getClass();
    System.out.print(clazz.getSimpleName()+" ");
    if(input instanceof Iterable<?>){
        for(Object o: ((Iterable<?>)input)){
            System.out.print("\n"+indent(depth+1));
            dump(o, depth+1);
        }
    }else if(clazz.getMethod("toString").getDeclaringClass().equals(Object.class)){
        Field[] fields = clazz.getFields();
        if(fields.length == 0){
            System.out.print(input+"\n"+indent(depth));
        }
        System.out.print("\n"+indent(depth+1));
        for(Field field: fields){
            Object o = field.get(input);
            String s = "|- "+field.getName()+": ";
            System.out.print(s);
            dump(o, depth+1);
        }
    }else{

        System.out.print(input+"\n"+indent(depth));
    }
}

private static String indent(int depth) {
    StringBuilder sb = new StringBuilder();
    for(int i=0; i<depth; i++)
        sb.append("  ");
    return sb.toString();
}

System.out.println(list); funciona para mí.

Aquí hay un ejemplo completo:

import java.util.List;    
import java.util.ArrayList;

public class HelloWorld {
     public static void main(String[] args) {
        final List<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("World");
        System.out.println(list);
     }
}

Se imprimirá [Hello, World].

    list.stream().map(x -> x.getName()).forEach(System.out::println);

Para una lista de matriz de cadena

list.forEach(s -> System.out.println(Arrays.toString((String[]) s )));

Intenta sobrescribir el método toString() ya que quieres que el elemento sea printend. así que el método para imprimir puede ser este:

for(int i=0;i<list.size();i++){
    System.out.println(list.get(i).toString());
} 

Ahora estoy trabajando en esto...

List<Integer> a = Arrays.asList(1, 2, 3);
List<Integer> b = Arrays.asList(3, 4);
List<int[]> pairs = a.stream()
  .flatMap(x -> b.stream().map(y -> new int[]{x, y}))
  .collect(Collectors.toList());

Consumer<int[]> pretty = xs -> System.out.printf("\n(%d,%d)", xs[0], xs[1]);
pairs.forEach(pretty);

   List<String> textList=  messageList.stream()
                            .map(Message::getText)
                            .collect(Collectors.toList());

        textList.stream().forEach(System.out::println);
        public class Message  {

        String name;
        String text;

        public Message(String name, String text) {
            this.name = name;
            this.text = text;
        }

        public String getName() {
            return name;
        }

      public String getText() {
        return text;
     }
   }

public static void main(String[] args) {
        answer(10,60);

    }
    public static void answer(int m,int k){
        AtomicInteger n = new AtomicInteger(m);
        Stream<Integer> stream = Stream.generate(() -> n.incrementAndGet()).limit(k);
        System.out.println(Arrays.toString(stream.toArray()));
    }