Java Collections Framework: Working with Collections and Data Structures in Java

Linear Data Structures: It is a single level data structure that has all of their elements arranged in a sequential manner.

Non-Linear Data Structures: Data is not arranged sequentially in non-linear data structures, which are multi-level data structures.

Arrays: Groups of data elements of similar types stored in close proximity to one another are called arrays. It is one of the most straightforward data structures, with each data element being randomly accessible via its index number.

Syntax:

dataType var[]; (or)

dataType[] arr; 

Example

class Arr

{

    public static void main (String[] args)

    {        

      int[] arr;

      arr = new int[5];

      arr[0] = 1;

      arr[1] = 4;

      arr[2] = 15;

      arr[3] = 21;

      arr[4] = 6;

      for (int i = 0; i < arr.length; i++)

         System.out.println(arr[i]);   

    }

}

Advantages of Arrays

• Many identical data elements are represented by an array under a single name.
• The index number in arrays can be used to randomly access the elements.
• Arrays allocate memory in contiguous memory areas for each of its elements. As a result, there is no chance that additional memory will be allocated. This avoids memory overflows and array shortages.
• Arrays can be used to build other data structures such linked lists, stacks, queues, trees, and graphs.

Learn to create GUI in java through the fundamentals of Java Swing.

Linked Lists: Similar to the ArrayList, the LinkedList class is a collection that can include a large number of objects of the same type. Each element in this case is a separate object having a data portion and an address component, and they are not all kept in the same place. Each component is referred to as a node, and pointers and addresses are used to connect them.

The Collection framework is found in the java.util package including Linked List.

Syntax:

LinkedList<dataType>var = new LinkedList<dataType>();

Example

import java.util.*;  

public class LinkedList{  

     public static void main(String args[]){  

         LinkedList<String> ll=new LinkedList<String>();

          ll.add(“Mango”);  

         ll.add(“Apple”);  

         ll.add(“Banana”);  

         ll.add(“Orange”); 

         System.out.println(ll);         

         }  

}  

Output

[Mango, Apple, Banana, Orange]

Advantages of Linked List

• It is a dynamic data structure, the linked list. At runtime, the memory can be allocated and released.
• The insertion and deletion functions make it simple to add or remove the node.
• The linked list efficiently utilizes memory. since we are not required to pre-allocate RAM.
• It may be accessed at a given moment without any memory overhead and has an incredibly quick access time.
• Linked lists can be utilized with linear data structures like stacks and queues.

Stack

The Last In First Out (LIFO) data structure known as a stack can be physically implemented as an array or a linked list. It just has one pointer the top, which directs attention to the element at the top of the stack. A new element can only be removed from the stack after being added to it; it is always placed at the top. A stack can be conceptualized as a container in which insertion and deletion are possible from one end, to put it another way.

Syntax

Stack var = new Stack(size)

Example

class Stack {

  private int array[];

  private int top;

  private int limit;

  Stack(int size) {

    array = new int[size];

    limit = size;

    top = -1;

  }

  public void push(int x) {

    if (isFull()) {

      System.out.println(“Overflow and program terminated\n”);

      System.exit(1);

    }

    System.out.println(“Inserted ” + x);

    array[++top] = x;

  }

  public int pop() {

    if (isEmpty()) {

      System.out.println(“STACK EMPTY”);

      System.exit(1);

    }

    return array[top–];

  }

  public int size() {

    return top + 1;

  }

  public Boolean isEmpty() {

    return top == -1;

  }

  public Boolean isFull() {

    return top == limit – 1;

  }

  public void printStack() {

    for (int i = 0; i <= top; i++) {

      System.out.println(array[i]);

    }

  }

  public static void main(String[] args) {

    Stack stack = new Stack(5);

    stack.push(10);

    stack.push(20);

    stack.push(30);

    stack.push(40);

    stack.pop();

    System.out.println(“\nAfter popping out”);

    stack.printStack();

  }

}

Output

Inserted 10

Inserted 20

Inserted 30

Inserted 40

After popping out

10

20

30

Advantages of Stack

• A linked list and an array cannot manage data in a LIFO manner, but a stack can.
• When a function is called, local variables are placed on a stack and are immediately removed after the function returns.
• The stack can be used to control memory allocation and deallocation.
• Since it is less susceptible to corruption, the stack is safer and more trustworthy.
• Variables cannot be resized in the stack.

Get the basic understanding of developing rich client applications in Java through our blog about JavaFX.

Queue

The FIFO (First-In-First-Out) principle, which states that elements are added to the end of the list and subtracted from the beginning, is the basis for the data structure known as a queue.

Syntax

Queue q1 = new LinkedList(); | Queue q2 = new PriorityQueue();

Example

import java.util.LinkedList;

import java.util.Queue;

class Main

{

    public static void main(String[] args)

    {

        Queue<String> queue = new LinkedList<String>();

        queue.add(“Orange”);     

        queue.add(“Banana”);     

        queue.add(“Mango”);     

        queue.add(“Pineapple”);     

        System.out.println(queue.peek());

        queue.remove();      

        queue.remove();     

        System.out.println(queue.peek());

        System.out.println(queue.size());

        if (queue.isEmpty()) {

            System.out.println(“The queue is empty”);

        }

        else {

            System.out.println(“The queue is not empty”);

        }

    }

}

Output

Orange

Mango

2

The queue is not empty

Advantages of Queue

The advantage of queues is that they are rapid, adaptable, and able to handle a range of data kinds. In contrast to fixed-length arrays, queues have the potential to be endlessly long.

Graph

A graph is a type of data structure used to store related data, such as a social media platform’s user base. Vertices and edges comprise a graph.The relationship between the entities (such as a person’s friendships) is represented by the edge, while the entity (such as individuals) is represented by the vertex.

Syntax

BaseType <ParameterType> obj = new BaseType <ParameterType>();  

Example

class Graph 

{

  class Edge {

    int src, dst; //source and destination

  }

  int vertices, edges;

  Edge[] edge; // store all the edges in an array

  Graph(int vertices, int edges) {

    this.vertices = vertices;

    this.edges = edges;

    edge = new Edge[edges];

    for(int i = 0; i < edges; i++) 

{

      edge[i] = new Edge();

    }

  }

  public static void main(String[] args) {

    int noVertices = 5;

    int noEdges = 8;

    Graph g = new Graph(noVertices, noEdges);

    g.edge[0].src = 1;   // edge 1-2

    g.edge[0].dst = 2;

    g.edge[1].src = 1;   // edge 1-3

    g.edge[1].dst = 3;

    g.edge[2].src = 1;   // edge 1-4

    g.edge[2].dst = 4;

    g.edge[3].src = 2;   // edge 2-4

    g.edge[3].dst = 4;

    g.edge[4].src = 2;   // edge 2-5

    g.edge[4].dst = 5;

    g.edge[5].src = 3;   // edge 3-4

    g.edge[5].dst = 4;

    g.edge[6].src = 3;   // edge 3-5

    g.edge[6].dst = 5;

    g.edge[7].src = 4;   // edge 4-5

    g.edge[7].dst = 5;

    for(int i = 0; i < noEdges; i++) {

      System.out.println(g.edge[i].src + ” – ” + g.edge[i].dst);

    }

  }

}

Output

1 – 2

1 – 3

1 – 4

2 – 4

2 – 5

3 – 4

3 – 5

4 – 5

Advantages of Graph

The main benefit of a graph data structure is that it makes it possible to use all graph-related computer science techniques. After figuring out how to graph your domain logic, you can use all of the power of graph algorithms to solve your issue.

Gain the fundamental understanding of software testing by checking out our recent blog.

Set

A set is a grouping of distinct items. In order to store different values, Java provides a set interface. To set is an interface found in the java.util package. The Set interface enlarges the Collection interface. An unordered list or collection with no room for duplicates is referred to as a collection interface. It is used to generate the mathematical set. The set interface uses the collection interface’s techniques to stop duplicate elements from being inserted. SortedSet and NavigableSet are two interfaces that enhance the implementation of a set.

Syntax

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

Example

import java.util.*;   

public class Set{   

    public static void main(String[] args)   

    {   

        Set<String> data = new LinkedHashSet<String>();   

        data.add(“This”);   

        data.add(“Is”);   

        data.add(“Set”);   

        data.add(“Example”);   

        System.out.println(data);   

    }   

}   

Output

[This, Is, Set, Example]

Advantages of Set

• There can never be a duplicate object in a set.
• Access times of O are often guaranteed using sets (logN).

Map

There is a map interface in Java. The package util represents a key and a value. The Map interface does not have a subclass called Collection. It functions differently from the other collection types as a result. Every map has a unique set of keys.

Syntax

Map hm<dataType,dataType> = new HashMap<dataType,dataType>();

Example

import java.util.*;

public class GFG {

    public static void main(String[] args)

    {

        Map<String, Integer> map = new HashMap<>();

        map.put(“Mango”, 10);

        map.put(“Apple”, 20);

        map.put(“Banana”, 30);

        for (Map.Entry<String, Integer> e : map.entrySet())

            System.out.println(e.getKey() + ” “

                               + e.getValue());

    }

}

Output

Apple 20

Mango 10

Banana 30

Advantages of Map

• An array (or, better yet, a vector) is wonderful if all you care about is looking up data, and you know that the keys you’re using to do so fall within a reasonably narrow integer range. Using a key in real-time, you can quickly look something up.
• Items are kept on a map in key order. The objects in a map can then be iterated over from start to finish in sorted key order. You can accomplish this with an array or vector, of course, but as was said before, a map enables you to declare any arbitrary key type and any arbitrary ordering.
• All of the objects in an array or vector must be moved to the left in order to insert in the middle of it. If you have a vector and a dynamic array, you must enlarge the vector to avoid having to copy the entire array to the new memory.

Do you know what the Java Developer Salary for Freshers is? Read through our article.