it-swarm.com.de

Wie kann man alle Elemente einer Liste in Java ausdrucken?

Ich versuche, alle Elemente einer List auszudrucken, es wird jedoch der Zeiger der Object und nicht der Wert gedruckt.

Das ist mein Druckcode ...

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

Könnte mir bitte jemand helfen, warum der Wert der Elemente nicht gedruckt wird?.

182
user1335361

Hier ein Beispiel zum Ausdrucken der Listenkomponente:

public class ListExample {

    public static void main(String[] args) {
        List<Model> models = new ArrayList<>();

        // TODO: First create your model and add to models ArrayList, to prevent NullPointerException for trying this example

        // Print the name from the list....
        for(Model model : models) {
            System.out.println(model.getName());
        }

        // Or like this...
        for(int i = 0; i < models.size(); i++) {
            System.out.println(models.get(i).getName());
        }
    }
}

class Model {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
98
Crazenezz

Folgendes ist kompakt und vermeidet die Schleife in Ihrem Beispielcode (und gibt Ihnen schöne Kommas):

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

Wie andere jedoch hervorgehoben haben, erhalten Sie die Objektzeiger (Hash-Codes), die Sie beobachten, wenn Sie keine vernünftigen toString () - Methoden für die Objekte in der Liste implementiert haben. Dies gilt unabhängig davon, ob sie in einer Liste sind oder nicht.

378
Holly Cummins

Seit Java 8 erbt List eine Standardmethode "forEach", die Sie mit der Methodenreferenz "System.out :: println" wie folgt kombinieren können:

list.forEach(System.out::println);
85
Karsten Hahn
System.out.println(list);//toString() is easy and good enough for debugging.

toString() of AbstractCollection ist sauber und leicht genug, um das zu tun. AbstractList ist eine Unterklasse von AbstractCollection, also keine Notwendigkeit für eine Schleife und kein toArray ().

Gibt eine Zeichenfolgendarstellung dieser Auflistung zurück. Die Zeichenfolgendarstellung besteht aus einer Liste der Elemente der Sammlung in der Sie werden von ihrem Iterator in eckigen Klammern angegeben ("[]"). Benachbarte Elemente werden durch die Zeichen "," (Komma Und Leerzeichen) getrennt. Elemente werden wie von .__ in Strings konvertiert. String.valueOf (Objekt).

Wenn Sie ein benutzerdefiniertes Objekt in Ihrer Liste verwenden, beispielsweise Student, müssen Sie seine toString()-Methode überschreiben (es ist immer gut, diese Methode zu überschreiben), um eine sinnvolle Ausgabe zu erhalten

Siehe folgendes Beispiel:

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

ausgabe:

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

Der Ansatz von Java 8 Streams ...

list.stream().forEach(System.out::println);
18
Bradley D

Die Objekte in der Liste müssen toString implementiert haben, damit sie etwas aussagekräftiges für den Bildschirm drucken können.

Hier ist ein kurzer Test, um die Unterschiede zu sehen:

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

Wenn dies ausgeführt wird, werden die auf dem Bildschirm angezeigten Ergebnisse angezeigt:

t1 = [email protected]
t2 = 5

Da T1 die toString-Methode nicht überschreibt, wird ihre Instanz t1 als etwas ausgegeben, das nicht sehr nützlich ist. Auf der anderen Seite überschreibt T2 toString, sodass wir kontrollieren können, was gedruckt wird, wenn es in E/A verwendet wird. Auf dem Bildschirm sehen wir etwas besseres.

14
K Mehta

Durch die Verwendung von Java 8-Funktionen.

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

    }

}
8
Ajmal sha

Betrachten Sie einen List<String> stringList, der mit Java 8-Konstrukten auf viele Arten gedruckt werden kann:

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)

Wie unterscheiden sich diese Ansätze voneinander?

Erster Ansatz (Iterable.forEach) - Der Iterator der Sammlung wird im Allgemeinen verwendet und ist als Fail-Fast konzipiert. Dies bedeutet, dass ConcurrentModificationException ausgegeben wird, wenn die zugrunde liegende Sammlung strukturell während der Iteration. Wie in doc für ArrayList erwähnt:

Eine strukturelle Änderung ist eine Operation, die eine oder .__ hinzufügt oder löscht. mehr Elemente oder ändert die Größe des Hintergrundarrays explizit; nur Einstellung Der Wert eines Elements ist keine strukturelle Änderung.

Das bedeutet, dass für die Einstellung von ArrayList.forEach der Wert ohne Probleme zulässig ist. Und im Falle einer gleichzeitigen Sammlung, z. ConcurrentLinkedQueue der Iterator wäre schwach konsistent , was bedeutet, dass die in forEach abgegebenen Aktionen sogar strukturelle Änderungen vornehmen dürfen, ohne dass ConcurrentModificationException-Ausnahme ausgelöst wird. Aber hier könnten die Modifikationen in dieser Iteration sichtbar sein oder nicht.

Zweiter Ansatz (Stream.forEach) - Die Reihenfolge ist nicht definiert. Es kann zwar nicht für sequentielle Streams vorkommen, aber die Spezifikation garantiert es nicht. Es ist auch erforderlich, dass die Aktion nicht in die Natur eingreift. Wie in doc erwähnt:

Das Verhalten dieser Operation ist explizit nicht deterministisch. Zum Parallel-Stream-Pipelines garantiert dieser Vorgang nicht respektieren Sie die Begegnungsreihenfolge des Streams, denn dies würde Opfer bringen der Vorteil der Parallelität.

Dritter Ansatz (Stream.forEachOrdered) - Die Aktion wird in der Reihenfolge des Streams ausgeführt. Also, wenn es um Ordnung geht, verwenden Sie forEachOrdered ohne einen zweiten Gedanken. Wie in doc erwähnt:

Führt für jedes Element dieses Streams eine Aktion in der Begegnung Reihenfolge des Streams aus, wenn der Stream eine definierte Begegnungsreihenfolge hat.

Beim Durchlaufen eines synchronisierter Auflistung würde der erste Ansatz die Auflistungssperre einmal übernehmen und würde sie über alle Aufforderungen zur Aktion halten, im Fall von Streams jedoch den Spliterator der Auflistung, der sperrt nicht und stützt sich auf die bereits festgelegten Regeln der Nichteinmischung. Falls die Sammlung der Datensicherung während der Iteration geändert wird, wird ConcurrentModificationException geworfen, oder es kann ein inkonsistentes Ergebnis auftreten. 

Vierter Ansatz (Parallel Stream.forEach) - Wie bereits erwähnt, kann die Begegnungsreihenfolge nicht wie erwartet bei parallelen Streams eingehalten werden. Es ist möglich, dass die Aktion in verschiedenen Threads für verschiedene Elemente ausgeführt wird, was bei forEachOrdered niemals der Fall sein kann.

Fünfter Ansatz (Parallel Stream.forEachOrdered) - Die forEachOrdered verarbeitet die Elemente in der von der Quelle angegebenen Reihenfolge, unabhängig davon, ob der Stream sequenziell oder parallel ist. Daher macht es keinen Sinn, dies mit parallelen Streams zu verwenden.

8
i_am_zero

Oder Sie können einfach die Apache Commons-Dienstprogramme verwenden:

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));
6
Romain VDK
  1. Sie haben nicht angegeben, welche Art von Elementen die Liste enthält. Wenn es sich um einen primitiven Datentyp handelt, können Sie die Elemente ausdrucken.
  2. Wenn es sich bei den Elementen jedoch um Objekte handelt, müssen Sie, wie Kshitij Mehta erwähnt hat, die Methode "toString" in diesem Objekt implementieren (überschreiben), sofern dies noch nicht implementiert ist, und eine vollständige Bedeutung innerhalb des Objekts zurückgeben. Beispiel:

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

Ich habe ähnliche Probleme gehabt. Mein Code:

List<Integer> leaveDatesList = new ArrayList<>();

.....inserted value in list.......

Weg 1: Drucken einer Liste in einer for-Schleife

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

Weg 2: Drucken der Liste in einer forEach, für Schleife

for(Integer leave : leaveDatesList){
    System.out.println(leave);
}

Weg 3: Liste in Java 8 drucken

leaveDatesList.forEach(System.out::println);
4
Atequer Rahman

Ich habe eine Dump-Funktion geschrieben, die grundsätzlich die öffentlichen Mitglieder eines Objekts ausgibt, wenn toString () nicht überschrieben wurde. Man kann es leicht erweitern, um Getter anzurufen . Javadoc:

Gibt ein gegebenes Objekt nach den folgenden Regeln an System.out aus:

  • Wenn das Objekt iterierbar ist, werden alle seine Komponenten gesichert.
  • Wenn das Objekt oder eine seiner Oberklassen toString () überschreibt, wird "toString" ausgegeben
  • Andernfalls wird die Methode für alle öffentlichen Mitglieder des Objekts rekursiv aufgerufen 

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

Ich arbeite gerade daran ...

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);
1
wayneseymour
    list.stream().map(x -> x.getName()).forEach(System.out::println);
1
Ella

System.out.println(list); arbeitet für mich.

Hier ist ein vollständiges Beispiel:

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

Es wird [Hello, World] gedruckt.

1
jfmg

Für eine Schleife zum Drucken des Inhalts einer Liste: 

List<String> myList = new ArrayList<String>();
myList.add("AA");
myList.add("BB");

for ( String elem : myList ) {
  System.out.println("Element : "+elem);
}

Ergebnis: 

Element : AA
Element : BB

Wenn Sie in einer einzelnen Zeile drucken möchten (nur zur Information): 

String strList = String.join(", ", myList);
System.out.println("Elements : "+strList);

Ergebnis: 

Elements : AA, BB
0
Théo Moulia
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()));
    }
0

versuchen Sie, die toString () -Methode zu überschreiben, wenn Sie möchten, dass das Element gedruckt wird. Die zu druckende Methode kann folgende sein:

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

Für eine Liste mit einem String-Array

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