Java List

The Java Collection Framework contains very useful interfaces and classes that implement them for working with data structures. It can be said that this is one of the most important JDK frameworks. The List interface is very popular. because without all sorts of lists in programming it is indispensable. In this article, we will cover this interface, Java List methods and implementations.

Java List Interface

The most important thing about a list is that it is an ordered collection. You can also call it a sequence. In Java, lists are homogeneous, that is, the elements of the list are of the same data type. Java List interface inherits from Collection, it inherits all of its operations. In addition to them, the following operations are also possible in List:

• Positional access. Each element has an index and can be manipulated based on their position. in the list. That is, you can add, exclude and modify elements.
• Search. You can find an element in a list by its content and return its index.
• Iteration. The sequential nature of List allows the use of iteration methods (listIterator).
• Range-view. The sublist method performs arbitrary range operations on the list.

Java List Methods

The above operations are exposed in the methods of the Java List interface. Here is some of them:

List implementation

Because List is an interface, programs need to create a concrete implementation of it. You can choose between the following List implementations in the Java Collections API:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

The most popular implementation of the List interface called ArrayList. Much less often, but you can still see the use of LinkedList in real tasks, but Vector and Stack have become morally obsolete for a long time, so you will most likely find them only in projects with ancient legacy code.

List Interface Declaration

You can declare a List in Java program in one of the following ways:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

It's best to declare a new list via an interface. Similarly, you can declare other implementations of List. The shortest way:

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

With such a declaration, the data type of the elements of such lists is determined during the initialization of the list, that is, when elements are added there.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

Now only strings can be added to our stack, integers to linkedList, floats to myVector, and myList is a list of characters.

How ArrayList works

If you're already familiar with regular arrays, you're also somewhat familiar with ArrayList. In fact, ArrayList is a dynamic array, and inside it is an ordinary array. This array acts as a data store. ArrayList stores only reference types, any objects, including third-party classes, strings, output streams, and other collections. Wrapper classes are used to store primitive data types in ArrayList. When creating a list, we can immediately set its size, but in most cases we do not. By default, ArrayList size = 10. What does adding a new element to an ArrayList look like? First of all, a check is started to see if there is enough space in the internal array and whether one more element will fit. If there is space, the new element is added to the end of the list, that is, to the cell that follows the last element. Its index will be arraylist.size(). If we just created our list and it is empty, this means that arrayList.size() = 0. Accordingly, a new element will be added to the cell with index 0. If it turns out that there is not enough space, a new array is created inside the ArrayList with the size (the size of the OldArray * 1.5) + 1. By the same principle, an insertion occurs in the middle of the list, but at the same time, all elements that follow the inserted element are shifted to the right. So, if we have 5 elements in the array, and we need to insert an element into cell number 2 (that is, the third one), then 0 and 1 array elements remain in place, a new element appears in cell 2, and its predecessor goes to the third cell and so on.

Java List Example (Arraylist realization)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

Here is the output of this program:

How LinkedList works

In a LinkedList, the elements are actually links in the same chain. Each element, in addition to the data it stores, has a link to the previous and next element. These links allow you to navigate from one element to another. The iterator supports traversal in both directions. Implements methods for getting, removing, and inserting at the beginning, middle, and end of a list. Allows you to add any elements including null. LinkedList implements two interfaces — not only List, but also Deque. This provides the ability to create a bidirectional queue from any elements, even null. Each object placed in the linked list is a node (node). Each node contains an element, a link to the previous and next node. In fact, the linked list consists of a sequence of nodes, each of which is designed to store an object of the type defined when it was created.

Code Example

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

The output is here:

Vector Code Example

Vector is also a dynamic array realization and is very similar to ArrayList, but synchronized and has some legacy methods that the collection framework does not contain. Here is a simple example of this class usage.

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

The output is:

Java Stack class code Example

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

Stack has not only add() and remove() methods but also push and pop, they are classical for such data structure. The stack obeys the rule “first in, last out” — this is such an anti-queue. Therefore, the pop operation pops the element that was last placed on the stack. Here is the output of our example: