Java常用的数据结构及简单的示例

涎涎原创约 1534 字大约 5 分钟...

Java常用的数据结构及简单的示例

注意

本博文仅供学术研究和交流参考，严禁将其用于商业用途。如因违规使用产生的任何法律问题，使用者需自行负责。

概念

Java常用的数据结构包括：

数组（Array）：是一种线性数据结构，可以存储相同类型的一组元素。
链表（LinkedList）：是一种动态数据结构，由节点组成，每个节点包含数据和指向下一个节点的引用。
栈（Stack）：是一种后进先出（LIFO）的数据结构，只允许在栈顶进行插入和删除操作。
队列（Queue）：是一种先进先出（FIFO）的数据结构，允许在队尾插入元素，在队首删除元素。
堆（Heap）：是一种特殊的树形数据结构，用于实现优先级队列，具有父节点的键值总是大于或等于其子节点。
集合（Set）：是一种不允许重复元素的数据结构，常见的实现类有HashSet和TreeSet。
映射（Map）：是一种键值对的数据结构，每个键对应一个值，常见的实现类有HashMap和TreeMap。
树（Tree）：是一种非线性的数据结构，由节点和边组成，每个节点可以有多个子节点。
图（Graph）：是一种非线性的数据结构，由节点和边组成，节点之间可以有多个连接关系。
集合框架（Collections Framework）：Java提供了一套完整的集合框架，包括List、Set、Queue、Map等接口及其实现类，方便开发者使用和操作不同类型的数据结构。

以上是Java常用的数据结构，每种数据结构都有其特定的用途和适用场景，开发者可以根据需求选择合适的数据结构来进行数据的存储和操作。

示例

数组（Array）：

int[] numbers = {1, 2, 3, 4, 5}; // 声明并初始化一个整型数组
String[] names = new String[3]; // 声明一个字符串数组并指定长度

System.out.println(numbers[2]); // 输出数组中索引为2的元素值
names[0] = "Alice"; // 设置数组中索引为0的元素值
System.out.println(names[0]); // 输出数组中索引为0的元素值

链表（LinkedList）：

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("Apple"); // 向链表尾部添加元素
linkedList.addFirst("Banana"); // 在链表头部添加元素
linkedList.addLast("Orange"); // 在链表尾部添加元素

System.out.println(linkedList.get(1)); // 获取链表中索引为1的元素值
linkedList.removeFirst(); // 删除链表头部的元素

for (String fruit : linkedList) {
    System.out.println(fruit); // 遍历链表并输出每个元素值
}

栈（Stack）：

Stack<String> stack = new Stack<>();
stack.push("Java"); // 将元素压入栈顶
stack.push("Python");
stack.push("C++");

System.out.println(stack.peek()); // 获取栈顶元素但不删除
System.out.println(stack.pop()); // 弹出栈顶元素并删除

while (!stack.isEmpty()) {
    System.out.println(stack.pop()); // 弹出并输出栈中所有元素
}

队列（Queue）：

Queue<String> queue = new LinkedList<>();
queue.offer("Apple"); // 将元素插入队尾
queue.offer("Banana");
queue.offer("Orange");

System.out.println(queue.peek()); // 获取队首元素但不删除
System.out.println(queue.poll()); // 弹出队首元素并删除

while (!queue.isEmpty()) {
    System.out.println(queue.poll()); // 弹出并输出队列中所有元素
}

堆（Heap）：

PriorityQueue<Integer> heap = new PriorityQueue<>();
heap.offer(5); // 将元素插入堆中
heap.offer(2);
heap.offer(8);

System.out.println(heap.peek()); // 获取堆顶元素但不删除
System.out.println(heap.poll()); // 弹出堆顶元素并删除

while (!heap.isEmpty()) {
    System.out.println(heap.poll()); // 弹出并输出堆中所有元素
}

集合（Set）：

Set<String> set = new HashSet<>();
set.add("Apple"); // 向集合中添加元素
set.add("Banana");
set.add("Orange");

System.out.println(set.contains("Apple")); // 检查集合中是否包含元素

for (String fruit : set) {
    System.out.println(fruit); // 遍历集合并输出每个元素值
}

映射（Map）：

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1); // 向映射中添加键值对
map.put("Banana", 

2);
map.put("Orange", 3);

System.out.println(map.get("Banana")); // 根据键获取对应的值

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue()); // 遍历映射并输出每个键值对
}

树（Tree）：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

// 创建一棵二叉树
TreeNode root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);

// 遍历二叉树（先序遍历）
void preorderTraversal(TreeNode node) {
    if (node == null) {
        return;
    }
    
    System.out.println(node.val); // 输出当前节点值
    preorderTraversal(node.left); // 遍历左子树
    preorderTraversal(node.right); // 遍历右子树
}

preorderTraversal(root); // 输出：1 2 4 5 3

图（Graph）：在Java中，表示图的数据结构可以使用邻接表或邻接矩阵等方式进行实现，具体示例略复杂，请参考专门的图算法相关资料。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

class Graph {
    private Map<Integer, List<Integer>> adjacencyList;

    public Graph() {
        adjacencyList = new HashMap<>();
    }

    public void addVertex(int vertex) {
        adjacencyList.put(vertex, new ArrayList<>());
    }

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

    public List<Integer> getAdjacentVertices(int vertex) {
        return adjacencyList.get(vertex);
    }
}

// 创建一个无向图
Graph graph = new Graph();
graph.addVertex(1);
graph.addVertex(2);
graph.addVertex(3);
graph.addVertex(4);

graph.addEdge(1, 2);
graph.addEdge(1, 3);
graph.addEdge(2, 3);
graph.addEdge(3, 4);

List<Integer> adjacentVertices = graph.getAdjacentVertices(1);
for (int vertex : adjacentVertices) {
    System.out.println(vertex); // 输出与顶点1相邻的顶点
}

集合框架（Collections Framework）：Java的集合框架提供了多种数据结构的实现类，如ArrayList、LinkedList、HashSet、TreeSet等，通过它们可以方便地操作和管理数据集合。具体使用示例请参考Java官方文档或相关的教程资料。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

System.out.println(list.get(1)); // 获取列表中索引为1的元素

for (String fruit : list) {
    System.out.println(fruit); // 遍历列表并输出每个元素
}

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");

System.out.println(set.contains("Banana")); // 检查集合中是否包含元素

for (String fruit : set) {
    System.out.println(fruit); // 遍历集合并输出每个元素
}

Java常用的数据结构及简单的示例

Java常用的数据结构及简单的示例

概念

示例

分割线

预览:

Java常用的数据结构及简单的示例

# Java常用的数据结构及简单的示例

# 概念

# 示例

# 分割线

预览:

Java常用的数据结构及简单的示例

概念

示例

分割线