Comment imprimer tous les éléments d'une liste en Java?

Ce qui suit est compact et évite la boucle dans votre exemple de code (et vous donne de belles virgules):

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

Cependant, comme d'autres l'ont souligné, si vous n'avez pas de méthodes toString() sensées implémentées pour les objets à l'intérieur de la liste, vous obtiendrez les pointeurs d'objets (codes de hachage, en fait) que vous observez. Cela est vrai qu'ils soient dans une liste ou non.

Depuis Java 8, List hérite d'une méthode par défaut "forEach" que vous pouvez combiner avec la référence de méthode "System.out::println", comme ceci:

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

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

toString() de AbstractCollection sera propre et assez facile à faire que. AbstractList est une sous-classe de AbstractCollection, donc pas besoin de boucle et pas de toArray() est nécessaire.

Renvoie une représentation de chaîne de cette collection. La représentation de chaîne consiste en une liste des éléments de la collection dans le ordre ils sont retournés par son itérateur, entre crochets ("[]"). Les éléments adjacents sont séparés par les caractères", " (virgule et espace). Les éléments sont convertis en chaînes comme par Chaîne.valueOf (Objet).

Si vous utilisez un objet personnalisé dans votre liste, par exemple Student, vous devez remplacer sa méthode toString() (il est toujours bon de remplacer cette méthode) pour avoir une sortie significative

Voir l'exemple ci-dessous:

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

Sortie:

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

L'approche des flux Java 8...

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

Les objets de la liste doivent avoir toString implémenté pour qu'ils impriment quelque chose de significatif à l'écran.

Voici un test rapide pour voir les différences:

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

Et lorsque cela s'exécute, les résultats imprimés à l'écran sont:

t1 = Test$T1@19821f
t2 = 5

Puisque T1 ne remplace pas la méthode toString, son instance t1 s'imprime comme quelque chose qui n'est pas très utile. D'autre part, T2 remplace toString, nous contrôlons donc ce qu'il imprime lorsqu'il est utilisé dans les E / S,et nous voyons quelque chose d'un peu mieux sur l'écran.

En utilisant les fonctionnalités 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);

    }

}

Considérons un List<String> stringList qui peut être imprimé de plusieurs façons en utilisant Java 8 constructions:

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 quoi ces approches sont-elles différentes les unes des autres?

Première Approche (Iterable.forEach)- L'itérateur de la collection est généralement utilisé et est conçu pour être fail-fast , ce qui signifie qu'il lancera ConcurrentModificationException si la collection sous-jacente est structurellement modifiée pendant l'itération. Comme mentionné dans le doc pour ArrayList:

Une modification structurelle est une opération qui ajoute ou supprime un ou plus d'éléments, ou redimensionne explicitement le tableau de sauvegarde; simplement définir la valeur d'un élément n'est pas une modification structurelle.

Cela signifie donc que pour ArrayList.forEach la définition de la valeur est autorisée sans aucun problème. Et en cas de collecte simultanée, par exemple ConcurrentLinkedQueue, l'itérateur serait faiblement cohérent , ce qui signifie que les actions passées dans forEach sont autorisées à apporter même des changements structurels sans ConcurrentModificationExceptionexception levée. Mais ici, les modifications peuvent ou non être visibles dans cette itération.

Deuxième Approche (Stream.forEach)- L'ordre n'est pas défini. Bien que cela ne puisse pas se produire pour les flux séquentiels, la spécification ne le garantit pas. En outre, l'action doit être de nature non interférente. Comme mentionné dans doc:

Le comportement de cette opération est explicitement non déterministe. Pour pipelines de flux parallèles, cette opération ne garantit pas à respectez l'ordre de rencontre du courant, car cela sacrifierait l'avantage du parallélisme.

Troisième Approche (Stream.forEachOrdered)- L'action serait effectuée dans l'ordre de rencontre du flux. Donc, chaque fois que l'ordre compte, utilisez forEachOrdered sans une seconde pensée. Comme mentionné dans le doc:

Effectue une action pour chaque élément de ce flux, dans la rencontre ordre du flux si le flux a ordre de rencontre défini.

En itérant sur une collection synchronisée la première approche prendrait le verrou de la collection une fois et le maintiendrait sur toutes les méthodes d'appels à l'action, mais dans le cas des flux, ils utilisent le spliterator de la collection, qui ne verrouille pas et s'appuie sur les règles de non-interférence déjà établies. Dans le cas où la collection sauvegardant le flux est modifiée pendant l'itération, un ConcurrentModificationException serait lancé ou un résultat incohérent pourrait se produire.

Quatrième Approche (Parallèle Stream.forEach)- Comme déjà mentionné aucune garantie de respecter l'ordre de rencontre comme prévu en cas de flux parallèles. Il est possible que l'action soit effectuée dans un thread différent pour différents éléments, ce qui ne peut jamais être le cas avec forEachOrdered.

Cinquième Approche (Parallèle Stream.forEachOrdered)- Le forEachOrdered traitera les éléments dans l'ordre spécifié par la source indépendamment du fait que le flux soit séquentiel ou parallèle. De sorte qu'il cela n'a aucun sens de l'utiliser avec des flux parallèles.

1. Vous n'avez pas spécifié quel type d'éléments la liste contient, s'il s'agit d'un type de données primitif , vous pouvez imprimer les éléments.

2. Mais si les éléments sont des objets, alors comme Kshitij Mehta l'a mentionné, vous devez implémenter (remplacer) la méthode "toString" dans cet objet - si elle n'est pas déjà implémentée-et la laisser renvoyer quelque chose de signifiant à partir de l'objet, exemple:

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

Ou vous pouvez simplement utiliser les utilitaires 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));

J'ai écrit une fonction de vidage, qui imprime fondamentalement les membres publics d'un objet s'il n'a pas remplacé toString(). On pourrait facilement l'étendre pour appeler getters. Jadoc:

Vide un objet donné dans le système.en utilisant les règles suivantes:

• Si l'objet est Itérable, tous ses composants sont vidés.
• Si l'objet ou l'une de ses superclasses remplace toString (), le" toString " est vidé
• , Sinon la méthode est appelée récursivement pour tous les membres publics de l'objet

/**
 * 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); ça marche pour moi.

Voici un exemple complet:

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

Il imprimera [Hello, World].

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

Pour une liste de tableau de chaîne

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

Essayez de remplacer la méthode toString() comme vous voulez que l'élément soit printend. donc, la méthode d'impression peut être ceci:

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

Il se trouve que je travaille là-dessus maintenant...

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