This Tutorial Explains Various Java List Methods such as Sort List, List Contains, List Add, List Remove, List Size, AddAll, RemoveAll, Reverse List & More:
We have already discussed the list interface in general in our previous tutorial. List interface has various methods that are used to manipulate the contents of the list. Using these methods you can insert/delete, sort, and search elements in the list.
In this tutorial, we will discuss all the methods that are provided by the list interface.
=> Check Here To See A-Z Of Java Training Tutorials Here.
In order to iterate through the list, the list interface makes use of the list iterator. This list iterator extends from the iterator interface. In our next tutorial, we will explore more about the list iterator.
Table of Contents:
List Methods In Java
The following table shows various functions provided by the list interface in Java.
List method | Method Prototype | Description |
---|---|---|
size | int size () | Returns the size of the list i.e. number of elements in the List or the length of the list. |
clear | void clear () | Clears the list by removing all the elements in the list |
add | void add (int index, Object element) | Adds the given element to the list at the given index |
boolean add (Object o) | Adds the given element at the end of the list | |
addAll | boolean addAll (Collection c) | Appends the entire given collection to the end of the list |
boolean addAll (int index, Collection c) | Inserts the given collection(all elements) to the list at the specified index | |
contains | boolean contains (Object o) | Checks if the specified element is present in the list and returns true if present |
containsAll | boolean containsAll (Collection c) | Checks if the specified collection (all elements) is part of the list. Returns true of yes. |
equals | boolean equals (Object o) | Compares the specified object for equality with elements of the list |
Get | Object get (int index) | Returns the element in the list specified by index |
hashCode | int hashCode () | Returns the hash code value of the List. |
indexOf` | int indexOf (Object o) | Finds the first occurrence of the input element and returns its index |
isEmpty | boolean isEmpty () | Checks if the list is empty |
lastIndexOf | int lastIndexOf (Object o) | Finds the last occurrence of the input element in the list and returns its index |
remove | Object remove (int index) | Removes the element at the specified index |
boolean remove (Object o) | Removes the element at its first occurrence in the list | |
removeAll | boolean removeAll (Collection c) | Removes all elements contained in the specified collection from the list |
retainAll | boolean retainAll (Collection c) | Opposite of removeAll. Retains the element specified in the input collection in the list. |
Set | Object set (int index, Object element) | Changes the element at the specified index by setting it to the specified value |
subList | List subList (int fromIndex, int toIndex) | Returns sublist of elements between fromIndex(inclusive), and toIndex(exclusive). |
sort | void sort (Comparator super E> c) | Sorts the list element as per the specified comparator to give an ordered list |
toArray | Object[] toArray () | Returns array representation of the list |
Object [] toArray (Object [] a) | Returns the array representation whose runtime type is the same as a specified array argument | |
iterator | Iterator iterator () | Returns an Iterator for the list |
listIterator | ListIterator listIterator () | Returns a ListIterator for the list |
ListIterator listIterator (int index) | Returns a ListIterator starting at the specified index in the list |
Next, we will discuss these functions along with their examples.
size
Prototype: int size()
Parameters: NIL
Return Value: int => Number of elements in the list or in other words the length of the list.
Description: The size() returns the number of elements or the size of the list. It can also be called length in simple terms.
clear
Prototype: void clear()
Parameters: NIL
Return Value: No return value
Description: Clears the list by removing all the elements of the list. Throws “UnSupportedException” if the operation is not supported by the list.
The below example will demonstrate size() and clear() method.
import java.util.*; public class Main { public static void main(String[] args) { List<String> strList = new ArrayList<String>(); // Creating a list //add items to list strList.add("Java"); strList.add("C++"); //print the size of list System.out.println("Size of list:" + strList.size()); //add more items to list strList.add("Ruby"); strList.add("Python"); strList.add("C#"); //print the size of list again System.out.println("Size of list after adding more elements:" + strList.size()); //clear method strList.clear(); System.out.println("List after calling clear() method:" + strList); } }
Output:
add
Prototype: void add(int index, Object element)
Parameters: index- a position at which the element is to be added.
Element- the element to be added
Return Value: void
Description: Adds the given element to the list at the given index. The subsequent elements are shifted to the right.
Following exceptions are thrown:
IndexOutOfBoundsException: List index is out of range
UnsupportedOperationException: Add operation is not supported by the List.
ClassCastException: The element cannot be added to the list because of the class of specified elements.
IllegalArgumentException: Specified element or some aspect is not correct.
Add
Prototype: boolean add (Object o)
Parameters: o=> Element to be added to the list
Return Value: true=> Element successfully added
False=> Add not successful
Description: This method adds the given element at the end of the list.
This operation can throw the following exceptions.
UnsupportedOperationException: Add operation not supported by this List.
ClassCastException: Specified element cannot be added because of its class
IllegalArgumentException: Specified element or some aspect is not correct.
addAll
Prototype: boolean addAll (Collection c)
Parameters: c=> Collection whose elements are to be added to the list
Return Value: true=> Method execution successful
Description: The addAll method takes all the elements from collection c and appends them to the end of the list by maintaining the order that was set.
This method exhibits unspecified behavior if the collection is altered when the operation is in progress.
The method throws the following exceptions:
UnsupportedOperationException: Add operation not supported by this List.
ClassCastException: Specified element cannot be added because of its class.
IllegalArgumentException: Specified element or some aspect is not correct.
addAll
Prototype: boolean addAll(int index, Collection c)
Parameters: index=> Position at which the collection is to be inserted.
C=> Collection that is to be inserted in the list.
Return Value: true => If collection elements are successfully added to the list.
Description: The addAll method inserts all the elements in the specified collection into the list at the specified index. The subsequent elements are then shifted to the right. As in the case of the previous overload of addAll, the behavior is unspecified if the collection is altered when the operation is in progress.
The exceptions thrown by this method are:
UnsupportedOperationException: Add operation not supported by this List.
ClassCastException: Specified element cannot be added because of its class.
IllegalArgumentException: Specified element or some aspect is not correct.
IndexOutOfBoundsException: Index out of range.
The program below shows the demonstration of add and addAll methods of the list.
import java.util.*; public class Main { public static void main(String[] args) { List<String> strList = new ArrayList<String>(); // Creating a list strList.add("Java"); strList.add("C++"); //print the list System.out.println("List after adding two elements:" + strList); List<String> llist = new ArrayList<String>(); // Create another list llist.add("Ruby"); llist.add("Python"); llist.add("C#"); // addAll method - add llist to strList strList.addAll(llist); System.out.println("List after addAll:"+ strList); } }
Output:
contains
Prototype: boolean contains(Object o)
Parameters: o=> Element to be searched in the list.
Return Value: true=> If list contains the specified element.
Description: The method ‘contains’ checks if the specified element is present in the list and returns a Boolean value true if the element is present. Otherwise, it returns false.
containsAll
Prototype: boolean containsAll(Collection c)
Parameters: c => Collection to be searched in the list.
Return Value: true=> If all elements in the specified collection are present in the list.
Description: “containsAll” method checks if all the elements present in the specified collection are present in the list. If present it returns a true value and false otherwise.
The following Java program demonstrates the usage of ‘contains’ and ‘containsAll’ methods of the list.
import java.util.*; public class Main { public static void main(String[] args) { //define list of strings List<String> list = new ArrayList<String>(); //initialize list to strings list.add("Java"); list.add("Xml"); list.add("Python"); list.add("Ruby"); list.add("JavaScript"); //contains method demo if(list.contains("C")==true) System.out.println("Given list contains string 'C'"); else if(list.contains("Java")==true) System.out.println("Given list contains string 'Java' but not string 'C'"); //containsAll method demo List<String> myList = new ArrayList<String>(); myList.add("Ruby"); myList.add("Python"); if(list.containsAll(myList)==true) System.out.println("List contains strings 'Ruby' and 'Python'"); } }
Output:
Given list contains string ‘Java’ but not string ‘C’
List contains strings ‘Ruby’ and ‘Python’
equals
Prototype: boolean equals(Object o)
Parameters: o=> The object that is to be tested for equality.
Return Value: true=> If the given object is equal to the list.
Description: This method is used to compare the given object with the list of equality. If the specified object is a list, then the method returns true. Both lists are said to be equal if and only if they are of the same size, and the corresponding elements in the two lists are equal and in the same order.
A demonstration of the equals method is given below:
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String[] args) { //define lists List<Integer> first_list= new LinkedList<>(); List<Integer> second_list = new LinkedList<>(); List<Integer> third_list = new LinkedList<>(); //initialize lists with values for (int i=0;i<11;i++){ first_list.add(i); second_list.add(i); third_list.add(i*i); } //print each list System.out.println("First list: " + first_list); System.out.println("Second list: " + second_list); System.out.println("Third list: " + third_list); //use equals method to check equality with each list to other if (first_list.equals(second_list) == true) System.out.println("\nfirst_list and second_list are equal.\n"); else System.out.println("first_list and second_list are not equal.\n"); if(first_list.equals(third_list)) System.out.println("first_list and third_list are equal.\n"); else System.out.println("first_list and third_list are not equal.\n"); if(second_list.equals(third_list)) System.out.println("second_list and third_list are equal.\n"); else System.out.println("second_list and third_list are not equal.\n"); } }
Output:
Get
Prototype: Object get(int index)
Parameters: index=> Position at which the element is to be returned.
Return Value: object=> Element at the specified position.
Description: The get() method returns the element at the given position.
This method throws “indexOutOfBoundsException” if the index specified is out of the range of the list.
Set
Prototype: Object set(int index, Object element)
Parameters: index=> Position at which the new element is to be set.
element=> New element to be placed at the position given by index.
Return Value: Object=> Element that was replaced
Description: The method set() replaces the element at the given index by another value given by element.
The method may throw the following exceptions:
UnsupportedOperationException: Set operation is not supported by the List.
ClassCastException: Operation cannot be performed because of the class of the element
IllegalArgumentException: Argument or some aspect of it is illegal
IndexOutOfBoundsException: Index out of range.
The following program shows an example of get () and set() method.
import java.util.*; public class Main { public static void main(String[] args) { //define list List listA = new ArrayList(); listA.add("Java"); listA.add("C++"); listA.add("Python"); //access list elements using index with get () method System.out.println("Element at index 0:" + listA.get(0)); System.out.println("Element at index 1:" + listA.get(1)); System.out.println("Element at index 2:" + listA.get(2)); //set element at index 1 to Ruby listA.set(1,"Ruby"); System.out.println("Element at index 1 changed to :" + listA.get(1) ); } }
Output:
hashCode
Prototype: int hashCode()
Parameters: NIL
Return Value: int=> hashCode of the list
Description: The method ‘hashCode()’ returns the hashCode of the list which is an integer value.
Example:
import java.util.*; public class Main { public static void main(String[] args) { // Initializing a list of type Linkedlist List<Integer> mylist = new LinkedList<>(); mylist.add(1); mylist.add(3); mylist.add(5); mylist.add(7); //print the list System.out.println("The list:" + mylist); //use hashCode() method to find hashcode of list int hash = mylist.hashCode(); System.out.println("Hashcode for list:" + hash); } }
Output:
isEmpty
Prototype: boolean isEmpty()
Parameters: NIL
Return Value: true=> List is empty
Description: The ‘isEmpty()’ method checks if the list is empty. IsEmpty method is used to check if the list has any elements in it before you begin to process those elements.
indexOf
Prototype: int indexOf(Object o)
Parameters: o=> element to search for in the list
Return Value: int=> the index or position of the first occurrence of the given element in the list. Returns -1 if element is not present.
Description: The method ‘indexOf()’ returns the index of the first occurrence of the given element o in the list. If the element is not found it returns -1.
lastIndexOf
Prototype: int lastIndexOf(Object o)
Parameters: o=> Object whose index is to be searched
Return Value: int=> Index of the last occurrence of the given element in the list, -1 otherwise.
Description: The method ‘lastIndexOf()’ returns the index of the last occurrence of element o in the list. If the element is not found, the method returns -1.
The Java program below demonstrates the usage of indexOf and lastIndexOf methods of the list.
import java.util.*; public class Main { public static void main(String[] args) { // define an integer array List<Integer> intList = new ArrayList<Integer>(5); //add elements to the list intList.add(10); intList.add(20); intList.add(30); intList.add(10); intList.add(20); //print the list System.out.println("The list of integers:" + intList); // Use indexOf() and lastIndexOf() methods of list to find first and last index System.out.println("first index of 20:" + intList.indexOf(20)); System.out.println("last index of 10:" + intList.lastIndexOf(10)); } }
Output:
remove
Prototype: Object remove (int index)
Parameters: index=> Index or position in the list at which the element is to be removed
Return Value: Object=> Element removed
Description: The ‘remove ()’ method removes the element at the given position from the list. After deletion, the elements next to the deleted element are shifted left.
This method may throw the following exceptions:
UnsupportedOperationException: Remove is not supported by the List.
IndexOutOfBoundsException: Index specified is out of range
remove
Prototype: boolean remove(Object o)
Parameters: o=> Element to be removed from the list
Return Value: true=> Element is successfully removed.
Description: This overloaded version of the remove() method removes the first occurrence of a given element o from the list. If the given element is not present in the list, then it remains unchanged.
This method may throw the following exception:
UnsupportedOperationException: Remove is not supported by the List.
removeAll
Prototype: boolean removeAll(Collection c)
Parameters: c=> A collection that contains elements that are removed from the list.
Return Value: true=> If the method call is successful and all the elements specified in the collection c are removed from the list.
Description: The ‘removeAll()’ method is used to remove all the elements from the list that are specified in collection c that is passed as an argument.
This method may throw the following exception:
UnsupportedOperationException: removeAll is not supported by the List.
Let us see an example of remove and removeAll methods.
import java.util.*; public class Main { public static void main(String[] args) { // Creating a list List<Integer> oddList = new ArrayList<Integer>(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println("Original List:" + oddList); // Removes element from index 1 oddList.remove(1); System.out.println("Oddlist after removing element at index 1:" + oddList); //removeAll method List<Integer> c1 = new ArrayList<Integer>(); c1.add(1); c1.add(5); c1.add(11); oddList.removeAll(c1); System.out.println("Oddlist after removing elements {1,5,11}}:" + oddList); } }
Output:
retainAll
Prototype: boolean retainAll(Collection c)
Parameters: c=> Collection that contains elements that should be retained in the list.
Return Value: true=> If the method call changed the list.
Description: This method removes all the elements from the list except for those which are present in the collection c. In other words, this method retains all the elements in the list that are present in collection c and removes the other elements.
This method may throw the following exception:
UnsupportedOperationException: retainAll is not supported by the List.
import java.util.*; public class Main { public static void main(String[] args) { // Creating a list List<Integer> oddList = new ArrayList<Integer>(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println("Original List:" + oddList); //retainAll method List<Integer> c1 = new ArrayList<Integer>(); c1.add(1); c1.add(5); c1.add(11); oddList.retainAll(c1); System.out.println("Oddlist after call to retainAll (1,5,11):" + oddList); } }
Output:
subList
Prototype: List subList (int fromIndex, int toIndex)
Parameters: fromIndex => Lower index of the list (inclusive)
toIndex => Higher index of the list (exclusive)
Return Value: List=> A sub-list of the given list
Description: The method sublist () returns the partial view of the list, also known as sublist from ‘fromIndex’ to ‘toIndex’. The returned sublist is just a view of the parent list and thus any changes made to either list reflect everywhere.
Similarly, all the operations of the list also work on a sublist.
The method can throw the following exception:
IndexOutOfBoundsException: Illegal toIndex value.
An example program for the sublist method is given below.
import java.util.*; public class Main { public static void main(String[] args) { // define a string list List<String> strList = new ArrayList<String>(5); //add elements to the list strList.add("Java"); strList.add("Tutorials"); strList.add("Collection"); strList.add("Framework"); strList.add("Series"); //print the original list System.out.println("The original list=>strList: " + strList); //define another list List<String> subList = new ArrayList<String>(); // take a sublist of elements from 2 to 4 from strList subList = strList.subList(2, 4); //print the sublist System.out.println("The sublist of strList:" + subList); } }
Output:
sort list
Prototype: void sort (Comparator<? super E> c)
Parameters: c=> Comparator on the basis of which the list is sorted.
Return Value: NIL
Description: ‘sort ()’ method is used to sort the list. The method makes use of the comparator specified to sort the list.
Let us see an example of the sort method. We have compared it with the Collections.sort method that sorts the elements in a natural sequence. The output of the program is an ordered list.
import java.util.Collections; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Main { public static void main(String[] args) { //define list List<Integer> intArray = new ArrayList<>(); Random random = new Random(); //populate the list with random numbers < 20 for (int i = 0; i < 10; i++) intArray.add(random.nextInt(20)); //display the original list System.out.println("Original List: "+intArray); //natural sorting using Collections.sort () method Collections.sort(intArray); System.out.println("List sorted naturally:\n"+intArray); //Sorting using list.sort with comparator intArray.sort((o1,o2) -> {return (o2-o1);}); //comparator to sort in reverse System.out.println("Reverse List sorted using comparator:\n"+intArray); } }
Output:
toArray
Prototype: Object [] toArray ()
Parameters: NIL
Return Value: Object [] => Array representation of the list
Description: Method toArray() returns the array representation of the list in a proper sequence.
toArray
Prototype: Object[] toArray(Object[] a)
Parameters: a => Array type which is to be matched to list element types while converting the list to an array.
Return Value: Object [] => Array representation of the list.
Description: This overload of method toArray () returns the array containing elements in the list that have the same runtime type as that of array a.
This method may throw the following exception:
ArrayStoreException: The runtime type of every element in the list is not a subtype of the runtime type of every element in this List.
The following is an example of the implementation of the toArray method.
import java.util.*; public class Main { public static void main(String[] args) { // create list ArrayList<String> colorsList = new ArrayList<String>(7); // add colors to colorsList colorsList.add("Violet"); colorsList.add("Indigo"); colorsList.add("Blue"); colorsList.add("Green"); colorsList.add("Yellow"); colorsList.add("Orange"); colorsList.add("Red"); System.out.println("Size of the colorsList: " + colorsList.size()); // Print the colors in the list System.out.println("Contents of colorsList:"); for (String value : colorsList){ System.out.print(value + " "); } // Create an array from the list using toArray method String colorsArray[] = new String[colorsList.size()]; colorsArray = colorsList.toArray(colorsArray); // Display the contents of the array System.out.println("\n\nPrinting elements of colorsArray:" + Arrays.toString(colorsArray)); } }
Output:
Iterator
Prototype: Iterator iterator ()
Parameters: NIL
Return Value: Iterator=> Iterator to iterate over the elements of the list
Description: This method returns the iterator that iterates over the elements in the list.
Java Program to demonstrate using iterator.
import java.util.*; public class Main { public static void main(String[] args) { // create list ArrayList<String> colorsList = new ArrayList<String>(7); // add colors to colorsList colorsList.add("Violet"); colorsList.add("Indigo"); colorsList.add("Blue"); colorsList.add("Green"); colorsList.add("Yellow"); colorsList.add("Orange"); colorsList.add("Red"); System.out.println("ColorList using iterator:"); //define iterator for colorsList Iterator<String> iterator = colorsList.iterator(); //iterate through colorsList using iterator and print each item while(iterator.hasNext()){ System.out.print(iterator.next() + " "); } } }
Output:
listIterator
Prototype: ListIterator listIterator()
Parameters: NIL
Return Value: ListIterator=> Listiterator of the elements in the list.
Description: Method listIterator() returns the ListIterator object of the elements in the list. This iterator starts from the beginning of the list i.e. index 0.
listIterator
Prototype: ListIterator listIterator (int index)
Parameters: index=> Position at which listIterator starts.
Return Value: ListIterator=> ListIterator object at specified index in the list.
Description: The overload of method listIterator () returns a listIterator that starts at the given position in the list. The given index indicates that it will be the first element that will be returned by the first call to nextElement() method of ListIterator.
The method may throw IndexOutOfBoundsException for the invalid value of the index.
The following example demonstrates listIterator usage.
import java.util.*; public class Main { public static void main(String[] args) { //define list & add items to list List<String> nameList = new LinkedList<>(); nameList.add("Java"); nameList.add("C++"); nameList.add("Python"); // get listIterator for the list ListIterator<String> namesIterator = nameList.listIterator(); // Traverse list using listiterator and print each item System.out.println("Contents of list using listIterator:"); while(namesIterator.hasNext()){ System.out.print(namesIterator.next() + " "); } } }
Output:
We will discuss ListIterator in detail later.
Let’s now discuss some of the miscellaneous operations that can be done on lists but methods for which are not provided in the list interface.
Copy List In Java
For copying elements of one list to another list, you have to use the copy() method provided by the Collections framework.
The method Collections.copy() copies all the elements of the list provided as the second argument, to the list provided as the first argument. Note that the list to which the contents of another list are being copies should be large enough to accommodate the copied elements.
If the list is not large enough, the copy method throws “indexOutOfBoundsEexception”.
The following program copies the contents of one list to another.
import java.util.*; public class Main { public static void main(String[] args) { //create first ArrayList object List aList_1 = new ArrayList(); //Add elements to first ArrayList aList_1.add("R"); aList_1.add("G"); aList_1.add("B"); //print the List System.out.println("The first list:" + aList_1); //create second ArrayList object List aList_2 = new ArrayList(); //Add elements to second Arraylist aList_2.add("Red"); aList_2.add("Green"); aList_2.add("Blue"); aList_2.add("Yellow"); aList_2.add("Brown"); System.out.println("The second list: " + aList_2); //use Collections.copy() method to copy elements of first list to second list. Collections.copy(aList_2,aList_1); //print the resultant second Arraylist System.out.println("\n\nThe second list after copying first list to second list: " + aList_2); } }
Output:
Remove Duplicates From A List In Java
A given list may or may not have repetitive elements or duplicates. If the list you are working with has duplicate elements and you want all distinct elements in the list, then there are two methods to remove duplicates from the list supported in Java.
Using Java 8 stream
The first method to remove duplicates from the list is by using the distinct () method provided by Java 8 stream. Here, the list containing duplicates invokes the stream ().distinct method and then the return value is converted to a new list which will have only the distinct elements.
The following program demonstrates the usage of the distinct () method.
import java.util.*; import java.util.stream.Collectors; class Main { public static void main(String[] args) { // original list List<Integer> intlist = new ArrayList<>( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5,6,5,3,4)); // Print the list System.out.println("Original ArrayList: " + intlist); // using distinct() method of Java 8 stream remove duplicates from original List //and generate a new list without duplicates List<Integer> distinct_list = intlist.stream().distinct() .collect(Collectors.toList()); // Print the new list System.out.println("ArrayList after removing duplicates: " + distinct_list); } }
Output:
Using Iterator approach
Removing duplicates from the list using the iterator is a lengthy and primitive approach. In this approach, you have to traverse through the list and put the first occurrence of every element in a new list. Every subsequent element is checked if it’s a duplicate.
The program below achieves this.
import java.util.*; public class Main { public static void main(String args[]) { // create original list ArrayList<Integer> aList = new ArrayList<>( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 5, 3, 4)); // Print the original list System.out.println("Original List: "+ aList); // Create a new list ArrayList<Integer> new_List = new ArrayList<>(); // Traverse through the original list to remove duplicates for (Integer element : aList) { // check if element is present in new_List, else add it if (!new_List.contains(element)) { new_List.add(element); } } // Print the new list without duplicates System.out.println("List after removing duplicates: "+ new_List); } }
Output:
Frequently Asked Questions
Q #1) What is get method in the list in Java?
Answer: Get method of the list is used to retrieve a particular element in the list based on the index. You pass the required index to the get method and the get method will return the element value at that index.
Q #2) What is the toArray method in Java?
Answer: The method toArray () is used to get the array representation of the list.
Q #3) How do you sort a list in Java?
Answer: In Java, a list can be sorted using the sort method of the list. You can pass your own sorting criteria using the comparator interface that is passed to the sort method as a parameter.
You can also use Collections. Sort method to sort the list. This method sorts the list as per natural ordering.
Q #4) What is Arrays.asList() in Java?
Answer: The method ‘asList’ of array returns the list of elements backed by an array.
Conclusion
In this tutorial, we have learned all the methods that a list provides. The Java list provides various methods using which you can manipulate and process lists including searching, sorting, etc. We have explained each method with appropriate programming examples here.
In our upcoming tutorial, we will discuss the ListIterator in detail.
=> Explore The Simple Java Training Series Here.