What are the commonly used data structures in Java? An in-depth analysis of Java data structures

Java is a widely used programming language, and data structures are an integral part of the development process. Data structures help organize and manage data and improve program execution efficiency. In Java, commonly used data structures include arrays, linked lists, stacks, queues, trees, graphs, etc. This article will provide an in-depth analysis of these commonly used Java data structures and provide specific code examples.

1. Array
An array is a linear data structure that can store elements of the same type. In Java, you can declare and initialize an array in the following way:

int[] arr = new int[5]; // 声明一个长度为5的整型数组
int[] arr = {1, 2, 3, 4, 5}; // 声明并初始化一个整型数组

The elements of the array can be accessed through subscripts, for example: arr[0] represents the first element of the array. Arrays also have some commonly used operations, such as traversing, obtaining length, sorting, etc.

2. Linked List
A linked list is a dynamic data structure that connects nodes together through pointers. In Java, you can use the LinkedList class to implement the function of a linked list. The following is a simple example using a linked list:

import java.util.LinkedList;

public class MyLinkedList {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();

        linkedList.add("A"); // 在链表末尾添加元素
        linkedList.addFirst("B"); // 在链表头部添加元素
        linkedList.addLast("C"); // 在链表尾部添加元素

        System.out.println(linkedList.get(0)); // 获取第一个元素
        System.out.println(linkedList.size()); // 获取链表长度
    }
}

3. Stack
The stack is a last-in-first-out (LIFO) data structure, which can be accessed through java.util. Stack class to achieve. The following is a simple example using stack implementation:

import java.util.Stack;

public class MyStack {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        stack.push("A"); // 元素入栈
        stack.push("B");
        stack.push("C");

        System.out.println(stack.peek()); // 获取栈顶元素
        System.out.println(stack.pop()); // 元素出栈
        System.out.println(stack.size()); // 获取栈的大小
    }
}

4. Queue (Queue)
The queue is a first-in, first-out (FIFO) data structure, you can use java.util.Queue Interface and its implementation class to implement the queue function. The following is a simple example implemented using queues:

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

public class MyQueue {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        queue.offer("A"); // 元素入队
        queue.offer("B");
        queue.offer("C");

        System.out.println(queue.peek()); // 获取队首元素
        System.out.println(queue.poll()); // 元素出队
        System.out.println(queue.size()); // 获取队列的大小
    }
}

5. Tree (Tree)
A tree is a non-linear data structure that consists of nodes connected by edges. In Java, you can use java.util.TreeSet and java.util.TreeMap to implement tree functions. The following is a simple example implemented using a tree:

import java.util.TreeSet;

public class MyTree {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();

        treeSet.add(5); // 添加元素
        treeSet.add(3);
        treeSet.add(8);
        
        System.out.println(treeSet.first()); // 获取最小的元素
        System.out.println(treeSet.last()); // 获取最大的元素
        System.out.println(treeSet.size()); // 获取元素个数
    }
}

6. Graph
A graph is a data structure composed of nodes and edges, which can be used to represent many-to-many relationships. In Java, graphs can be represented using adjacency matrices or adjacency lists. The following is a simple example using adjacency list representation:

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

public class MyGraph {
    private int vertexCount; // 顶点数量
    private List<List<Integer>> adjList; // 邻接表

    public MyGraph(int vertexCount) {
        this.vertexCount = vertexCount;
        adjList = new ArrayList<>();
        
        for (int i = 0; i < vertexCount; i++) {
            adjList.add(new ArrayList<>());
        }
    }

    public void addEdge(int src, int dest) {
        adjList.get(src).add(dest);
        adjList.get(dest).add(src);
    }
    
    public static void main(String[] args) {
        MyGraph myGraph = new MyGraph(5);
        
        myGraph.addEdge(0, 1); // 添加边
        myGraph.addEdge(0, 2);
        myGraph.addEdge(1, 3);
        
        System.out.println(myGraph.adjList.get(0)); // 获取节点0的邻接节点
    }
}

The above is an in-depth analysis and specific code examples of commonly used data structures in Java. Data structure is an important part of programming. Familiarity with and flexible use of various data structures can effectively improve the operating efficiency and performance of the program. I hope this article can provide readers with useful guidance and help.

The above is the detailed content of What are the commonly used data structures in Java? An in-depth analysis of Java data structures. For more information, please follow other related articles on the PHP Chinese website!