It can be defined as an interface that empowers to store and fetch elements based on a key where a key can not be duplicated and can refer to at most a single value.
Map interface consists its various methods to operate with data. There are more often used methods such as put() method to add an element in a key-value pair, get() method to fetch data based on a key and, remove() method to remove an element.

Point to Remember

1) A map represents data structure that stores data in key-value pair
2) It doesn’t allow duplicate key
3) A key can only be associated to at most single value
4) It accepts null key. Only TreeMap implementation doesn’t allow null

How to create a Map Object?

Map is an interface and its implementation classes can be used to create its object. In below example, we’ve used HashMap.

Map<K,V> map = new HashMap<>();

Method of Maps

Java Program to demonstrate the basic operations of Map interface

Program:

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapExample {
    public static void main(String[] args) {
        // Creating a Map object
        Map<String,String> map  = new HashMap<>();

        // putting enteries in the map
        map.put("p","programmerbay");
        map.put("e","Example");
        map.put("a","Another");

        // Retrieving an element based on a key
        System.out.println("fetching value associated with p "+map.get("p"));


        // Iterating over Map elements

        Set<Map.Entry<String,String>> enteries = map.entrySet();

        for (Map.Entry<String,String> singleEntry:
             enteries) {
            System.out.println(singleEntry);
        }
    }
}

Output:

fetching value associated with p programmerbay
p=programmerbay
a=Another
e=Example

Implementing Classes and Interfaces of Map

There are various implementation classes and sub interfaces of Map interface.

Below are the following sub interfaces:

1) SortedMap

SortedMap is a sub interface of Map that provides a way to specify ordering on its keys. By default, keys are sorted in natural order. Further, with the help of Comparator, one can also specify custom sorting order. Additionally, keys inserted must implement Comparable interface.

2) NevigableMap

NavigableMap extends SortedMap that provides navigation methods to navigate through entries of a Map. Methods like lowerEntry, ceilingEntry, lowerKey, floorKey and higherKey are used for locating entries in a map.

Similar to NavigableSet, NavigableMap can also be traversed in both ascending or descending key order. However, if one considers performance, then ascending operations are faster than descending ones.

Below are the following implementation classes:

1) HashMap

HashMap provides a hash table based implementation to store data in key-value pair. It accepts a single null key and multiple null values. It doesn’t guarantee the order of a map. It uses a hash function to calculate the hash code, based on which the respective element get stored among the buckets. As a result, it serves constant-time performance for operations like adding and fetching data.

2) LinkedHashMap

LinkedHashMap is a subclass of HashMap that represents Hash table and linked list as its underlying data structure. It preserves the order of entries which is maintained and defined by a doubly linked list. In other words, it fetches elements in the same order in which they are previously added. It permits at most one null key.

3) IdentityHashMap

IdentityHashMap is an implementation class of Map interface that uses Hash Table as its underlying data structure. Unlike HashMap, it uses == operator to identify duplicate entries.

4) WeakHashMap

WeakHashMap is a Hash table based implementation where entries get automatically cleaned up by garbage collector when its key reference for a mapped value is no longer exist or in use.

5) TreeMap

TreeMap is a red-black tree based implementation class of Map interface. It stores elements in some specific order of its key. It doesn’t allow null key.

Basic Operations in Map

There are various operations that can be performed on data. Below are some frequently used operations.
1) Adding elements
2) Updating elements
3) Removing elements
4) Iterating over elements
5) Retrieving element

1) Adding elements

put() and putIfAbsent() method can be used to add element in a map. Both methods are used in different situations
put(k,v) : It adds single element to a given map. It returns null, indicating that no key mapping is exist
putAll(Map obj) : It adds all the elements consisting in passed Map Object.
putIfAbsent(k,v) : It is similar to put() method but only adds elements if the given key mapping is not present in the targeted map

Program:

import java.util.HashMap;
import java.util.Map;

public class MapExample {
public static void main(String[] args) {
// Creating a Map object
Map<String,String> map = new HashMap<>();
// putting entries in the map
map.put("p","programmerbay");

// Printing Map elements
System.out.println(map);


Map<String,String> differentMap = new HashMap<>();
differentMap.put("e","example");

// Adding element to Map elements
map.putAll(differentMap);

// Printing Map elements
System.out.println(map);

// putIfAbsent is used to add element
map.putIfAbsent("c","code ");

// Printing Map elements
System.out.println(map);

}
}

Output:

{p=programmerbay}
{p=programmerbay, e=example}
{p=programmerbay, c=code , e=example}

2) Updating elements

put() is also used to update the existing key mapping in a map. It returns old key-value existing mapping if present in the map, otherwise, null. In other words, put() replaces an entry if passed key already is present, otherwise, add-operation is performed.

Program:

import java.util.HashMap;
import java.util.Map;

public class MapExample {
public static void main(String[] args) {
// Creating a Map object
Map<String,String> map = new HashMap<>();
// putting entries in the map
map.put("p","programmerbay");

System.out.println(map);

// updating existing key
map.put("p","updated");

System.out.println(map);

}
}

Output:

{p=programmerbay}
{p=updated}

3) Removing elements

remove() method is used to delete a key value pair from a map. There are various overloaded methods of remove.
remove(k) : It removes a key-value mapped with given key in a map
remove(k,v) : It removes a key-value pair present that matches with provided key and value.

Program:

import java.util.HashMap;
import java.util.Map;

public class MapExample {
public static void main(String[] args) {
// Creating a Map object
Map<String,String> map = new HashMap<>();
// putting entries in the map
map.put("p","programmerbay");

System.out.println(map);

// remove existing key
map.remove("p","programmerbay");

System.out.println(map);

}
}

Output:

{p=programmerbay}
{}

4) Iterating over elements

Enhanced forEach() can be used to iterate over elements. In order to iterate through a map, first one needs to get its all entries using entrySet() method.

Program:

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapExample {
    public static void main(String[] args) {
        // Creating a Map object
        Map<String,String> map  = new HashMap<>();
        // putting entries in the map
        map.put("p","programmerbay");
        map.put("c","code");
        map.put("e","example");



        Set<Map.Entry<String,String>> enteries = map.entrySet();

        for (Map.Entry<String,String> singleEntry:
             enteries) {
            System.out.println(singleEntry);
        }
    }
}

Output:

p=programmerbay
c=code
e=example

5) Retrieving element

get() method is used to retrieve value associated with a key. It accepts key name based on which the associated value is retrieved.

Program:

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        // Creating a Map object
        Map<String,String> map  = new HashMap<>();
        // putting entries in the map
        map.put("p","programmerbay");

        System.out.println(map);

        // diplaying value based on key
        System.out.println(map.get("p"));

    }
}

Output:

{p=programmerbay}
programmerbay

Syntax:

Set<T> set = new TreeSet<T>();

It stores elements in natural sorting order using compareTo() method of Comparable interface. It also allows custom sorting order with the help of compare() method of Comparator interface.

It provides various methods that are inherited from Navigable,SortedSet and Set interface.

Point to remember:

1. It uses self balancing tree as its underlying data structure
2. It doesn’t allow Duplicate elements

3. It doesn’t preserve insertion order

4. It stores data in some sorting order
5. Only comparable or same type of elements are allowed

6. It is not thread safe

7. It provides non synchronised implementation of Set

TreeSet an implementation of Binary Search Tree

TreeSet class uses self balancing binary search tree as its underlying data structure which makes it one of the efficient implementations for storing large data set in ordered manner. It takes logarithmic average and worst case time when it comes to perform basic operations such as add, delete and search.

TreeSet is not Thread Safe

It is also important to know that TreeSet provides non synchornized implementation which allow multiple threads to access a tree set object concurrently. It can lead to uncertain behaviour as more than one threads can operate on that object at the same time. It is possible to make a tree set synchronized. With the help of Collection.synchronizedSortedSet() method we can encapsulate a set in a synchronized object or wrapper.

Syntax :

Set<T> treeSet = new TreeSet<>();
Set synchronized = Collections.synchronziedSet(treeSet);

TreeSet NULL Acceptance

If  a treeSet is non empty Set, then by default we are going to get null pointer exception while trying to insert null value. It occurs because of the comparison with other elements.

For empty TreeSet, null value can be accepted

Constructors of TreeSet Class

There are four constructors support by TreeSet class.

1) TreeSet()

A default constructor that creates an empty tree set object with default natural sorting order

TreeSet<T> t = new TreeSet<T>()

2) TreeSet(Comparator c)

It creates an empty tree set instance with custom specified order defined using Comparator .

TreeSet<T> t = new TreeSet(Comparator c);

3) TreeSet(Collection obj)

It creates a tree set instance with the elements present in the collection object and order them in nature order.

TreeSet<T> t = new TreeSet<>(Collection obj)

4) TreeSet(SortedSet obj)

Similar to previous constructor, the constructor accepts a collection object which is in this case, is SortedSet and creates an tree set instance with all the elements present in that collection in natural order.

TreeSet<T> t = new TreeSet<T>(Sorted obj)

Methods of TreeSet Class

Comparable Interface Vs Comparator Interface

If the empty tree set is created with default constructor, then the elements should be of same type and comparable, otherwise, ClassCastingException would be triggered by the Java compiler. Objects that implements Comparable interface are called comparable.

Comparable Interface

• It resides in Java.lang package
• It contains only single method, named compareTo()
• It returns int value, as it decides whether an element, greater, equal or smaller than other

obj1.compareTo(obj 2)

1.  -ve obj1 should come before obj2
2.  +ve obj1 should come after obj2
3.  0 both obj1 and obj2 are equal

Comparator Interface

If a custom implementation is required, we can use Comparator, not Comparable.

• It is used for customised sorting order
•  It resides in Java.util packages
•  It contains 2 methods, compare() and equals()
•  compare() also returns int.
• It uses same comparison approach as compareTo() method
•  It is compulsory to provide implementation of compare method but, equals() implementation is optional as it’s root class method
• Using Comparator, we can use non comparable objects in tree set

A tree set can have duplicate elements if we use Comparator to implement the sorting or insertion changes.

Java Program to arrange and print elements of TreeSet in descending order with the help of Comparator

Program:

import java.util.*;

public class SetExample implements Comparator<Integer>{
    public static void main(String[] args) {

        Set<Integer> treeSet = new TreeSet<>(new SetExample()); // creating a treeSet instance that holds integers

        // Adding elements to linked hash set
        treeSet.add(5);
        treeSet.add(1);

        treeSet.add(2);
        treeSet.add(100);
        treeSet.add(101);


        // Iterating using for each

        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
    
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2-o1;
    }
}

Output:

101
100
5
2
1

Points to Remember:

1) Hash Table and Linked List are its underlying data structure

2) It extends HashSet class and implements Set interface
3) It preserves insertion order
4) It permits only unique elements, similar to HashSet
5) It allows at most single null value
6) It offers a constant time performance for all the basic operations
7) It is less expensive than HashSet when comes to iterating over elements

Syntax:

Set<T> set = new LinkedHashSet<T>();

It is an implementation class that uses hash table and linked list data structure as its underlying data structure. It differs from HashSet with the exception that it maintains a doubly linked list to all the elements. It preserves insertion order with the help of a linked list which defines iteration order and makes sure the elements must be retrieved in the same order as they were previously inserted. It allows a single null element. It provides constant time performance for the basic operations.

There are 4 constructors provided in LinkedHashSet class:

1) LinkedHashSet()

A default constructor to create an empty linked hash set with default initial capacity and load factor.

LinkedHashSet<T> linkedHashSet = new LinkedHashSet<T>();

2) LinkedHashSet(collectionObj) 

It creates a new linked hash set having elements present in passed collection object.

ArrayList<T> list = new ArrayList<>();

LinkedHashSet<T> linkedHashSet = new LinkedHashSet<T>(list);

3) LinkedHashSet(int initialCapacity) :

It creates an empty linked hash set with specified capacity and default load factor.

LinkedHashSet<T> linkedHashSet = new LinkedHashSet<T>(4);

4) LinkedHashSet(int initialCapacity, float loadFactor):

It creates an empty linked hash set with mentioned capacity and load factor.

LinkedHashSet<T> linkedHashSet = new LinkedHashSet<T>(4,0.8);

Methods of LinkedHashSet Class

Java Program to create LinkedHashSet instance and demonstrate its basic operations

Program:

import java.util.*;

public class SetExample {
    public static void main(String[] args) {

        Set<Integer> linkedHashSet = new LinkedHashSet<>(); // creating a linked hashset instance that holds integers

        // Adding elements to linked hash set
        linkedHashSet.add(5);
        linkedHashSet.add(1);
        linkedHashSet.add(null);  // adding nul value
        linkedHashSet.add(100);

        // Displaying Stored elements
        System.out.println(linkedHashSet);

        // removing null element from linked hash set

        linkedHashSet.remove(null);

        //Displaying after removing null

        System.out.println(linkedHashSet);

        // iterating through hash set

        Iterator iterator = linkedHashSet.iterator(); // getting iterator object
        System.out.println("Iterating over all the element of linked hash set :: ");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }


    }
}

Output:

[5, 1, null, 100]
[5, 1, 100]
Iterating over all the element of linked hash set :: 
5
1
100

Basic Operations of LinkedHashSet

1) Adding element

HashLinkedSet supports add() and addAll() method to add elements in a given set

add(element) : It adds a given element to the set
addAll(collectionObj): It adds all the elements provided in collection object.

Java program to demonstrate add operation in LinkedHashSet

Program:

import java.util.*;

public class SetExample {
public static void main(String[] args) {

Set<Integer> linkedHashSet = new LinkedHashSet<>(); // creating a linked hashset instance that holds integers

// Adding elements to linked hash set
linkedHashSet.add(5);
linkedHashSet.add(1);

// Displaying Stored elements
System.out.println(linkedHashSet);

// add All method to add multiple elements

linkedHashSet.addAll(Arrays.asList(100,101,102,103));

//Displaying after addAll

System.out.println(linkedHashSet);


}
}

Output:

[5, 1]
[5, 1, 100, 101, 102, 103]

2) Removing element

There are two methods namely, remove() and removeAll() used for removing single or multiple elements from a set.
remove(element) : It removes the given element from the given set.
remove(collectionObj) : It removes all the elements present in the collection object from the given set.

Java program to demonstrate remove operation in LinkedHashSet

Program:

import java.util.*;

public class SetExample {
public static void main(String[] args) {

Set<Integer> linkedHashSet = new LinkedHashSet<>(); // creating a linked hashset instance that holds integers

// Adding elements to linked hash set
linkedHashSet.add(5);
linkedHashSet.add(1);

linkedHashSet.add(2);
linkedHashSet.add(100);
linkedHashSet.add(101);
linkedHashSet.add(102);
// Displaying Stored elements
System.out.println(linkedHashSet);

// removing single element the linked hash set

linkedHashSet.remove(2);

System.out.println("Removed 2 :: "+linkedHashSet);

// removeAll for remove multiple elements

linkedHashSet.removeAll(Arrays.asList(100,101,102));

//Displaying after removeAll

System.out.println("Removed 100, 101,102 from set :: "+linkedHashSet);


}
}

Output:

[5, 1, 2, 100, 101, 102]
Removed 2 :: [5, 1, 100, 101, 102]
Removed 100, 101,102 from set :: [5, 1]

3) Iterating over elements

There are multiple ways to iterate over a linked hash set. These are the following :-
1) iterator()
2) forEach()
3) Using Java 8 streams

Java program to demonstrate iteration operation over elements of a linked hash set object

Program:

import java.util.*;

public class SetExample {
public static void main(String[] args) {

Set<Integer> linkedHashSet = new LinkedHashSet<>(); // creating a linked hashset instance that holds integers

// Adding elements to linked hash set
linkedHashSet.add(5);
linkedHashSet.add(1);

linkedHashSet.add(2);
linkedHashSet.add(100);
linkedHashSet.add(101);

// Iterating using for each

System.out.println("Iterating using foreach :: ");
for (Integer element:
linkedHashSet) {
System.out.println(element);
}

// Iterating using iterator object
System.out.println("Iterating using iterator :: ");

Iterator iterator = linkedHashSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}

System.out.println("Iterating using stream :: ");

linkedHashSet.stream().forEach(e-> System.out.println(e));
}
}

Output:

Iterating using foreach ::
5
1
2
100
101
Iterating using iterator ::
5
1
2
100
101
Iterating using stream ::
5
1
2
100
101

SortedSet<T> set = new TreeSet<T>();

Program:

import java.util.*;

public class SetExample {
    public static void main(String[] args) {
        SortedSet<String> sortedSet = new TreeSet<>() ;  // Creating sortedSet object

        // Adding elements to sorted set object
        sortedSet.add("Example");
        sortedSet.add("Code");
        sortedSet.add("A");

        // Displaying the output
        System.out.println(sortedSet);

        // Removing A element from the set
        sortedSet.remove("A");

        System.out.println(sortedSet);

        // printing first element from the set
        System.out.println(sortedSet.first());

        // printing last element from the set
        System.out.println(sortedSet.last());
    }
}

Output:

[A, Code, Example]
[Code, Example]
Code
Example

Methods of SortSet Interface

It provides several essential methods that can be used to store, manipulate and search elements in a given set. It depicts a mathematical set and provides its abstraction.

There are various methods which implement the Set interface, including HashSet, LinkedHashSet and TreeSet.
SortedSet and NavigableSet interfaces further extend Set Interface that provides additional behaviour and different implementation to the existing method. NavigableSet is a child interface of SortedSet that provides navigational methods to navigate through a Set. It has a child class named TreeSet which is an implementation of the self-balancing tree.

How to declare and initialise a Set Object in Java?

Set interface provides specification only, in order to create its object, one requires its implementing class i.e HashSet,TreeSet, in order to create an object. With the help of Generics, we can specify the type of object that a Set Collection can store.

Set<T> set = new HashSet<T> ();

Point to Remember:

• It doesn’t preserve order of inserted elements
• It allows at most single null element
•  It doesn’t allow duplicate elements
• It can have elements of different types

Methods of Set Interface

The methods supported by Set Interface are listed below :

Java Program to demonstrate working of Set interface

Program:

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>() ;  // Creating set object
        set.add("The");
        set.add("Programmerbay");
        set.add("Code");
        set.add("Example");

        System.out.println("Printing Added element :: "+set);
        set.add("Code");  //  Adding duplicate element
        System.out.println("Duplicate element not present :: "+set);
        set.remove("Example");  //  Removing duplicate element
        System.out.println("Removing 'Example' element :: "+set);


    }
}

Output:

Printing Added element :: [The, Example, Code, Programmerbay]
Duplicate element not present :: [The, Example, Code, Programmerbay]
Removing 'Example' element :: [The, Code, Programmerbay]

Basic Operations Supported by Set and Its implementing Classes

1) Add Elements :

Set interface specifies add(object) and addAll(CollectionObj) to add elements to a set. It doesn’t preserves insertion order of inserted elements. In contrast, it uses hashing mechanism to store elements where a hash of an element is generated and stored in a hash table. As mentioned before, it doesn’t allow duplicates, but accepts atmost single null value.

Java program to add single element and multiple elements in a Set using add() and addAll() method

Program:

public class SetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>() ; // Creating set object
Collection<String> collection = List.of( "Another","Collection","inserted");

set.add("Programmerbay");

System.out.println("Single Added element :: "+set);

set.addAll(collection); // Adding collection elements, but order will not be preserved

System.out.println("Collection added to set :: "+ set);

}
}

Output:

Single Added element :: [Programmerbay]
Collection added to set :: [inserted, Collection, Programmerbay, Another]

2) Remove Elements:

Set interface offers three methods for this, however, all have different use cases.
1) remove() -> It removes a single element
2) removeAll() -> It accepts a collection object and removes all elements that match the targeted set.
3) retainAll () -> Opposite to removeAll(), it accepts a collection object and persists only those elements that match with the provided collection, other elements that are present in the targeted set get removed.

Java program to remove single element and multiple elements in a Set using remove() and removeAll() method

Program:

public class SetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>() ; // Creating set object
Collection<String> retainObjs = List.of("Programmerbay","Code");
Collection<String> removeAllObj = List.of("Remove1","Remove2");

// Adding random elements
set.add("Remove Me");
set.add("Remove1");
set.add("Remove2");
set.add("Programmerbay");
set.add("Example");
set.add("The");
set.add("Code");


System.out.println("Elements :: "+set);

// removing 'remove Me' from the list
set.remove("Remove Me");

System.out.println("After single remove :: "+set);

set.removeAll(removeAllObj); // remove1 and remove2 stored in removeAllObj would remove elements in set

System.out.println("after removeAll() :: "+ set);

set.retainAll(retainObjs); // Programmerbay and Code stored in reainAllObj would store elements and remove others from the set

System.out.println("after retainAll() :: "+ set);

}
}

Output:

Elements :: [The, Remove1, Remove2, Remove Me, Example, Code, Programmerbay]
After single remove :: [The, Remove1, Remove2, Example, Code, Programmerbay]
after removeAll() :: [The, Example, Code, Programmerbay]
after retainAll() :: [Code, Programmerbay]

4) Iterate over Elements:

There are multiple ways to iterate over elements of a set. These are the following:
1) using iterator
2) Using forEach()
3) Using Java 8 Stream

Java program to iterate over elements of a set.

program:

public class SetExample {
public static void main(String[] args) {
Set<String> set = new HashSet<>() ; // Creating set object

// Adding random elements
set.add("Remove Me");
set.add("Remove1");
set.add("Remove2");
set.add("Programmerbay");
set.add("Example");
set.add("The");
set.add("Code");

Iterator iterator = set.iterator(); // fetching iterator object of the set

System.out.println("Iterating through iterator object :: ");
while (iterator.hasNext()){
System.out.println(iterator.next());
}


// using for each
System.out.println("Iterating through for each loop :: ");

for (String element:
set) {
System.out.println( element);
}

// using Java 8 Stream
System.out.println("Iterating through using java 8 stream :: ");

set.stream().forEach(e -> System.out.println("element :: "+ e));

}
}

Output:

Iterating through iterator object ::
The
Remove1
Remove2
Remove Me
Example
Code
Programmerbay
Iterating through for each loop ::
The
Remove1
Remove2
Remove Me
Example
Code
Programmerbay
Iterating through using java 8 stream ::
element :: The
element :: Remove1
element :: Remove2
element :: Remove Me
element :: Example
element :: Code
element :: Programmerbay

Implementing Classes of Set Interface

HashSet class : Hashset class is a implementing class of Set interface that uses hash table as its underlying data structure. It doesn’t preserves insertion order,meaning, the order in which elements are inserted may differ as it hash code to insert data. It accepts null values.

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>() ;  // Creating set object
        set.add("Programmerbay");
        set.add("Example");
        System.out.println(set);
    }
}

Output:

[Example, Programmerbay]

LinkedHashSet class : It also implements Set interface and exhibits the behavior of doubly linked list. Unlike HashSet, it preserves insertion order.

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<>() ;  // Creating set object
        set.add("Programmerbay");
        set.add("Example");
        System.out.println(set);
    }
}

Output:

[Programmerbay, Example]

TreeSet class : It is a implementation class of SortedSet interface. It resembles tree data structure to store and manage data. It stores data in natural sorting order.

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>() ;  // Creating set object
        set.add("Programmerbay");
        set.add("Example");
        System.out.println(set);
    }
}

Output:

[Example, Programmerbay]

Point to Remember:

1. It preserves insertion order and duplicates are allowed.

2. It accepts different types of objects and null insertions.

3. Similar to ArrayList, it is growable in nature, meaning, its size can shrink or grow dynamically.

4. It is best choice when insertion and deletion operations are involved mostly.

5. It resembles doubly linked list data structure which provides flexibility to implement other algorithms and data structure such as Stack,Queue and more.

6. It has the worst performance in case of fetching or accessing an element from the list as it provides linear-time performance.

7. It implements Serializable and Clonable interface but not RandomAccess interface.

8. It is not thread-safe, which means that multiple threads cannot safely access and modify the list at the same time.

9. It becomes slower than other List implementations when it comes to traversing over elements.

Method of Linked List Class

Linked List implements List and Deque interface. Therefore, there are several methods implemented by this class.

Below are the methods inherited from Deque.

Below are the methods is from List interface.

Constructors of Linked List

There are two constructor present in Linked list class. These constructors are explained below :-

1) new LinkeList()

It is a default constructor that creates an empty linked list. Unlike ArrayList, it doesn’t have capacity issue.

Syntax:

LinkedList<T> l = new LinkeList<>() :

2) new LinkedList(Collection obj)

It creates a linked list instance, consisting elements of the given collection object.

LinkedList l = new LinkedList(Collection obJ);

Operations in LinkedList Class

1) Add an element

There are several methods provided by LinkedList class to add an element, such as add(), addFirst(),addList(),push(),offerFirst() and more.
Among all, add() and addAll() methods are most commonly used methods to perform add operation.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");

// Displaying elements of the list
System.out.println(linkedList);

// addAll method to add list of elements
linkedList.addAll(Arrays.asList("element1","element2"));
System.out.println(linkedList);

}
}

Output:

[Programmerbay, Example]
[Programmerbay, Example, element1, element2]

2) Replace an element

LinkedList supports index based access which provides it the capability to update or replace an element at given position .
set() method is used for the purpose. Below is the code example.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");

// Displaying elements of the list
System.out.println(linkedList);

// set method to replace an element with new one
linkedList.set(1,"Removed") ; // Example would be replaced with Removed

System.out.println(linkedList);

}
}

Output:

[Programmerbay, Example]
[Programmerbay, Removed]

3) Remove an element

Like several add() methods, LinkedList supports several methods to remove an element from a list i.e remove(),removeFirst(),removeLast() , pop() and more. The most commonly used methods are remove() and removeAll(). Below is a code example

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");
linkedList.add("Test");


// Displaying elements of the list
System.out.println(linkedList);

// remove(element) method to remove the given element
linkedList.remove("Test"); // element Test would be removed

System.out.println(linkedList);


// remove(index) method to remove element from the given index

linkedList.remove(1); // element would be removed, sitting at 1st index which is example in this case
System.out.println(linkedList);
}
}

Output:

[Programmerbay, Example, Test]
[Programmerbay, Example]
[Programmerbay]

4) Traverse or iterate over elements

Like other implementation classes of List interface, elements of a linked list can also be traversed through various ways, iterator object and forEach are some of them.

With the help of iterator, we can traverse through all the elements in the given linked list. Also, enhanced for loop can also be used to loop through elements. Below are the code example.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list

// Adding elements to linked list

linkedList.add("Programmerbay");
linkedList.add("Example");
linkedList.add("Test");

// traversing element using iterator object
System.out.println("Traversing using iterator :: ");

Iterator iterator = linkedList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

// traversing element using for each method
System.out.println("Traversing using for each :: ");
for (String str:
linkedList) {
System.out.println(str);
}


}
}

Output:

Traversing using iterator ::
Programmerbay
Example
Test
Traversing using for each ::
Programmerbay
Example
Test

5) Converting List to Array

toArray() method provides the capability to convert a given linked list to array of objects. Below is the code example.

Program:

public class ArrayListExample {
public static void main(String[] args) {
ArrayList<String> linkedList = new ArrayList<>(); // creating instance of linked list
linkedList.add("Programmerbay");

System.out.println("List view :: "+ linkedList);
Object[] array = linkedList.toArray();

System.out.println("Array view :: ");
for (Object obj:
array) {
System.out.print(obj);
}
}
}

Output:

List view :: [Programmerbay]
Array view :: 
Programmerbay

Further, it provides only a default constructor to create an empty stack object.

One of the main use case of the Stack class is to reverse a sequence of elements. This can be done by pushing elements onto the stack and then popping them off one by one from the top.

The collection class provides various methods for manipulating elements present in the stack, such as push(), pop(), peek(), and empty().

Methods Of Stack Class

push(): The push method is used to add an element to the top of the stack

pop(): The pop method is used to remove and return the element at the top.

peek(): The peek method returns the element at the top without removing it.

empty(): It returns true if the stack is empty, otherwise, false.

search(): It searches an element, and returns offset, otherwise, -1 to signify not found.

Other Inherited Methods

Here’s a program example to reverse a sequence of integers using Stack:

Program: 

import java.util.Stack;

public class Main
{
  public static void main (String[]args)
  {
    Stack < Integer > stack = new Stack <> ();
    stack.push (1);
    stack.push (2);
    stack.push (3);
    stack.push (4);
    while (!stack.empty ())
      {
  System.out.println ("Element :: "+ stack.pop ());
      }
  }
}

Output:

Element :: 4
Element :: 3
Element :: 2
Element :: 1

Over Stack class, the Deque interface should be used as it provides a more complete and flexible API. The Deque interface extends the Queue interface and supports both LIFO and First-In-First-Out (FIFO) operations. The ArrayDeque class implements the Deque interface which is a resizable array and is a good choice for most use cases.

import java.util.ArrayDeque;
public class Main
{
  public static void main (String[]args)
  {
    ArrayDeque < Integer > deque = new ArrayDeque <> ();
    deque.push (1);
    deque.push (2);
    deque.push (3);
    deque.push (4);
    while (!deque.isEmpty ())
      {
  System.out.println ("Element :: "+deque.pop ());
      }
  }
}

Element :: 4
Element :: 3
Element :: 2
Element :: 1

It is similar to ArrayList, but is synchronized  and supports legacy methods which duplicates the behaviour of methods defined by Collection Framework.  It implements Serializable and RandomAccess interface. Its most of the methods are thread safe.

It is a legacy class and fully compatible with Collection, meaning one can use enhanced for loops to iterate through its elements.

Points to Remember

1) Its underlying data structure is dynamic array. It has the capability to grow or shrink as required. Like array, it uses zero  based index to access, add, delete, and update an element.

2) It is a legacy class, as a result, it supports legacy methods along with predefined methods by Collection framework. Further, it is synchronized.

3) It preserves insertion order that signifies all elements get stored in same order in which they inserted

4)  It can be used where multiple threads require to perform operations on same list. However, it can impact performance inversely, since, it’s synchronized.

Constructors of Vector

1. Vector v = new Vector();

The default constructor that creates the list with initial capacity of 10.

When vector crosses its capacity, a new vector object is created by the compiler and the values of first vector object is copied to new one. Lastly, reference variable starts pointing to new one and old reference becomes eligible for garbage collection.

How to calculate the capacity of vector?

capacity of new vector = 2 * current capacity

2. Vector v = new Vector(int capacity);

The constructor creates a vector with the given capacity provided in parameter.

3. Vector v = new Vector(int initialCapacity, int incrementalCapacity);

It creates a vector with initial capacity provided in the parameter. The incrementalCapacity specifies the new incremental capacity every time when the list resized  to be allocated .

4.Vector v = new Vector(Collection obj);

It creates equivalent list similar to the collection object provided in the constructor.

Methods in Vector

• addElement(Object obj): Insert an element to the end of the list.
• removeElement(Object obj): Removes the very first occurrence of the given element
• insertElementAt(Object obj, int indx): Inserts the given element at the specified position, moving elements greater than that index by 1.
• removeElementAt(int indx): Deletes the element at the specified index.
• setElementAt(Object obj, int indx): Replaces the element at the specified position with the specified element.
• elementAt(int indx): Returns the element at the given position.
• firstElement(): Returns the first element in the list.
• lastElement(): Returns the last element in the list.
• copyInto(Object[] o):  Copies elements to the given arrays passed as parameter.
• indexOf(Object o): Returns the index of the first occurrence of the specified element.
• trimToSize(): Reduces the capacity of the given vector to the current size.
• ensureCapacity(int minCapacity): Increases the capacity to ensure that the list can hold at least the specified number of elements.
• setSize() : Set the size of the given vector, storing null values to new empty spaces.
• capacity(): Returns the current capacity of the vector.

Disadvantages of using Vector Class

Point to Remember

1. It is a growable array
2. It allows duplicate elements
3. It preserves insertion order
4. It can store different types of elements
5. It can have null values
6. It resides in java.util package
7. By default, it is non synchronized class
8. It is not thread safe
9. It uses zero-based index to access, add, delete and update an element
10. If frequent operation is retrieve operation, then arrayList is best choice.
11. If insertion and removal in middle is the operation then arrayList is worst choice.
12. It doesn’t work with primitive types

Constructors in ArrayList

There are three constructors associated with ArrayList to create its objects.

1. new ArrayList() : A default constructor that takes no input and creates an empty list with default capacity. By default, it intializes with capacity of 10, meaning, it can hold 10 elements.

However,when an eleventh element is inserted in a list. JVM automatically generates a larger list with greater capacity and copies the element from old one to new one. Further, it changes reference variable to point to the new list, making old list eligible for garbage collection.

How to calculate capacity of ArrayList?

This is the formula used to calculate new capacity of an arrayList
new Capacity = (current capacity * 3/2)+1

ArrayList<ObjType> arr = new ArrayList<>();

2. new ArrayList ( int capacity) : A parameterised constructor that takes capacity as an input and creates an empty list with provided initial capacity.

ArrayList<ObjType> arr = new ArrayList<>(capacity);

3. new ArrayList (Collection c) : The constructor takes collection object as an input and creates an equivalent list from the given collection

ArrayList<ObjType> arr = new ArrayList<>(c);

The purpose of collection is to hold a group of data that can be transferred from one place to another place, it can be over the network or data sources. In order to provide this support, it is compulsory to implement serializable interface. Therefore, all the collection implementation classes implements serializable class.

Further, Arraylist and Vector implements RandomAccess interface that signifies accessing any element using index which takes same time.
RandomAccess interface is present in java.util packages and doesn’t consist any method. It’s a marker interface.

How to define an ArrayList?

ArrayList implements List interface and is a generic class with below definition:

ArrayList<ObjType> list = new ArrayList<>();

• ObjType is any non-primitve dataType
• new keyword is used to allocate memory and create an object.
• ArrayList<>() is default constructor

Methods in Java ArrayList

Operations in ArrayList

There are various operations can be performed on a ArrayList. These are

1. Element addition
2. Element updation
3. Element deletion
4. Element traversal
5. Element access
6. Element sorting

1. Adding an element in an Array

ArrayList provides implementation to add() method inherited from List interface. There are overloaded versions of add() method.

add(obj) : It appends an element to the end of a list
add(indx,obj) : It adds an element at the given position in a list

Below is the simple java program to add an element in an ArrayList

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
ArrayList<Integer> integerArrayList = new ArrayList<>();
integerArrayList.add(5);
integerArrayList.add(10);
integerArrayList.add(1);
System.out.println("The list content :: "+ integerArrayList);
}
}

Output:

The list content :: [5, 10, 1]

2. Updating or replacing an element in an ArrayList

ArrayList provides set() method to set or replace an element at given position. The method takes index and the element as an input to replace and uses the index to locate the position and replaces the element with new value.

set(indx, obj) : It replaces an element at the given position with the new element.

Below is the simple java program to replace or update an element in an ArrayList

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
ArrayList<Integer> integerArrayList = new ArrayList<>();
integerArrayList.add(5);
integerArrayList.add(10);
integerArrayList.add(1);
System.out.println("The list :: "+ integerArrayList);

integerArrayList.set(1,100); // replacing element (10) at index 1 with 100

System.out.println(integerArrayList);
}
}

Output:

The list content :: [5, 10, 1]

3. Deleting an element from an ArrayList

remove() method is used to delete an element from a list. It has multiple overloaded versions. These are :

remove(obj) : It deletes very first occurrence of the matched object in a list.
remove(int indx): It deletes an element located at a given position or index

Below is the simple Java program to delete or remove an element from an ArrayList

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
ArrayList<Integer> integerArrayList = new ArrayList<>();
integerArrayList.add(5);
integerArrayList.add(10);
integerArrayList.add(1);
System.out.println("The list :: "+ integerArrayList);

integerArrayList.remove(1); // removing element (10) at index 1

System.out.println(integerArrayList);
}
}

Output:

The list :: [5, 10, 1]
[5, 1]

4. Iterating over elements of an ArrayList

All the collection framework classes indirectly implements Iterable interface. The iterable interface provides various methods which empowers iterating ArrayList. These are :

Iterator() : It returns Iterator Object. It provides a way to iterate over a list
forEach(Consumer action) : It iterates and performs action over each element until all the element are processed.

Apart from this, for-each or advance for loop can be used to iterate through elements of a list

Below is the simple Java program to iterate through an ArrayList

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
ArrayList<Integer> integerArrayList = new ArrayList<>();
integerArrayList.add(5);
integerArrayList.add(10);
integerArrayList.add(1);

System.out.println(" Iterating through iterator :: ");
Iterator itr = integerArrayList.iterator(); // getting iterator object from arraylist instance
while(itr.hasNext()) // while the list has the content, do
{
System.out.println(itr.next()); // returns the current element and moves the iteration state to next element
}

System.out.println(" Iterating through forEach :: ");
integerArrayList.forEach(System.out::println); // Java 8 forEach with lambda exp

System.out.println(" Iterating through for-each :: ");

for (Integer val:
integerArrayList) {
System.out.println(val);
}

}
}

Output:

Iterating through iterator ::
5
10
1
Iterating through forEach ::
5
10
1
Iterating through for-each ::
5
10
1

5. Fetching an element from an ArrayList

ArrayList uses zero-based index in order to access an element. It provides a method named get() that takes index as an input and returns the element at that position

get(indx) : returns an element at the given position

Below is the simple Java program to get or fetch an element from an ArrayList

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
ArrayList<Integer> integerArrayList = new ArrayList<>();
integerArrayList.add(5);
integerArrayList.add(10);
integerArrayList.add(1);

System.out.println("Fetching element at index 2 :: "+ integerArrayList.get(2));

}
}

Output:

Fetching element at index 2 :: 1

7. Sorting elements in an ArrayList

Sort() method is used to sort a list in ArrayList. It takes comparator as an input and applies on elements to achieve sorting.

sort(Comparator c): sorts elements in a list

Below is the simple java program to sort an ArrayList

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
ArrayList<Integer> integerArrayList = new ArrayList<>();
integerArrayList.add(5);
integerArrayList.add(10);
integerArrayList.add(1);
System.out.println("before sorting :: "+integerArrayList);

integerArrayList.sort(Comparator.comparingInt(Integer::intValue));
System.out.println("after sorting :: "+integerArrayList);

}
}

Output:

before sorting :: [5, 10, 1]
after sorting :: [1, 5, 10]

How to get length or size of an ArrayList?

size() method is used to get length or size of an array in arrayList.

size() : returns length of a list

integerArrayList.size();

It defines listIterator() method which returns ListIterator object which empowers the implementing classes to able to traverse their collection objects in both directions, forward and backward.

ArrayList,LinkedList, Stack and Vector are the implementing classes of List interface. Vector class is the legacy class in the List hierarchy.

It allows index based element access and also can be used to insert an element using its position in the given list using zero based index.
A list can contain duplicate elements. It defines its own methods that is specifically made for List implementing classes.

Important Notes

1. It is an ordered collection, meaning, elements are stored the manner in which they are inserted. Therefore, it preserves the insertion order.
2. It uses zero based index in order to access, insert and search element in the list
3. It allows duplicate elements
4. It accepts and stores elements of different types

Method of List Interface

Since, it is child interface of Collection, therefore, it has access all of its method. Apart from this, List interface defines its own methods. The methods and explanations are given below

Classes that implements List interface

These are the following classes that implements List Interface
1. ArrayList
2. LinkedList
3. Vector
4. Stack

ArrayList

ArrayList resembles dynamic array behaviour in Collection framework. It provides a way to overcomes from fixed size problem of standard arrays. Apart from that, it supports several predefined methods and also uses zero-based index to access, remove or retrieve an object from a list. In other words, it is an array list with growable size functionality.

Vector

Vector is a legacy class in Collection framework. Its underlying data structure is also growable array. It uses zero based index in order to operate on objects and its size can be grow or shrink on runtime based on objects in the list.

Stack

Stack is a child class of Vector. As name suggest, its behaviour resembles Stack data structure. It follows basic principle of Stack which is last in first out. Apart from this, it offers various inbuilt methods to perform basic Stack operation, involving, push(), pop() and peak().

LinkedList

LinkedList implements Linked list data structure in Collection framework. It uses addresses to locate and form a sequence of elements that are stored at different location. In this, each element is termed as node which keep data and address of next or previous element.
It can be considered where insertion and deletion, are frequent operation.

How to declare and define a List?

A List interface only declares behaviour, but not implementation. It is not possible to create its object. Therefore, a List can only hold reference of its implementing classes object. Since, it use Generics concept, therefore, it is controllable to define which type of object a list can hold.

Syntax:

List<Obj> listRef = new ArrayList<>();
List<Obj> listRef = new Stack<>();
List<Obj> listRef = new Vector<>();
List<Obj> listRef = new LinkedList<>();

Obj represents the Type of object the list can hold

Below is the simple Java program to declare a list.

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
List<String> list = new ArrayList<>(); // list is a reference variable that can hold object of List Type or its implementing classes
list.add("Viewer"); // added single element in the list
System.out.println(list); // printing the output
}
}

Output:

[Viewer]

Basic Operations that List Interface provides

1. Adding elements to the List

List provides add() and addAll() methods in order to add elements in the list.

Syntax:

add(Object obj) : It adds element to the end of the list
add(int indx,Object obj) : It adds element on specified position
addAll(Collection c) : It adds another list at the end of the list

Below is the simple Java program to add elements in the list

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
List<String> list = new ArrayList<>(); // list is a reference variable that can hold object of List Type or its implementing classes
list.add("Viewer"); // added single element in the list
list.add("Viewer2"); // added single element in the list
System.out.println(list); // printing the output

list.add(1,"inserted"); // added element at first position
System.out.println(list);

List<String> anotherList = new ArrayList<>();
anotherList.add("another list content1") ;
anotherList.add("another list content2") ;

list.addAll(anotherList); // adding all elements of another list
System.out.println(list);

}
}

Output:

[Viewer, Viewer2]
[Viewer, inserted, Viewer2]
[Viewer, inserted, Viewer2, another list content1, another list content2]

2. Updating elements to the List

List provides set() and replace() method to update the elements of a list.

set(int index, Obj element) : It updates or replaces element in the list at the given position
replaceAll(UniaryOperator op) : It replaces all the elements in the list.

Below is the simple java program to replace elements in the list

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
List<String> list = new ArrayList<>(); // list is a reference variable that can hold object of List Type or its implementing classes
list.add("Viewer"); // added single element in the list
list.add("Viewer2"); // added single element in the list
System.out.println(list); // printing the output

System.out.println("After replace -----------");
list.set(1, "Kui"); // replaced the viewer2 value with Kui in the list
System.out.println(list);

System.out.println("After replace All -----------");
list.replaceAll(String::toUpperCase); // a lambda expression (Java 8 feature), that denotes replaces all the elements with its Uppercase version
System.out.println(list); // replaced the viewer2 value with Kui in the list

}
}

Output:

[Viewer, Viewer2]
After replace -----------
[Viewer, Kui]
After replace All -----------
[VIEWER, KUI]

3. Deleting elements to the List

List interface provides remove() and removeAll method to delete elements from the list.

remove(int indx) : It deletes elements at the given position
remove(Object obj) : It deletes very first occurrence of the given object
removeAll(Collection c) : It deletes all the eleemnts that matches with the given collection object

Below is the simple Java program to delete or remove elements from a list

Program:

import java.util.ArrayList;
import java.util.List;

public class ListDeclarationExample {

public static void main(String[] args) {
List<String> list = new ArrayList<>(); // list is a reference variable that can hold object of List Type or its implementing classes
list.add("Viewer"); // added element in the list
list.add("Viewer2");
list.add("Viewer3");
list.add("Viewer4");
list.add("Viewer3");


System.out.println(list); // printing the output

System.out.println("After deleting element at 1st index -----------");
list.remove(1); // removed the viewer2 value
System.out.println(list);

System.out.println("After deleting element at Viewer3 object (very first match only)-----------");
list.remove("Viewer3"); // removed the viewer3 value,only very first occurrence
System.out.println(list);

System.out.println("After deleting elements defined in another list -----------");
List<String> deleteList = new ArrayList<>();
deleteList.add("Viewer4");
list.removeAll(deleteList); // removed the viewer4 value
System.out.println(list);
}
}

Output:

[Viewer, Viewer2, Viewer3, Viewer4, Viewer3]
After deleting element at 1st index -----------
[Viewer, Viewer3, Viewer4, Viewer3]
After deleting element at Viewer3 object (very first match only)-----------
[Viewer, Viewer4, Viewer3]
After deleting elements defined in another list -----------
[Viewer, Viewer3]

4. Sorting elements in the List

List provides sort() method to sort list

sort (Comparator c) : It sorts list based on given comparator

Below is the simple Java program to sort list

Program:

public class ListDeclarationExample {

public static void main(String[] args) {
List<String> list = new ArrayList<>(); // list is a reference variable that can hold object of List Type or its implementing classes
list.add("Sandeep"); // added element in the list
list.add("Sachin");
list.add("Jay");
list.add("Shiva");
list.add("Kui");

System.out.println("Before sorting based on the string length or size"); // printing the output
System.out.println(list); // printing the output

System.out.println("After sorting based on the string length or size"); // printing the output

list.sort(Comparator.comparingInt(String::length)); // It would sort the list based on the size or length of a string in increasing order

System.out.println(list); // printing the output


}
}

Output:

Before sorting based on the string length or size
[Sandeep, Sachin, Jay, Shiva, Kui]
After sorting based on the string length or size
[Jay, Kui, Shiva, Sachin, Sandeep]

5. Iterating over elements in List

List indirectly extends Iterable interface that provides method to iterate through collection objects. iterator() method and forEach() methods are one of methods.

Also, using advance for-each, one can iterate through a list.

Below is the simple Java Program to iterate through a List

Program:

public class ListDeclarationExample {

    public static void main(String[] args) {
        ArrayList<Integer> integerArrayList = new ArrayList<>();
        integerArrayList.add(5);
        integerArrayList.add(10);
        integerArrayList.add(1);

        System.out.println(" Iterating through iterator :: ");
        Iterator itr = integerArrayList.iterator();  // getting iterator object from arraylist instance
        while(itr.hasNext())    // while the list has the content, do
        {
            System.out.println(itr.next()); // returns the current element and moves the iteration state to next element
        }

        System.out.println(" Iterating through forEach :: ");
        integerArrayList.forEach(System.out::println);  // Java 8 forEach with lambda exp
    }
}

Output:

 Iterating through iterator :: 
5
10
1
 Iterating through forEach :: 
5
10
1