Java常见数据结构创建以及使用

原创 已于 2025-05-31 21:15:38 修改 · 350 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #数据结构

于 2025-05-31 21:05:17 首次发布

一、数组（Array）

特点：

  • 固定长度，内存连续，支持随机访问（O (1)），插入 / 删除效率低（O (n)）。
  • 可存储基本类型或引用类型。

创建与初始化

// 静态初始化
int[] arr1 = {1, 2, 3};          // 基本类型数组
String[] arr2 = {"a", "b", "c"}; // 引用类型数组

// 动态初始化
int[] arr3 = new int[5];         // 长度为5的int数组（默认值0）
Object[] arr4 = new Object[3];   // 引用类型数组（默认值null）

常用操作

// 访问元素`在这里插入代码片`
int first = arr1[0];     // 读取第一个元素
arr1[2] = 100;           // 修改元素

// 遍历数组
for (int i = 0; i < arr1.length; i++) { ... }  // 普通for循环
for (int num : arr1) { ... }                   // 增强for循环

// 数组工具类（Arrays）
Arrays.sort(arr1);       // 排序
int index = Arrays.binarySearch(arr1, 2);  // 二分查找
int[] copy = Arrays.copyOf(arr1, arr1.length);  // 复制数组

二、链表（LinkedList）

特点：

  • 动态数据结构，元素通过节点连接，内存不连续。
  • 插入 / 删除效率高（O (1)），随机访问效率低（O (n)）。
  1. Java 内置 LinkedList（双向链表）
import java.util.LinkedList;

// 创建
LinkedList<Integer> list = new LinkedList<>();  // 空链表
LinkedList<String> list2 = new LinkedList<>(Arrays.asList("a", "b", "c"));  // 初始化

// 添加元素
list.add(1);          // 尾部添加（O(1)）
list.addFirst(0);     // 头部添加（O(1)）
list.add(2, 100);     // 指定位置插入（O(n)）

// 删除元素
list.remove(0);       // 删除头部（O(1)）
list.remove(Integer.valueOf(100));  // 删除指定值（O(n)）

// 访问元素
int first = list.getFirst();  // 取头部（O(1)）
int last = list.getLast();    // 取尾部（O(1)）
int element = list.get(1);    // 指定索引（O(n)）

// 遍历
for (int num : list) { ... }  // 增强for循环
Iterator<Integer> it = list.iterator();  // 迭代器
  1. 自定义单向链表（需手动实现）
class CustomLinkedList {
    private Node head;  // 头节点
    
    static class Node {
        int data;
        Node next;
        Node(int data) { this.data = data; }
    }
    
    // 添加元素（尾部）
    public void append(int data) {
        Node newNode = new Node(data);
        if (head == null) { head = newNode; return; }
        Node current = head;
        while (current.next != null) current = current.next;
        current.next = newNode;
    }
    
    // 删除元素（按值）
    public void delete(int data) {
        if (head == null) return;
        if (head.data == data) { head = head.next; return; }
        Node current = head;
        while (current.next != null && current.next.data != data) {
            current = current.next;
        }
        if (current.next != null) current.next = current.next.next;
    }
    
    // 遍历打印
    public void print() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}

三、栈（Stack）

特点：

  • 后进先出（LIFO），基于数组或链表实现。
  • 推荐使用 Deque 接口（如 ArrayDeque）替代传统 Stack 类（性能更优）。

创建与初始化

import java.util.Deque;
import java.util.ArrayDeque;

// 创建栈（使用Deque接口）
Deque<Integer> stack = new ArrayDeque<>();  // 推荐方式

// 入栈
stack.push(1);    // 等价于 addFirst()
stack.push(2);

// 出栈
int top = stack.pop();    // 取出并删除栈顶（空栈抛异常）
int safeTop = stack.poll();  // 安全出栈（空栈返回null）

// 查看栈顶
int peek = stack.peek();  // 查看不删除

// 判断栈空
boolean isEmpty = stack.isEmpty();

四、队列（Queue）

特点：

  • 先进先出（FIFO），支持在队头删除、队尾插入。
  • 常用实现：LinkedList（链表队列）、ArrayDeque（数组队列）、PriorityQueue（优先队列）。

创建与初始化

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

// 普通队列（链表实现）
Queue<Integer> queue = new LinkedList<>();

// 优先队列（默认最小堆）
Queue<Integer> priorityQueue = new PriorityQueue<>();  // 元素需实现Comparable

// 双端队列
Deque<Integer> deque = new ArrayDeque<>();

常用操作

// 入队
queue.offer(1);    // 安全入队（返回boolean）
queue.add(2);      // 失败抛异常

// 出队
int front = queue.poll();    // 安全出队（空队返回null）
int frontThrow = queue.remove();  // 空队抛异常

// 查看队头
int peek = queue.peek();     // 查看不删除
int peekThrow = queue.element();  // 空队抛异常

// 双端队列额外操作
deque.offerFirst(0);   // 队头插入
deque.offerLast(3);    // 队尾插入
deque.pollFirst();     // 队头删除
deque.pollLast();      // 队尾删除

五、哈希表（HashMap/HashSet）

  1. HashMap（键值对存储）

特点：

  • 基于哈希表实现，键唯一，无序，非线程安全。

创建与初始化

import java.util.HashMap;

// 创建
HashMap<String, Integer> map = new HashMap<>();  // 空Map
HashMap<String, Integer> map2 = new HashMap<>() {{
    put("a", 1);
    put("b", 2);
}};  // 初始化（不推荐匿名内部类）

常用操作

// 添加/修改
map.put("c", 3);
map.put("a", 100);  // 覆盖已有键

// 获取
int value = map.get("a");        // 存在返回值，不存在返回null
int defaultValue = map.getOrDefault("d", 0);  // 不存在返回默认值

// 删除
map.remove("b");

// 判断键存在
boolean containsKey = map.containsKey("a");

// 遍历
for (String key : map.keySet()) { ... }  // 遍历键
for (int val : map.values()) { ... }     // 遍历值
for (Map.Entry<String, Integer> entry : map.entrySet()) { ... }  // 遍历键值对
  1. HashSet（唯一元素集合）

特点：

  • 基于 HashMap 实现，元素唯一，无序。

创建与初始化

import java.util.HashSet;

// 创建
HashSet<Integer> set = new HashSet<>();  // 空Set
HashSet<Integer> set2 = new HashSet<>(Arrays.asList(1, 2, 3));  // 初始化

常用操作

// 添加元素
set.add(4);      // 添加成功返回true，重复元素返回false

// 删除元素
set.remove(2);

// 判断元素存在
boolean contains = set.contains(3);

// 遍历
for (int num : set) { ... }

六、树（Tree）

特点：

  • 层次化结构，常用实现：二叉搜索树（BST）、平衡树（如红黑树）。
  • Java 内置：TreeSet（有序集合）、TreeMap（有序映射），基于红黑树实现
  1. TreeSet（有序集合）
import java.util.TreeSet;

// 创建
TreeSet<Integer> treeSet = new TreeSet<>();  // 自然排序（升序）

// 添加元素
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);  // 自动排序为 [1, 2, 3]

// 获取元素
int first = treeSet.first();  // 获取最小元素
int last = treeSet.last();    // 获取最大元素

// 范围查询
TreeSet<Integer> subset = (TreeSet<Integer>) treeSet.subSet(1, true, 3, false);  // [1, 3)

// 遍历（有序）
for (int num : treeSet) { ... }
  1. TreeMap（有序键值对）
import java.util.TreeMap;

// 创建
TreeMap<String, Integer> treeMap = new TreeMap<>();  // 按键自然排序

// 添加元素
treeMap.put("c", 3);
treeMap.put("a", 1);  // 按键排序为 {"a":1, "c":3}

// 获取元素
int value = treeMap.get("a");

// 范围查询
SortedMap<String, Integer> subMap = treeMap.subMap("a", "c");  // ["a", "c")

// 遍历（按键有序）
for (Map.Entry<String, Integer> entry : treeMap.entrySet()) { ... }

七、图（Graph）

特点：

  • 多对多关系，由节点（Vertex）和边（Edge）组成。
  • Java 无内置图结构，需自定义实现（邻接表或邻接矩阵）

邻接表实现（示例）

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

class Graph {
    private int vertices;                // 节点数
    private List<List<Integer>> adjList; // 邻接表

    public Graph(int vertices) {
        this.vertices = vertices;
        adjList = new ArrayList<>(vertices);
        for (int i = 0; i < vertices; i++) {
            adjList.add(new ArrayList<>());  // 初始化每个节点的邻接表
        }
    }

    // 添加边（无向图）
    public void addEdge(int u, int v) {
        adjList.get(u).add(v);
        adjList.get(v).add(u);
    }

    // 打印邻接表
    public void printGraph() {
        for (int i = 0; i < vertices; i++) {
            System.out.println("节点 " + i + " 的邻接节点: " + adjList.get(i));
        }
    }
}

八、堆（Heap）

特点：

  • 完全二叉树，分为最大堆（父节点≥子节点）和最小堆（父节点≤子节点）。
  • Java 中通过 PriorityQueue 实现（默认最小堆）。

创建与初始化

import java.util.PriorityQueue;

// 最小堆（默认）
PriorityQueue<Integer> minHeap = new PriorityQueue<>();

// 最大堆（通过比较器实现）
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);

// 添加元素
minHeap.offer(3);
minHeap.offer(1);

// 获取堆顶元素
int min = minHeap.poll();  // 取出最小元素
int peek = minHeap.peek(); // 查看堆顶不删除
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赢过我也要赢过生活

清风携意过蓬莱，谢君慷慨赠云彩

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值