How to print out all the elements of a List in Java?

Overriding toString() for custom objects

Behold an odyssey with custom objects. It's crucial to override the toString() method:

public class Fruit {
    private String name;

    public Fruit(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Fruit{name='" + name + "'}";
    }
    // Tastes like freshly formatted data, yum yum!
}


Now, when you unleash System.out.println() on a Fruit object, it serves up meaningful data, not merely the object's hash code! Who wants the memory address for dinner, right?

Don't loop it, toString() it!

If your fancy List cuddles up primitive data types or objects with a sensibly overridden toString() method, you can have a feast served in a line:

List<Fruit> fruits = List.of(new Fruit("Apple"), new Fruit("Banana"), new Fruit("Cherry"));
System.out.println(fruits);


Behold! It is the mighty toString() method of AbstractCollection at play, to which List pays its allegiance.

String.join() — the peacekeeper

Given a List<String>, join the battle of elements into a unified string with a delimiter with String.join():

String allFruits = String.join(", ", fruits);
System.out.println(allFruits);


With flexibility in representation, you can master the arts of CSV values making or other delimited outputs. Unity is strength, even in strings!

The tried and true — for-each loop

In the jungle of variations, the traditional for-each loop stands tall:

for(String fruit : fruits) {
    System.out.println(fruit);
}


Its majesty, the intuitive structure and simplicity, holds the flag of readability high in the air.

Before printing, peek inside

Validate if the list is non-empty before printing, like knocking before entering to avoid NullPointerException or unproductive operations:

if(!fruits.isEmpty()) {
    fruits.forEach(System.out::println);
    // Wilderness has been tamed, let the feast begin!
}


Safeguard conversions with String.valueOf()

In the realm of Lists, beware of the null elements lurking around:

List<String> fruitsWithNulls = Arrays.asList("Apple", null, "Cherry");


The knight String.valueOf() ensures safe conversion to String without throwing an exception, like a magic null-nullifying shield:

fruitsWithNulls.forEach(fruit -> System.out.println(String.valueOf(fruit)));


Invoke the magic — method references

In the realm of Java, unleash the sorcery of method references and escape the shadows of performance overhead that lurk behind lambdas:

fruitsWithNulls.stream()
                .map(String::valueOf)
                .forEach(System.out::println);
// Call me `map`, the shapeshifter, 
// Call me `forEach`, the scribe.


Arrays.toString() — compact but competent

Unearth the power of Arrays.toString() lurking in Java Utilities for array representations of collections:

System.out.println(Arrays.toString(fruits.toArray()));


The beauty of its compact and readable output, a treasure for quick debugging or logging. Talk about a little spark causing a prairie fire!

The thinking model class

When the data gets complex, embrace the sophistication of a model class with access methods and a smart toString():

public class Book {
    private String title;
    private String author;
    
    // Constructor, getters, and setters omitted for brevity
    
    @Override
    public String toString() {
        return "Book{" +
               "title='" + title + '\'' +
               ", author='" + author + '\'' +
               '}';
    }
    // Beauty of a novel without the reading time!
}


Now, a List<Book> unfolds as an open book. So intuitively detailed, unearthing contents and the data structures like popping a Jack out of the box.

Get out of the get() pitfall

While traversing, the tempting get() method may lead you into the labyrinth of inefficiency, especially with LinkedList:

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

The price for the get()? Sometimes, an O(n²) complexity. It's like paying for a mango with a gold coin!

Embrace the elegance of Java 8

Witness the conciseness and might of Java 8 features transform mere printing rituals into versatile data manipulation:

fruits.stream()
      .filter(fruit -> fruit.startsWith("A"))
      .forEach(System.out::println);


This snippet selects only the fruits initiating with "A", showcasing stream API's power and elegance. Decisions, decisions!