Java Collection Types

Java Collection Types, also know as Collection framework provides many interfaces and classes that will help to implement reusable collection data structures. These collection types provide an architecture to store and provide manipulation for a group of objects. In Java, be it any group of individual objects which are represented as a single unit is known as the Collection of objects. Based on this, JDK 1.2 has been introduced with Collection Framework and Types which has all the collection classes and interfaces. Some of the ready to use collections such as list, set, map, queue, and stack, etc. solve common problems that user deals with a group of homogenous and heterogeneous objects. Let us dig deeper into the topic of Collection types and get to know syntaxes for all Types.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Hierarchy of Java Collection Types/ Framework

The Collection Types in Java consists of multiple interfaces where each interface is used to store a specific data type

Iterable Interface

It is the root interface for the Collection framework. The collection interface extends the Iterable interface. Hence, all the class and interface implement this interface. It contains only one abstract method which is the iterator.

Syntax:

Iterator iterator();

Collection Interface

It extends the iterable interface and is implemented by all the classes of the collection framework. It contains all the methods of which every collection has like removing data, adding the data or clearing the data, etc.

List Interface

It is the child interface of the Collection interface and is dedicated to list-type data which is used to store ordered collection of data, also allowing duplicates. The list interface is implemented by various classes such as Vector, Array List, Stack, etc. As all these subclasses implement a list, the user can instantiate the list object.

Syntax:

List<T> array_list = new ArrayList<>();
List<T> linked_list = new LinkedList<>();
List<T> vector = new Vector<>();

“T” being the type of object.

Array List

It provides dynamic arrays in Java. Size of Array List increases if collection grows or shrinks if objects are removed from collection. In Java, Array list can be randomly accessible and can’t be used for primitive types, will need wrapper class in such cases. Syntax is shown above.

Linked List

This class is an implementation of Linked List data structure. It is a linear data structure where elements are not stored continuously and each element is a separate object having data and address parts. Elements are linked up using addresses and pointers and each element is known as a node. Syntax is shown above.

Vector

This class provides dynamic arrays. It is slower than standard arrays but is helpful in programs where a lot of manipulations are needed. It is similar to the array list but Vector is synchronized and Array list is not synchronized. Syntax is shown above.

Stack

This class models and implements Stack data structure, and is based on the basic principle of last in first out. Along with basic push pop operations, this class also provides empty, peek and search functions. And can also be referred to as subclass of Vector.

Syntax:

Stack<T> stack = new Stack<>();

Queue Interface

This interface maintains the First In First Out order which is one similar to the queue line. It is dedicated to store all the elements where element order matters. It also consists of various classes such as Deque, Priority Queue, Array Queue, etc. Since all the subclasses implement queue, user can instantiate queue objects.

Syntax:

Queue<T> array_queue = new ArrayQueue<>();
Queue<T> priority_queue = new PriorityQueue<>();

Priority Queue

It is used when objects are supposed to be processed based on their priority, i.. based on a priority heap. The elements in the priority queue are ordered according to natural ordering, or by using Comparator. Syntax is given above.

Array Queue

This class is implemented in the framework allows user to have a resizable array. It is one of the special kinds of array, that allows users to remove or add element from both sides of the queue. It has no restrictions and will grow if necessary. Syntax is shown above.

Deque Interface

This interface is a slightest variation of Queue data structure. It is also known as Double-ended queue, as elements can be added to and removed from both ends. This interface instantiates class ArrayDeque.

Syntax:

Deque<T> deque = new ArrayDeque<>();

Set Interface

This class is inherent implementation for hash table data structure. Objects that are inserted into HashSet do not provide any guarantee that elements will be inserted in the same order. Objects are inserted based on hashcode and allow insertion of NULL elements too.

Syntax:

HashSet<T> hashset = new HashSet<>();

Linked Hash Set

It is much similar to Hash Set but uses a double linked list to store data by retaining the order of elements

Syntax:

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

Sorted Set Interface

This interface is much similar to Set Interface. It has extra methods which maintain the order of elements. Interface is implemented by instantiating is Tree Set.

Syntax:

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

Tree Set

This class uses a Tree for storage. Ordering of elements is maintained by using natural ordering else an external comparator is required.

Syntax:

TreeSet<T> tree_set = new treeSet<>();

Map Interface

This interface, Map is a data structure with key-value mapping data. It does not support duplicates because the same key cannot have multiple mappings. Map Interface is implemented by classes like Hash Map, Tree Map, etc.

Syntax:

Map<T> hash_map = new HashMap<>();
Map<T> tree_map = new TreeMap<>();

Hash Map

It provides a basic implementation of Java Map interface. To access a value in Hash Map, key is to be known. There is a technique of converting larger strings to small strings

Syntax:

HashMap<T, T> hashmap = new HashMap<T, T>();

Conclusion

With this, we conclude our topic “Java Collection Types”. We have seen various Interfaces and also the Iterable through which Interface came out. We have studied various interfaces such as Set, Java List, and Map interface and also covered subtypes of Java Collection Framework i.e. Stack, Queue, Deque. All the Syntax is given here which will be helpful to write logic and implement it programmatically. We have also seen the Java Collection Framework Hierarchy.

The above is the detailed content of Java Collection Types. For more information, please follow other related articles on the PHP Chinese website!