Java Data Structures for Beginners with Examples

Understanding structures is fundamental to software development. Java is an ideal choice for learning about data structures due to its simple syntax and wide scope of applications, from mobile app development to big data analysis.

Let's take a closer look at data structures in Java.

What is data structure?

A data structure describes how data sets are organized and managed. It defines how information can be stored, accessed and manipulated in a programming language. Understanding correlations between data elements allows developers to process information more efficiently.

Benefits of Using Data Structures in Java

Java development requires efficient processes, and using a data structure can help speed up processing and retrieval.

Efficient memory usage

Choosing the right data structure for your project impacts performance due to memory usage. Different data structures use memory in different ways. For example, a linked list data structure can use any available memory due to its dynamic nature, allocating memory as elements are added, whereas arrays use contiguous memory for storage that requires special allocation.

Improved performance

Knowing appropriate data structures can help alleviate problems and provide better results by improving data cycle time and space complexity. Some are too simple for complex operations. For example, an array can search for a million integers, while a HashSet can provide better results. Knowing how and when to apply each one saves time and effort and improves performance.

Improved data management

Using a specific data structure helps bring together various data in one place. Its standard structures ensure that program tasks are delivered faster and more accurately. They improve application programs by improving readability, detecting errors, and strengthening program productivity.

Supports complex functionality

Trees and graphs allow the implementation of complex functions that cannot be achieved with primitive data structures. They provide a way to present modeled relationships between elements that go beyond basic data types with a single value and limited range. A tree data structure allows for hierarchical representations with branching child elements, whereas a graph data structure can have more versatile data structures consisting of nodes (vertices) covering a wide range of complex networks.

Data structure reuse

Data structures can be reused across different elements or programs. A circular buffer (circular queue) connects the last node in a queue to the first, allowing repetitive use of data. Implementing data reuse techniques eliminates the need to repeat access to the same data.

Better problem solving

Data structures allow programmers to better understand the nature of problems, allowing them to solve them efficiently. As an integral part of modeling problems through object relations, they can help moderate potential problems within a framework.

Types of Data Structures in Java

Having a unified approach to data systems means better performance. Data must flow as fluidly as possible.

Java is adaptable. Sun Microsystems' “Write Once, Run Anywhere” (WORA) slogan represented a revolution in programming. It's no surprise that Java is among the most used programming languages.

There are certain structural features to consider:

• Linear vs. nonlinear: sequence structure or the order of items in a data set
• Homogeneity vs. heterogeneity: compositional characteristics within a given repository
• Static vs. dynamic data structure: variation in terms of size, structure, and memory location

There are many approaches to classifying datasets based on complexity: primitive, non-primitive, and abstract .

Primitive data structures

Primitive data type structures are the simplest approach to storing data in its raw form. There are four main types: integer, character, boolean, and float.

With a fixed size and simple format, they require minimal memory and can be processed quickly. These fundamental values ​​can interact by performing essential arithmetic and basic logical operations.

Whole

The integer (int) data type stores integers in Java. Includes any number that does not have a decimal point, such as -42, 0, and 8463. Ints are commonly used for calculations. They are also crucial for sorting and searching large data sets.

Character

The character data type (char) is a primitive structure that represents single characters. It includes letters, symbols and numbers, usually written in single quotation marks, and can be used to store individual words or strings of text. The char data type is commonly used to identify user input values ​​and write programs that display messages on the screen.

boolean

Named after Boolean algebra, this data type has two values: false (0) and true (1). It can be found in logic control structures. The binary data type can constitute opposite values ​​in programming (Yes/No; On/Off; True/False, etc.). Java uses the Boolean keyword only as a primitive data type because it stores only two possible values ​​and is often used in conditional tests and similar operations.

Floating point

Float data types in Java are more precise primitive data structures that can store a decimal value with up to seven digits of precision. Numbered values ​​with fractional parts are stored as a mantissa (the binary digit) and an exponent (the number of times the base number is multiplied by itself). Floating point structures have been used in data science engineering, economics, and more.

Non-primitive data structures

Also known as reference data structures, these data sets are more complex than primitive types because they refer to objects that are not predetermined. A programmer creates non-primitive data types except String.

Variety

An array data structure is a non-primitive data structure that stores a collection of elements in sequential order, where each element can be accessed using its index (the position of the element in the array). They are commonly used to store lists of related objects or values, such as student grades or employee names.

To create an array in Java, you must first indicate the data type of the elements, followed by square brackets ( ). So, you need to specify the size of the array.

 // Declaration and initialization of an array of integers
 int myArray = new int(5);

 // Declaration and initialization of an array of strings
 String names = new String(3);

Array Operations in Java

Arrays ensure efficient storage by allocating contiguous memory where elements can be accessed directly using their index. Its easy traversal using lops simplifies performing operations on each element.

• Insertion adds an element to an array that will displace all other elements to make space.

To insert an element into an array, you can assign a value to a specific index.

 int numbers = new int(5); // Declaring an integer array with size 5

 numbers(0) = 10; // Assigning a value to the first element
 numbers(1) = 20; // Assigning a value to the second element
 numbers(2) = 30; // Assigning a value to the third element

 // Inserting a new element at index 1
 numbers(1) = 15; // The previous value (20) is overwritten

• Elimination removes an element from the index and requires shifting all other elements in the array to fill the space left by the deleted element. Assign a default or null value to the specific index.

 String names = new String(3); // Declaring a string array with size 3

 names(0) = "Alice";
 names(1) = "Bob";
 names(2) = "Charlie";

 // Removing the element at index 1
 names(1) = null;

• Traversing the array can be done using for loop or forEach loop.

 public class ArrayTraversalExample {
  public static void main(String args) {
    // Create an array with some values
    int numbers = {10, 20, 30, 40, 50};

    // Traversal using a for loop
    System.out.println("Traversal using a for loop:");
    for (int i = 0; i < numbers.length; i++) {
      System.out.println(numbers(i));
    }

    // Traversal using a forEach loop
    System.out.println("\nTraversal using a forEach loop:"); 
for (int num : numbers) {
 System.out.println(num);
 }
 }
 }

The array of 'numbers' with value from 10 to 50 is traversed using both:

• a 'for' loop using the variable 'i', where each element is accessed using 'number(1)
• 'forEach' loop that does not explicitly manage the index using the 'num' variable representing each array element

 Traversal using a for loop:
 10
 20
 30
 40
 50

 Traversal using a forEach loop:
 10
 20
 30
 40
 50

Linked List

The Java LinkedList data class consists of sequential nodes containing data references from one to another. Its size changes when adding or removing elements from the list stored in containers. Unlike arrays, they do not require contiguous memory allocation, allowing for dynamic memory during runtime.

Implementing a LinkedList in Java requires defining a Node class containing data and a reference to the next node:

 class Node {
 int data;
 Node next;

 public Node(int data) {
 this.data = data; 
this.next = null;
 }
 }

LinkedLists are excellent in scenarios that require dynamic size, frequent insertion and deletion, and flexible memory allocation, but may not be suitable for situations that require random access or have strict memory constraints.

The advantages of LinkedLists include:

• Dynamically scaling up or down during runtime allows for efficient memory utilization and flexibility in managing changes in data sizes.
• Easier frequent insertion and deletion operations can be done constantly.
• Flexibility in memory usage and allocation, as each node allocates memory and does not require contiguous memory blocks.

LinkedLists have advantages, but they cannot access elements by index. Extra memory is used to store references to the next node. Traversing backwards or accessing elements randomly can be inefficient, and managing references and node bindings is complex.

LinkedList Operations in Java

A LinkedList operation is a good solution for frequent insertion and deletion of elements through:

• insertion
• elimination
• and crossing.

Insertion

Inserting LinkedList in Java can be done using the add method . For example:

 import java.util.LinkedList;

 public class LinkedListInsertionExample {
  public static void main(String args) {
    LinkedList<String> list = new LinkedList<> ;

    // Insert elements using add method
    list.add("apple");
    list.add("banana");
    list.add("cherry");

    //Print the LinkedList
    System.out.println("LinkedList after insertion: " + list);
  }
 }

Elimination

To delete the parent node, adjust the previous and next node pointers to ignore it and set the reference to the next node as the new parent node.

 import java.util.LinkedList;

 public class LinkedListDeletionExample {
  public static void main(String args) { 
LinkedList<Integer> numbers = new LinkedList<> ;

 // Add elements to the LinkedList
 numbers.add(10);
 numbers.add(20);
 numbers.add(30);
 numbers.add(40);

 // Remove a specific element using remove
 numbers.remove(Integer.valueOf(30));

 // Print the modified LinkedList
 System.out.println(numbers); // Output: (10, 20, 40)
 }
 }

In the example above, we created a LinkedList called “numbers” and added some elements to it. Then we use the `remove` method to delete the element with the value '30'. Finally, we print the modified list containing (10, 20, 40).

Crossing

LinkedList traversal in Java involves visiting each node in the LinkedList and performing an operation on it.

 import java.util.LinkedList;

 public class LinkedListTraversalExample {
  public static void main(String args) {
    // Create a linked list 
LinkedList<Integer> linkedList = new LinkedList<> ;
 linkedList.add(1);
 linkedList.add(2);
 linkedList.add(3);
 linkedList.add(4);
 linkedList.add(5);

 // Traverse the linked list
 for (Integer element : linkedList) {
 System.out.print(element + " ");
 }
 }
 }

Stacks and queues

Stacks and Queues are two of the most basic examples used in many programming languages.

Stacks

A common visual presentation of stack data structures is a stack of plates where changes can only be made from the top. This is called the Last-In-First-Out data structure, where the last (push ) element added is the first to be removed ( pop ).

The push method adds items to the stack.

 import java.util.Stack;

 Stack<Integer> stack = new Stack<> ;
 stack.push(10);
 stack.push(20);
 stack.push(30);

The pop method removes items from the stack.

int poppedElement = stack.pop; // Returns 30

Queues

Queues are linear data structures similar to stacks, but they are open at both ends. They follow the FIFO principle, except for removing elements. In a queue, the oldest element is removed first through enqueuing and dequeuing.

The enqueue method adds an element to the end of the queue.

 import java.util.LinkedList;
 import java.util.Queue;

 Queue<String> queue = new LinkedList<> ;
 queue.add("Alice");
 queue.add("Bob");
 queue.add("Charlie");

The dequeue method removes and returns the first/most recent element from the queue.

 String dequeuedElement = queue.poll; // Returns "Alice"

By using these operations, you can manipulate elements in stacks and queues according to your specific ordering rules and perform various tasks efficiently.

Trees

Trees are non-linear data structures that store information hierarchically. They comprise nodes with a data value and references to other nodes (or subtrees). Trees are typically used for sorting and searching operations, storing and traversing hierarchical data.

Example of implementing binary tree in Java:

 public class BinaryTree {
 private TreeNode root;
 // Create the tree
 public void create(int arr) {
 this.root = new TreeNode(arr(0));
 Queue queue = new LinkedList<> ;
 queue.add(root);
 int i = 1;
 while (I < arr.length) {
 TreeNode currentNode = queue.remove;
 if (arr(i) != -1) {
 currentNode.

Tree Operations in Java

Trees are an essential data structure used in programming. The main operations that can be performed on trees include insertion, deletion, search and traversal.

Insertion

Adding a new element to a binary search tree must be designed in such a way that it does not violate each value. Example:

10

/ \

5 15

We can enter a value of 12 as follows:

10

/ \

5 15

/ \ / \

3 7 12 18

Elimination

Removing a node in binary trees requires replacing the deleted node with its successor or predecessor (whichever is available first).

For example, given the tree above, if we wanted to delete 10, we could replace it with its successor in order 12, as follows:

12

/ \

5 15

/ \ / \

3 7 10 18

To search for

Binary search trees provide efficient search capabilities as each branch has only two options and each move left or right halves the number of nodes that need to be searched. For example, given our original binary tree, we could search for 7 as follows:

10

/ \

5 15

/ \ / \

3 7 12 18

Crossing

A graph traversal ensures that all nodes in a tree data structure are visited exactly once. There are three types of crossings:

• Pre-order traversals begin by visiting the roots before moving to subtrees.
• Post-order traversals start with subtrees moving to the root.
• Ordered traversals that start with the left child (and the entire subtree) go to the root and end by visiting the right child.

For example, given our original binary tree, we could traverse in order as follows: 3->5->7->10->12->15->18

Graphics

Graphs are a common way to present nonlinear data. It consists of vertices, graphical units (vertices or nodes) and edges (connective paths between nodes).

Adding a vertex

Implementing a new node in a graphical framework requires adding a new object.

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

 public class Graph {
 private int numVertices; 
private List<List<Integer>> adjacencyList;

 public Graph(int numVertices) {
 this.numVertices = numVertices;
 adjacencyList = new ArrayList<>(numVertices);

 // Initialize the adjacency list
 for (int i = 0; i < numVertices; i++) {
 adjacencyList.add(new ArrayList<> );
 }
 }

 public void addVertex {
 numVertices++;
 adjacencyList.add(new ArrayList<> );
 }
 }

Adding an advantage

Once you find two vertices to connect, set the necessary references between them before adding an edge.

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

 public class Graph {
 private int numVertices;
 private List<List<Integer>> adjacencyList;

 public Graph(int numVertices) {
 this.numVertices = numVertices;
 adjacencyList = new ArrayList<>(numVertices);

 // Initialize the adjacency list
 for (int i = 0; i < numVertices; i++) {
 adjacencyList.add(new ArrayList<> );
 }
 }

 public void addEdge(int source, int destination) {
 // Check if the vertices are within the valid range 
if (source >= 0 && source < numVertices && destination >= 0 && destination < numVertices) {
 // Add the destination vertex to the adjacency list of the source vertex
 adjacencyList.get(source).add(destination);

 // If the graph is undirected, add the source vertex to the adjacency list of the destination vertex as well
 // adjacencyList.get(destination).add(source); // Uncomment this line for an undirected graph
 }
 }
 }

Graph Traversal

Graph lookups are performed when each vertex is visited for checks or updates. Depending on the type of problem, two iterations can do this.

Breadth-first traversal (BFS) is usually implemented in a queue data structure. It starts at a given node (usually the root) and explores its adjacent nodes, then moves to the next level of nodes until all nodes have been visited. BFS is typically implemented using a queue data structure.

 import java.util.LinkedList; 
import java.util.Queue;

 class Graph {
 private int numVertices;
 private LinkedList<Integer> adjacencyList;

 public Graph(int numVertices) {
 this.numVertices = numVertices;
 adjacencyList = new LinkedList(numVertices);
 for (int i = 0; i < numVertices; i++) {
 adjacencyList(i) = new LinkedList<> ;
 }
 }

 public void addEdge(int source, int destination) {
 adjacencyList(source).add(destination);
 }

 public void breadthFirstTraversal(int startVertex) {
 boolean visited = new boolean(numVertices);
 Queue<Integer> queue = new LinkedList<> ;

 visited(startVertex) = true;
 queue.offer(startVertex);

 while (!queue.isEmpty ) {
 int currentVertex = queue.poll;
 System.out.print(currentVertex + " ");

 for (int neighbor : adjacencyList(currentVertex)) {
 if (!visited(neighbor)) {
 visited(neighbor) = true;
 queue.offer(neighbor);
 }
 }
 }
 }
 }

 public class Main {
 public static void main(String args) {
 Graph graph = new Graph(6);
 graph.addEdge(0, 1);
 graph.addEdge(0, 2);
 graph.addEdge(1, 3);
 graph.addEdge(2, 4);
 graph.addEdge(3, 4);
 graph.addEdge(3, 5);
 
System.out.println("Breadth-First Traversal:");
 graph.breadthFirstTraversal(0);
 }
 }

Depth-first traversal (DFS) explores the graph using recursion or a stack data structure to go as far as possible along each branch before going back. It starts at a particular node (usually the root) and explores as deeply as possible before going back and visiting other adjacent nodes.

 import java.util.LinkedList;

 class Graph {
 private int numVertices;
 private LinkedList<Integer> adjacencyList;

 public Graph(int numVertices) {
 this.numVertices = numVertices;
 adjacencyList = new LinkedList(numVertices);
 for (int i = 0; i < numVertices; i++) {
 adjacencyList(i) = new LinkedList<> ;
 }
 }

 public void addEdge(int source, int destination) {
 adjacencyList(source).add(destination);
 }

 public void depthFirstTraversal(int startVertex) {
 boolean visited = new boolean(numVertices);
 dfsHelper(startVertex, visited);
 }

 private void dfsHelper(int vertex, boolean visited) {
 visited(vertex) = true; 
System.out.print(vertex + " ");

 for (int neighbor : adjacencyList(vertex)) {
 if (!visited(neighbor)) {
 dfsHelper(neighbor, visited);
 }
 }
 }
 }

 public class Main {
 public static void main(String args) {
 Graph graph = new Graph(6);
 graph.addEdge(0, 1);
 graph.addEdge(0, 2);
 graph.addEdge(1, 3);
 graph.addEdge(2, 4);
 graph.addEdge(3, 4);
 graph.addEdge(3, 5);

 System.out.println("Depth-First Traversal:");
 graph.depthFirstTraversal(0);
 }
 }

Both traversal methods play important roles in graph algorithms and applications, such as finding connected components, detecting cycles, determining reachability, and solving graph-based puzzles.

Abstract data types

An abstract data type (ADT) serves as the basis upon which a data structure will be attached without impacting the implementation process. Abstract data types can be classified as

• Built-in/user-defined
• Mutable/immutable

In Java, an abstract class is defined by interface contracts for a specific data structure.

List

A segment of the Java Collections Framework is built for array and linked list implementation.

A list interface creates an ArrayList to store names:

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

 List<String> names = new ArrayList<> ;
 names.add("Alice");
 names.add("Bob");
 names.add("Charlie");

 System.out.println(names.get(1)); // Output: "Bob"

To define

The AbstractSet class in Java provides a body structure for the set interface that implements the collection interface and the abstract collection class. It differs from the list interface in that it does not allow duplicate elements. It provides methods like add, remove, contain, and size.

Use the set interface to store a set of numbers:

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

 Set<Integer> numbers = new HashSet<> ;
 numbers.add(1);
 numbers.add(2);
 numbers.add(3); 
numbers.add(2); // Duplicate element, not added

 System.out.println(numbers.contains(2)); // Output: true

Map

A map interface in Java stores data in key-value pairs with unique keys. It provides methods like put, get, remove and containsKey. It is commonly used for storing key-value pairs. Here is an example of using the map interface to store a mapping of names and ages:

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

 Map<String, Integer> ages = new HashMap<> ;
 ages.put("Alice", 25);
 ages.put("Bob", 30);
 ages.put("Charlie", 35);

 System.out.println(ages.get("Bob")); // Output: 30

How to Choose the Right Data Structure in Java

The decision about which data structure best suits any program implementation largely depends on factors such as inputs, data processing, and output operations.

Based on the complexity of operations and performance expectations, programmers can narrow down potential frameworks to those with similar results. It's always better to start with the simplest solutions and work your way up.

Consider the ease of use and maintenance of your chosen data structure. Some data structures have complex implementation details or require specific coding practices. Leverage existing Java collections and use pre-implemented frameworks with optimized performance and functionality.

Conclusion

Selecting the most appropriate data structure for implementing a program requires a thorough understanding of the program's requirements, careful analysis of the operations involved, and consideration of various factors such as memory efficiency, search capabilities, and ordering requirements.

The data structure must have a scope of predefined operations and properties necessary for good software performance. Data structures are critical in Java and data generation continues to grow.

Common questions

What are data structures in Java?

Data structures in Java are a formatted collection of data elements to perform any activity on datasets (organization, processing, access and string). Different types of structures have wide applications across industries.

Why are data structures important in Java programming?

Data structures in Java programming can help increase and improve performance and allow developers to resolve issues and failures faster.

What is the difference between primitive and non-primitive data structures?

The main difference between primitive and non-primitive data structures is their complexity. Primitive data types are predefined, always have a value, and cannot perform certain operations.

On the other hand, non-primitive data structures are created by a programmer, can have a null value, and are used to call methods to perform specific actions.

When should I use arrays vs linked lists in Java?

ArrayList in Java serves best for search operations because it provides constant time if the programmer knows the number of elements in a sequence with limited memory. LinkedList in Java, on the other hand, can be useful when operations require more data manipulation, especially when you add priority queues or need to know how many items there will be in the list.

How does a stack differ from a queue in Java?

The main difference between a stack and a queue in Java is in the order in which the data structures are processed. The stack follows the Last In, First Out (LIFO) input processing order, while the Queue follows the First In, First Out principle, which means it processes the first input in the order. Additionally, being open at both ends removes the oldest element from one side of the queue.