In Java, a set or group of objects is known as a collection. Several interfaces, classes, and Algorithms together form the Collection Framework. Collections and the Collection framework are two very important concepts in Java when it comes to handling and organizing data. In this article, we will take a look at all the various collections that are present in the Java programming language and how we can implement them in our code.<\/p>\n
The collection is an interface that provides various other interfaces and classes that help store and manipulate groups of objects. It helps in various operations such as searching, sorting, insertion, manipulation, and deletion.<\/p>\n
The Java Collection provides various interfaces, such as Set, List, Queue, Deque, and various classes, such as ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet, TreeSet, etc.<\/p>\n
The Collection interface is the root of the collection framework. Every other interface and class implements the Collection interface. It declares all the methods like Boolean add(Object obj), Boolean addAll (Collection c), void clear(), etc., which are implemented by all the subclasses of the Collection interface.<\/p>\n
We will now discuss all the interfaces and classes that fall under the Collection Interface.<\/p>\n
List interface is a child interface of the Collection Interface. It stores data in the form of a list-type data structure. We can store an ordered collection of objects in it. It is possible to have duplicates in this type of data structure.<\/p>\n
The classes ArrayList, LinkedList, Vector, and Stack implement the List Interface.<\/p>\n
The List interface is instantiated using the following statements:<\/strong><\/p>\n Let us see the use of each of these classes individually.<\/p>\n The ArrayList class implements the List Interface to create a dynamic array. Thus, it is a more flexible form of the default static array. However, the ArrayList class always maintains the insertion order and is always non-synchronized. The ArrayList can be accessed randomly.<\/p>\n Code to Understand the Implementation of ArrayList:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n The LinkedList also implements the List Interface. Internally, the LinkedList class uses a doubly linked list to store data. Therefore, it can also store duplicate elements and maintain the insertion order in a non-synchronized form. Although Data manipulation is faster in LinkedList because there is no shifting required.<\/p>\n Code to understand the implementation of LinkedList:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n It is the same as the ArrayList in every aspect, except for the fact that vectors are synchronized and contain many methods that are not part of the Collection Framework.<\/p>\n Vectors in Java are a type of array; their size can increase or decrease. However, an array has a defined size at the time of creation. So, to overcome this constraint, a vector was introduced.\u00a0<\/span><\/p>\n Code to understand the implementation of Vector:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n Stack is a subclass of the vector class. It follows the LIFO(Last In, First Out) principle of data structure. Thus, Stack contains all the methods of the Vector class and has methods like push(), peek(), and pop() of its own.<\/p>\n Code to understand the implementation of Stack:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n The Queue Interface implements the Collection Interface. It maintains the FIFO(First In First Out) principle of Data Structure. It holds elements in an ordered list. Therefore, Various classes and interfaces implement the Queue Interface, like PriorityQueue, Deque, and ArrayDeque<\/p>\n The queue interface can be instantiated as follows:<\/strong><\/p>\n Let us discuss the classes and interfaces that implement the Queue interface.<\/p>\n The PriorityQueue class implements the Queue interface. Thus, it holds the elements or objects by their priorities. Null values are not allowed in the PriorityQueue.<\/p>\n Code to implement PriorityQueue:<\/strong><\/p>\n The output of the above queue:<\/strong><\/p>\n The Deque Interface extends the Queue Interface. The Deque interface allows us to add and remove elements from both sides. However, it is basically a double-ended queue and is more flexible than a regular queue.<\/p>\n The deque interface can be instantiated by:<\/strong><\/p>\n The ArrayDeque class implements the Deque interface. It helps us implement the double-ended queue. However, ArrayDeque is faster than ArrayList and Stack and has no capacity restrictions, thus making it better and more flexible.<\/p>\n Code to understand the implementation of ArrayDeque:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n The Set interface also extends the Collection Interface. In a set, the list of elements is unordered, and the elements need to be unique, i.e, duplicates are not allowed. Only one Null value is allowed in a set. However, the set is implemented by the HashSet, LinkedHashSet, and TreeSet classes.<\/p>\n Set interface can be instantiated as:<\/strong><\/p>\n The HashSet class implements the Set Interface. It uses a hash table for storing elements. However, hashing is used to store the elements in a HashSet. However, each element in the HashSet is Unique. The insertion order is not maintained in HashSet.<\/p>\n Code to understand the implementation of HashSet:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n LinkedHashSet class implements the Set interface to represent the implementation of LinkedList. Thus, it extends the HashSet class. LinkedHashSet also has unique elements. Although it maintains the insertion order. Only one Null value is allowed.<\/p>\n Code to understand the implementation of LinkedHashSet:<\/strong><\/p>\n The output of the above code is:<\/strong><\/p>\n The SortedSet interface implements the Set interface. In this interface, the elements are stored in increasing order.<\/p>\n The SortedSet interface is instantiated by:<\/strong><\/p>\n TreeSet is a class that extends the SortedSet Interface. Java TreeSet works by representing the data in a tree structure for data sorting and data storage. However, the tree set does not allow storing duplicate data. Hence, the element stored in the tree set must be unique, resulting in reduced data redundancy. Although elements are also stored in ascending order.<\/p>\n However, the tree set prohibits the use of null values; if added, it will throw an exception.<\/p>\n Code to understand the implementation of TreeSet:<\/strong><\/p>\n The output of the above code is:<\/strong><\/p>\n Java collections provide various ways to iterate through their elements. Here are two common approaches:<\/p>\n Iterators<\/strong>: The Iterator interface provides a way to iterate through a collection’s elements one at a time. Therefore, you can obtain an iterator from a collection using its iterator() method. The iterator has methods like hasNext() to check if there are more elements and next() to get the next element.<\/p>\n For-each loop:<\/strong> Java provides a more concise way to iterate through collections using the for-each loop. Thus, this loop automatically iterates over each element in the collection and assigns it to a temporary variable.<\/p>\n In this article, we saw the main interfaces that implement the Collection interface and their respective extended classes. Although Java Collections help store and maintain data with ease, knowing the concept of Java Collections makes the programs very easy to implement.<\/p>\n","protected":false},"excerpt":{"rendered":" In Java, a set or group of objects is known as a collection. Several interfaces, classes, and Algorithms together form the Collection Framework. Collections and the Collection framework are two very important concepts in...<\/p>\n","protected":false},"author":5,"featured_media":108860,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32],"tags":[2633,2636,3769,7337,7579,7583,7691,8518,12767,13967,15065],"class_list":["post-14198","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-collection-framework-in-java","tag-collections-in-java","tag-deque-java","tag-iterator-interface-in-java","tag-java-line","tag-java-list-interface","tag-java-stack","tag-map-interface-in-java","tag-set-interface-in-java","tag-subtypes-of-collection-in-java","tag-types-of-interface-in-java"],"yoast_head":"\nList <data-type> list1= new ArrayList(); \r\n<\/pre>\n
List <data-type> list2 = new LinkedList(); \r\n<\/pre>\n
List <data-type> list3 = new Vector(); \r\n<\/pre>\n
List <data-type> list4 = new Stack(); \r\n<\/pre>\n
Java ArrayList<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class Arraylist\r\n{\r\n public static void main(String args[])\r\n { \r\n ArrayList<Integer> arr=new ArrayList<Integer>(); \r\n arr.add(1);\r\n arr.add(7); \r\n arr.add(10); \r\n arr.add(50); \r\n Iterator i=arr.iterator(); \r\n while(i.hasNext())\r\n { \r\n System.out.println(i.next()); \r\n } \r\n } \r\n} \r\n<\/pre>\n
\n7
\n10
\n50<\/div>\nJava LinkedList<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class Linkedlist\r\n{\r\n public static void main(String args[])\r\n { \r\n LinkedList<Integer> L=new LinkedList<Integer>(); \r\n L.add(1); \r\n L.add(7); \r\n L.add(10); \r\n L.add(50); \r\n Iterator<Integer> i=L.iterator(); \r\n while(i.hasNext())\r\n { \r\n System.out.println(i.next()); \r\n } \r\n } \r\n}\r\n<\/pre>\n
\n7
\n10
\n50<\/div>\nJava Vector<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class Vectors\r\n{\r\n public static void main(String args[])\r\n { \r\n Vector<Integer> v=new Vector<Integer>(); \r\n v.add(1); \r\n v.add(7); \r\n v.add(10); \r\n v.add(50); \r\n Iterator<Integer> i=v.iterator(); \r\n while(i.hasNext())\r\n { \r\n System.out.println(i.next()); \r\n } \r\n} \r\n}\r\n<\/pre>\n
\n7
\n10
\n50<\/div>\nJava Stack<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class Stacks\r\n{\r\n public static void main(String args[])\r\n { \r\n Stack<Integer> s = new Stack<Integer>(); \r\n s.push(1); \r\n s.push(7); \r\n s.push(10); \r\n s.push(50); \r\n s.push(100); \r\n s.pop(); \r\n Iterator<Integer> itr=s.iterator(); \r\n while(itr.hasNext())\r\n { \r\n System.out.println(itr.next()); \r\n } \r\n} \r\n}\r\n<\/pre>\n
\n7
\n10
\n50<\/div>\nJava Queue Interface<\/h3>\n
Queue<String> q1 = new PriorityQueue(); \r\n<\/pre>\n
Queue<String> q2 = new ArrayDeque(); \r\n\r\n<\/pre>\n
Java PriorityQueue<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class priority_queue\r\n{\r\n public static void main(String args[])\r\n { \r\n PriorityQueue<Integer> queue=new PriorityQueue<Integer>(); \r\n queue.add(1); \r\n queue.add(7); \r\n queue.add(10); \r\n queue.add(50); \r\n System.out.println(\"High Priority:\"+queue.element()); \r\n System.out.println(\"High Priority:\"+queue.peek()); \r\n System.out.println(\"Iterating through the queue :\"); \r\n Iterator itr=queue.iterator(); \r\n while(itr.hasNext()){ \r\n System.out.println(itr.next()); \r\n } \r\n queue.remove(); \r\n queue.poll(); \r\n System.out.println(\"After removing two elements from the Queue:\"); \r\n Iterator<Integer> itr2=queue.iterator(); \r\n while(itr2.hasNext()){ \r\n System.out.println(itr2.next()); \r\n } \r\n}\r\n}\r\n<\/pre>\n
\nHigh Priority:1
\nIterating through the queue :
\n1
\n7
\n10
\n50
\nAfter removing two elements from the Queue:
\n10
\n50<\/div>\nJava Deque Interface<\/h3>\n
Deque d = new ArrayDeque(); \r\n<\/pre>\n
Java ArrayDeque<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class ArrayDQ\r\n{\r\n public static void main(String[] args) \r\n { \r\n Deque<Integer> deque = new ArrayDeque<Integer>(); \r\n deque.add(1); \r\n deque.add(7); \r\n deque.add(10); \r\n deque.add(50); \r\n for (int i : deque) \r\n { \r\n System.out.println(i); \r\n } \r\n }\r\n}\r\n<\/pre>\n
\n7
\n10
\n50<\/div>\nJava Set Interface<\/h3>\n
Set<data-type> s1 = new HashSet<data-type>(); \r\n<\/pre>\n
Set<data-type> s2 = new LinkedHashSet<data-type>();<\/pre>\n
Set<data-type> s3 = new TreeSet<data-type>(); \r\n\r\n<\/pre>\n
Java HashSet<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class Hashset\r\n{\r\n public static void main(String args[])\r\n { \r\n HashSet<Integer> set=new HashSet<Integer>(); \r\n set.add(1); \r\n set.add(7); \r\n set.add(10); \r\n set.add(50); \r\n Iterator<Integer> itr=set.iterator(); \r\n while(itr.hasNext())\r\n { \r\n System.out.println(itr.next()); \r\n } \r\n } \r\n}\r\n<\/pre>\n
\n50
\n7
\n10<\/div>\nJava LinkedHashSet<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class LinkedHashset\r\n{\r\n public static void main(String args[])\r\n { \r\n LinkedHashSet<Integer> set=new LinkedHashSet<Integer>(); \r\n set.add(1); \r\n set.add(7); \r\n set.add(10); \r\n set.add(50); \r\n Iterator<Integer> itr=set.iterator(); \r\n while(itr.hasNext())\r\n { \r\n System.out.println(itr.next()); \r\n } \r\n }\r\n}\r\n<\/pre>\n
\n7
\n10
\n50<\/div>\nJava SortedSet Interface<\/h3>\n
SortedSet<data-type> set = new TreeSet(); \r\n<\/pre>\n
Java TreeSet<\/h3>\n
package com.DataFlair.Collections;\r\nimport java.util.*;\r\npublic class Treeset\r\n{\r\n public static void main(String args[])\r\n { \r\n TreeSet<Integer> set=new TreeSet<Integer>(); \r\n set.add(1); \r\n set.add(10); \r\n set.add(50); \r\n set.add(7); \r\n Iterator<Integer> itr=set.iterator(); \r\n while(itr.hasNext())\r\n { \r\n System.out.println(itr.next()); \r\n } \r\n } \r\n}\r\n<\/pre>\n
\n7
\n10
\n50<\/div>\nSummarizing the Java Collection Interface<\/h3>\n
\n\n
\n Interface<\/b><\/td>\n Collection Class<\/b><\/td>\n Ordered<\/b><\/td>\n Sorted<\/b><\/td>\n<\/tr>\n \n List<\/span><\/td>\n ArrayList<\/span><\/td>\n Indexed<\/span><\/td>\n No<\/span><\/td>\n<\/tr>\n \n Vector<\/span><\/td>\n Indexed<\/span><\/td>\n No<\/span><\/td>\n<\/tr>\n \n LinkedList<\/span><\/td>\n Indexed<\/span><\/td>\n No<\/span><\/td>\n<\/tr>\n \n Queue<\/span><\/td>\n Priority Queue<\/span><\/td>\n Sorted<\/span><\/td>\n By to-do order<\/span><\/td>\n<\/tr>\n \n Set<\/span><\/td>\n HashSet<\/span><\/td>\n No<\/span><\/td>\n No<\/span><\/td>\n<\/tr>\n \n TreeSet<\/span><\/td>\n Sorted<\/span><\/td>\n By natural order or custom order<\/span><\/td>\n<\/tr>\n \n LinkedHashSet<\/span><\/td>\n By insertion Order<\/span><\/td>\n No<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Iterating Through Collections in Java<\/h3>\n
Conclusion<\/h3>\n