1. Python技术站首页
  2. 数据结构

Java常见基础数据结构

• 数据结构

Java常见基础数据结构攻略

Java是一种面向对象的编程语言，拥有丰富的数据结构，大多数基础数据结构都包含在Java API中。在本文中，我们将讨论Java中常见的基础数据结构，包括数组、链表、栈、队列、集合和映射。我们将探讨每种数据结构的定义、用法和基本操作，并提供两个示例说明。

数组

数组是Java中最基本的数据结构之一。它是一个有序的集合，可以包含任何类型的元素。在使用数组之前，必须先定义它的大小。以下是声明和初始化一个整数类型数组的语法：

int[] arr = new int[10];

下面以求和为例，介绍数组的基本操作。

访问数组元素

数组中的每个元素都有一个唯一的索引或位置，可以使用数组名称和元素的索引来访问。Java中的数组索引从0开始，因此第一个元素的索引为0。以下是一个例子：

int[] arr = {1, 2, 3, 4, 5};
int sum = arr[0] + arr[1] + arr[2] + arr[3] + arr[4];
System.out.println(sum); // 输出15

更改数组元素

可以使用数组名称和元素的索引来更改数组中的元素。以下是一个例子：

int[] arr = {1, 2, 3, 4, 5};
arr[2] = 6;
System.out.println(Arrays.toString(arr)); // 输出 [1, 2, 6, 4, 5]

数组长度

可以使用数组的length属性获取数组的长度。以下是一个例子：

int[] arr = {1, 2, 3, 4, 5};
System.out.println(arr.length); // 输出 5

链表

链表是由一系列节点组成的。每个节点包含一个元素和一个指向下一个节点的引用。最后一个节点通常包含一个空引用。以下是一个定义节点的Java类：

class Node<T> {
    T data;
    Node<T> next;

    public Node(T data) {
        this.data = data;
    }
}

下面以遍历链表为例，介绍链表的基本操作。

遍历链表

遍历链表是指访问链表中的所有节点。可以使用循环遍历每个节点，直到到达链表的末尾。以下是一个例子：

Node<String> head = new Node<>("A");
head.next = new Node<>("B");
head.next.next = new Node<>("C");

Node<String> current = head;
while (current != null) {
    System.out.print(current.data + " ");
    current = current.next;
}
// 输出A B C

插入节点

可以在链表的任何位置插入一个新节点。插入节点之前，必须找到插入位置的前一个节点。以下是一个插入节点的例子：

Node<String> head = new Node<>("A");
head.next = new Node<>("B");
head.next.next = new Node<>("C");

Node<String> newNode = new Node<>("D");
newNode.next = head.next;
head.next = newNode;

Node<String> current = head;
while (current != null) {
    System.out.print(current.data + " ");
    current = current.next;
}
// 输出 A D B C

栈

栈是一种后进先出（LIFO）的数据结构。栈有两个基本操作：推入元素和弹出元素。以下是一个定义栈的Java类：

class Stack<T> {
    private List<T> list = new ArrayList<>();

    public void push(T item) {
        list.add(item);
    }

    public T pop() {
        if (list.isEmpty()) {
            throw new RuntimeException("Stack is Empty!");
        }
        return list.remove(list.size() - 1);
    }

    public boolean isEmpty() {
        return list.isEmpty();
    }

    public int size() {
        return list.size();
    }
}

下面以十进制转二进制为例，介绍栈的基本操作。

推入元素

可以使用push方法将元素推入栈中。以下是一个十进制转二进制的例子：

int decimal = 10;
Stack<Integer> stack = new Stack<>();

while (decimal > 0) {
    int remainder = decimal % 2;
    stack.push(remainder);
    decimal /= 2;
}

while (!stack.isEmpty()) {
    System.out.print(stack.pop());
}
// 输出 1010

弹出元素

可以使用pop方法将栈顶元素弹出栈。以下是一个计算基本表达式的例子：

String expression = "2 + 3 * 4";
Stack<Integer> stack = new Stack<>();

for (String token : expression.split(" ")) {
    if (token.equals("+")) {
        int b = stack.pop();
        int a = stack.pop();
        stack.push(a + b);
    } else if (token.equals("*")) {
        int b = stack.pop();
        int a = stack.pop();
        stack.push(a * b);
    } else {
        stack.push(Integer.parseInt(token));
    }
}

System.out.println(stack.pop()); // 输出 14

队列

队列是一种先进先出（FIFO）的数据结构。队列有两个基本操作：入队和出队。以下是一个定义队列的Java类：

class Queue<T> {
    private List<T> list = new ArrayList<>();

    public void enqueue(T item) {
        list.add(item);
    }

    public T dequeue() {
        if (list.isEmpty()) {
            throw new RuntimeException("Queue is Empty!");
        }
        return list.remove(0);
    }

    public boolean isEmpty() {
        return list.isEmpty();
    }

    public int size() {
        return list.size();
    }
}

下面以BFS为例，介绍队列的基本操作。

入队元素

可以使用enqueue方法将元素入队。以下是一个BFS（广度优先搜索）的例子：

class Node {
    List<Node> neighbors = new ArrayList<>();
    String label;

    public Node(String label) {
        this.label = label;
    }
}

Node graph = new Node("A");
graph.neighbors.add(new Node("B"));
graph.neighbors.add(new Node("C"));
graph.neighbors.get(0).neighbors.add(new Node("D"));
graph.neighbors.get(0).neighbors.add(new Node("E"));

Queue<Node> queue = new Queue<>();
Set<Node> visited = new HashSet<>();

queue.enqueue(graph);
visited.add(graph);

while (!queue.isEmpty()) {
    Node current = queue.dequeue();
    System.out.print(current.label + " ");

    for (Node neighbor : current.neighbors) {
        if (!visited.contains(neighbor)) {
            queue.enqueue(neighbor);
            visited.add(neighbor);
        }
    }
}
// 输出 A B C D E

出队元素

可以使用dequeue方法将队头元素出队。以下是一个打印队列中的所有元素的例子：

Queue<String> queue = new Queue<>();
queue.enqueue("A");
queue.enqueue("B");
queue.enqueue("C");

while (!queue.isEmpty()) {
    System.out.print(queue.dequeue() + " ");
}
// 输出 A B C

集合

集合是一种不包含重复元素的数据结构。Java API提供了Set接口，可以用来实现集合。以下是一个使用Set的例子：

Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");
set.add("B"); // 重复元素

System.out.println(set); // 输出[A, B, C]

可以使用Stream API来操作集合。以下是一个过滤集合中的奇数元素并求和的例子：

Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5));
int sum = set.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();

System.out.println(sum); // 输出6

映射

映射是一种将键和值进行映射的数据结构。Java API提供了Map接口，可以用来实现映射。以下是一个使用Map的例子：

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

System.out.println(map.get("B")); // 输出 2

可以使用Stream API来操作键或值的集合。以下是一个过滤映射中的奇数值并求和的例子：

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

int sum = map.values().stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();

System.out.println(sum); // 输出2

总结

在Java中，有很多种不同的数据结构可供选择。本文介绍了Java中的常见基础数据结构，包括数组、链表、栈、队列、集合和映射。掌握这些数据结构可以让我们在编写Java程序时更加高效和灵活。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Java常见基础数据结构 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月16日
下一篇 2023年5月17日

相关文章

  • JavaScript中数据结构与算法(四)：串(BF)

    JavaScript中数据结构与算法(四)：串(BF) 一、串的定义 在计算机科学中，串（string）是由零个或多个字符组成的有限序列。零个字符的串称为空串（empty string），也叫做空格串（null string）。串中的字符数称为串的长度（length）。 二、串BF算法的定义 串的BF算法，也称为朴素算法（Brute-Force Algori…

    数据结构 2023年5月17日
    00

  • C++ 数据结构线性表-数组实现

    C++ 数据结构线性表-数组实现 什么是线性表 线性表，简单来说，就是一种有序的数据结构，数据元素起来往往构成一列，比如数组、链表等等。 数组实现线性表 数组是一种容器，它可以存储相同类型的数据元素。使用数组实现线性表，就是将数据元素按照一定的顺序依次存储在数组中。 数组实现线性表的基本思路 定义一个数组，用来存储数据元素； 定义一个变量，用来记录线性表中元…

    数据结构 2023年5月17日
    00

  • c++ 数据结构map的使用详解

    c++ 数据结构map的使用详解 什么是map map是C++ STL中提供的一种用以存储键值对（key-value）的容器。它能够以平均O(log n)复杂度进行搜索、插入、删除操作，并且保持元素顺序，是一种比较高效的数据结构。 map的基本用法 定义map 定义map需要包含头文件<map>。 语法：map<key_type, valu…

    数据结构 2023年5月17日
    00

  • 排序算法之详解冒泡排序

    引入 冒泡排序顾名思义，就是像冒泡一样，泡泡在水里慢慢升上来，由小变大。 虽然冒泡排序和冒泡并不完全一样，但却可以帮助我们理解冒泡排序。 思路 一组无序的数组，要求我们从小到大排列 我们可以先将最大的元素放在数组末尾 再将第二大的数放在数组的倒数第二个位置 再将第三大的数放在数组的倒数第三个位置 以此类推 那么现在问题的关键就是如何将 第 n 大的数 放在 …

    算法与数据结构 2023年4月25日
    00

  • Redis数据结构之链表与字典的使用

    Redis是一个开源、基于内存的数据结构存储系统。Redis支持多种数据类型，包括字符串、整数、浮点数、列表、哈希表、集合、有序集合等。本文将详细介绍Redis数据结构之链表与字典的使用。 链表 链表是Redis中常用的数据结构之一，主要用于存储有序的元素列表。链表中的每个元素都包含了一个指向前驱元素和后继元素的指针，这种结构可以方便地实现链表的插入、删除和…

    数据结构 2023年5月17日
    00

  • Java数据结构之堆(优先队列)的实现

    Java 数据结构之堆(优先队列)的实现 什么是堆(优先队列) 堆(Heap)是一种数据结构，使用数组实现。堆分为小根堆和大根堆，大根堆满足父节点值大于子节点，小根堆则相反。堆通常被用来实现优先队列(Priority Queue)。 优先队列(Priority Queue)是一个能够让用户迅速查找到队列中最小值（或最大值）的抽象数据类型（ADT）。优先队列通…

    数据结构 2023年5月17日
    00

  • C语言数据结构之简易计算器

    C语言数据结构之简易计算器攻略 简介 这是一个基于C语言的简易计算器，可以实现加、减、乘、除四个基本运算。 实现步骤 首先，需要声明四个变量，分别表示运算符、被加数、被减数、被乘数和被除数。 char op; double n1, n2, result; 然后，需要通过scanf()函数获取用户输入的运算符和数字。 printf(“请输入运算符和数字：\n”…

    数据结构 2023年5月17日
    00

  • C++高级数据结构之二叉查找树

    C++高级数据结构之二叉查找树 什么是二叉查找树 二叉查找树，也称二叉搜索树（BST，Binary Search Tree），是一种常见的基于二叉树的数据结构，主要用于快速查找与排序。在二叉查找树上，左子树的每个节点都比其根节点小，右子树的每个节点都比其根节点大，同时整棵树也满足二叉树的性质。 二叉查找树的实现 我们可以通过C++语言实现二叉查找树的基本操作…

    数据结构 2023年5月17日
    00
合作推广
合作推广
分享本页
返回顶部