Java LinkedList clear()
method
The clear()
method in Java's LinkedList
class is a handy tool for quickly removing all elements from the list. It essentially empties the linked list, making it as if it were newly created.
clear()
methodclear()
methodThe clear()
method in Java's LinkedList
class is a handy tool for quickly removing all elements from the list. It essentially empties the linked list, making it as if it were newly created.
public void clear()
Parameter | Description |
---|---|
None | This method doesn't accept any parameters. |
The clear()
method returns void
, meaning it doesn’t explicitly return a value. Instead, it modifies the list in place.
Let's start with a simple case – clearing a LinkedList that is already empty. This demonstrates that calling clear()
on an empty list has no effect.
LinkedList<String> myList = new LinkedList<>();
System.out.println("Size before clear: " + myList.size()); // Output will be 0
myList.clear();
System.out.println("Size after clear: " + myList.size()); // Output will still be 0
Size before clear: 0
Size after clear: 0
As you can see, the size remains zero because the list was already empty.
Now let's look at what happens when we clear a LinkedList that actually contains elements. The method removes all elements, resulting in an empty list.
LinkedList<Integer> numbers = new LinkedList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("Size before clear: " + numbers.size()); // Output will be 3
numbers.clear();
System.out.println("Size after clear: " + numbers.size()); // Output will be 0
Size before clear: 3
Size after clear: 0
The list initially held three elements, but after calling clear()
, the size is reduced to zero. The elements are removed from memory.
This example demonstrates how clearing a LinkedList affects any iterators that might be associated with it. It's crucial to understand this because using an iterator after the list has been cleared will result in a ConcurrentModificationException
.
LinkedList<String> names = new LinkedList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
names.clear(); // Clear the list
// The following line will throw a ConcurrentModificationException:
// iterator.next();
The commented-out iterator.next()
call would cause a ConcurrentModificationException
because the linked list has been modified while the iterator was in use. If you need to process elements after clearing, create a new iterator.
This example shows that after calling clear()
, you can add new elements back into the LinkedList as if it were newly created.
LinkedList<Double> values = new LinkedList<>();
values.add(10.5);
values.add(20.7);
values.clear();
System.out.println("Size after clear: " + values.size()); // Output will be 0
values.add(30.9);
values.add(40.2);
System.out.println("Size after adding new elements: " + values.size()); // Output will be 2
Size after clear: 0
Size after adding new elements: 2
The list is first cleared, then two new values are added back in.