Hoe kan ik alle elementen van een lijst in Java afdrukken?

Ik probeer alle elementen van een List af te drukken, maar het drukt de aanwijzer van het Object af in plaats van de waarde.

Dit is mijn afdrukcode…

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

Kan iemand me alsjeblieft helpen waarom het de waarde van de elementen niet afdrukt.


Antwoord 1, autoriteit 100%

Hier is een voorbeeld over het afdrukken van de lijstcomponent:

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

Antwoord 2, autoriteit 98%

Het volgende is compact en vermijdt de lus in uw voorbeeldcode (en geeft u mooie komma’s):

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

Echter, zoals anderen hebben opgemerkt, als je geen verstandige toString()-methoden hebt geïmplementeerd voor de objecten in de lijst, krijg je de objectaanwijzers (in feite hashcodes) die je observeert. Dit is waar, of ze nu in een lijst staan ​​of niet.


Antwoord 3, autoriteit 96%

Sinds Java 8 neemt List een standaard “forEach”-methode over die u als volgt kunt combineren met de methode-referentie “System.out::println”:

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

Antwoord 4, autoriteit 36%

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

toString() van AbstractCollection zal schoon en gemakkelijk genoeg zijn om dat te doen. AbstractList is een subklasse van AbstractCollection, dus geen for-lus en geen toArray() nodig.

Retourneert een tekenreeksrepresentatie van deze verzameling. De tekenreeksrepresentatie bestaat uit een lijst van de elementen van de collectie in de
volgorde waarin ze worden geretourneerd door de iterator, tussen vierkante haken ingesloten
(“[]”). Aangrenzende elementen worden gescheiden door de tekens “, ” (komma
en ruimte). Elementen worden geconverteerd naar strings als by
String.valueOf(Object).

Als je een aangepast object in je lijst gebruikt, zeg Student , moet je de methode toString() overschrijven (het is altijd goed om deze methode te negeren) om een ​​zinvolle uitvoer te krijgen

Zie het onderstaande voorbeeld:

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

uitvoer:

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

Antwoord 5, autoriteit 19%

Gebruik String.join()
bijvoorbeeld:

System.out.print(String.join("\n", list));

Antwoord 6, autoriteit 18%

De Java 8 Streams-aanpak…

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

Antwoord 7, autoriteit 12%

Voor de objecten in de lijst moet toString zijn geïmplementeerd om iets zinvols op het scherm te kunnen afdrukken.

Hier is een snelle test om de verschillen te zien:

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

En wanneer dit wordt uitgevoerd, zijn de resultaten die op het scherm worden afgedrukt:

t1 = [email protected]
t2 = 5

Omdat T1 de methode toString niet overschrijft, wordt de instantie t1 afgedrukt als iets dat niet erg nuttig is. Aan de andere kant overschrijft T2 toString, dus we bepalen wat het afdrukt wanneer het wordt gebruikt in I/O, en we zien iets beters op het scherm.


Antwoord 8, autoriteit 10%

Of je kunt gewoon de Apache Commons-hulpprogramma’s gebruiken:

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

Antwoord 9, autoriteit 10%

Overweeg een List<String> stringList die op vele manieren kan worden afgedrukt met behulp van Java 8 constructies:

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)

Hoe verschillen deze benaderingen van elkaar?

Eerste benadering (Iterable.forEach)-
De iterator van de collectie wordt over het algemeen gebruikt en die is ontworpen om fail-fast wat betekent dat het ConcurrentModificationException zal gooien als de onderliggende collectie tijdens de iteratie structureel wordt gewijzigd. Zoals vermeld in de doc voor ArrayList:

Een structurele wijziging is elke bewerking die een of toevoegt of verwijdert
meer elementen, of de grootte van de backing-array expliciet wijzigen; alleen maar instellen
de waarde van een element is geen structurele wijziging.

Dus het betekent voor ArrayList.forEach instelling dat de waarde zonder enig probleem is toegestaan. En in het geval van gelijktijdige verzameling, b.v. ConcurrentLinkedQueue de iterator zou zwak consistent wat betekent dat de acties die worden doorgegeven in forEach zelfs structurele wijzigingen mogen aanbrengen zonder dat er een ConcurrentModificationExceptionuitzondering wordt gegenereerd. Maar hier kunnen de wijzigingen al dan niet zichtbaar zijn in die iteratie.

Tweede benadering (Stream.forEach)-
De volgorde is niet gedefinieerd. Hoewel het misschien niet voorkomt voor opeenvolgende streams, garandeert de specificatie dit niet. Ook moet de handeling niet-belastend van aard zijn. Zoals vermeld in doc:

Het gedrag van deze bewerking is expliciet niet-deterministisch. Voor
parallelle stroompijpleidingen, deze bewerking garandeert niet dat:
respecteer de ontmoetingsvolgorde van de stroom, omdat dit zou offeren
het voordeel van parallellisme.

Derde benadering (Stream.forEachOrdered)-
De actie zou worden uitgevoerd in de ontmoetingsvolgorde van de stream. Dus wanneer orde belangrijk is, gebruik forEachOrdered zonder erbij na te denken. Zoals vermeld in de doc:

Voert een actie uit voor elk element van deze stream, in de ontmoeting
volgorde van de stream
als de stream een ​​gedefinieerde ontmoetingsvolgorde heeft.

Tijdens het herhalen van een gesynchroniseerde verzameling zou de eerste benadering de vergrendeling van de verzameling eenmaal nemen en deze vasthouden voor alle call-to-action-methoden, maar in het geval van streams zouden ze gebruik de spliterator van de collectie, die niet vergrendelt en vertrouwt op de reeds vastgestelde regels van niet-interferentie. In het geval dat de back-up van de collectie tijdens iteratie wordt gewijzigd, wordt een ConcurrentModificationException gegenereerd of kan een inconsistent resultaat optreden.

Vierde benadering (parallel Stream.forEach)-
Zoals reeds vermeld, geen garantie om de ontmoetingsvolgorde te respecteren zoals verwacht in het geval van parallelle streams. Het is mogelijk dat actie wordt uitgevoerd in verschillende threads voor verschillende elementen, wat nooit het geval kan zijn met forEachOrdered.

Vijfde benadering (parallel Stream.forEachOrdered)-
De forEachOrdered verwerkt de elementen in de door de bron gespecificeerde volgorde, ongeacht of de stream sequentieel of parallel is. Het heeft dus geen zin om dit te gebruiken met parallelle streams.


Antwoord 10, autoriteit 7%

Ik heb soortgelijke problemen ondervonden. Mijn code:

List<Integer> leaveDatesList = new ArrayList<>();
.....inserted value in list.......

Manier 1: een lijst afdrukken in een for-lus

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

Manier 2: de lijst afdrukken in een forEach, for-lus

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

Manier 3: de lijst afdrukken in Java 8

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

Antwoord 11, autoriteit 4%

  1. Je hebt niet gespecificeerd wat voor soort elementen de lijst bevat, als het een primitief gegevenstype is dan kun je de elementen uitprinten.
  2. Maar als de elementen objecten zijn, moet je, zoals Kshitij Mehta al zei, de methode “toString” binnen dat object implementeren (overschrijven) – als het nog niet is geïmplementeerd – en het iets betekenisvols laten retourneren vanuit de object, voorbeeld:
    class Person {
        private String firstName;
        private String lastName;
        @Override
        public String toString() {
            return this.firstName + " " + this.lastName;
        }
    }
    

Antwoord 12, autoriteit 3%

Voor een lijst met arrays van String

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

Antwoord 13, autoriteit 3%

For-lus om de inhoud van een lijst af te drukken:

List<String> myList = new ArrayList<String>();
myList.add("AA");
myList.add("BB");
for ( String elem : myList ) {
  System.out.println("Element : "+elem);
}

Resultaat:

Element : AA
Element : BB

Als u in één regel wilt afdrukken (alleen ter informatie):

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

Resultaat:

Elements : AA, BB

Antwoord 14, autoriteit 2%

System.out.println(list); werkt voor mij.

Hier is een volledig voorbeeld:

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

Het zal [Hello, World] afdrukken.


Antwoord 15, autoriteit 2%

Ik heb een dump-functie geschreven, die in principe de openbare leden van een object afdrukt als het toString() niet heeft overschreven. Je zou het gemakkelijk kunnen uitbreiden om getters te noemen.
Javadoc:

Dumpt een bepaald object naar System.out met behulp van de volgende regels:

  • Als het object itereerbaar is, worden alle componenten gedumpt.
  • Als het object of een van zijn superklassen toString() overschrijft, wordt de “toString” gedumpt
  • Anders wordt de methode recursief aangeroepen voor alle openbare leden van het object
/**
 * 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();
}

Antwoord 16, autoriteit 2%

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

Antwoord 17, autoriteit 2%

Het hangt af van het type objecten dat is opgeslagen in de List en of het is geïmplementeerd voor de methode toString(). System.out.println(list) moet alle standaard Java-objecttypen afdrukken (String, Long, Integer enz). Als we aangepaste objecttypen gebruiken, moeten we de methode override toString() van ons aangepaste object.

Voorbeeld:

class Employee {
 private String name;
 private long id;
 @Override
 public String toString() {
   return "name: " + this.name() + 
           ", id: " + this.id();
 }  
}

Testen:

class TestPrintList {
   public static void main(String[] args) {
     Employee employee1 =new Employee("test1", 123);
     Employee employee2 =new Employee("test2", 453);
     List<Employee> employees = new ArrayList(2);
     employee.add(employee1);
     employee.add(employee2);
     System.out.println(employees);
   }
}

Antwoord 18

Ik ben hier nu mee bezig…

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

Antwoord 19

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

Antwoord 20

probeer de methode toString() te overschrijven als u wilt dat het element wordt afgedrukt.
dus de methode om af te drukken kan deze zijn:

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

Antwoord 21

Oplossing van uw probleem voor Java 11 is:

String separator = ", ";
String toPrint = list.stream().map(o -> String.valueOf(o)).collect(Collectors.joining(separator));
System.out.println(toPrint);

Antwoord 22

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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes