Java数据结构：数组、向量、集合

GUMP小甘

已于 2023-11-13 15:30:27 修改

阅读量207

点赞数

分类专栏： JAVA 文章标签： java 数据结构算法

于 2023-11-12 15:58:56 首次发布

本文链接：https://blog.csdn.net/weixin_53850894/article/details/134359946

版权

JAVA 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

文章目录

一、数组
- 示例：数组Demo：
二、向量
- 示例：向量Demo
三、集合：List接口
四、集合：set接口
五、集合：Map接口
六、集合：Queue接口
- 示例0：QueueDemo
- 示例1：QueueDemoSql
七、总结

一、数组

在Java中，数组是一种用于存储相同类型数据的数据结构。数组具有固定大小，一旦创建，其大小不能更改。数组中的元素可以通过索引访问，索引从0开始。

以下是关于Java数组的一些基本概念和操作：

1. 数组的声明和初始化：

// 声明一个整数数组
int[] intArray;

// 初始化一个整数数组，长度为5
intArray = new int[5];

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

// 简化方式，长度为3的字符串数组
String[] stringArray = {"apple", "banana", "orange"};

2. 访问数组元素：

// 访问数组元素
int firstElement = intArray[0]; // 第一个元素
int thirdElement = anotherIntArray[2]; // 第三个元素
String fruit = stringArray[1]; // 第二个元素

3. 数组长度：

int lengthOfIntArray = intArray.length;
int lengthOfAnotherIntArray = anotherIntArray.length;
int lengthOfStringArray = stringArray.length;

4. 循环遍历数组：

// 使用for循环遍历整数数组
for (int i = 0; i < intArray.length; i++) {
    System.out.print(intArray[i] + " ");
}
System.out.println();

// 使用增强型for循环遍历字符串数组
for (String fruit : stringArray) {
    System.out.print(fruit + " ");
}
System.out.println();

5. 多维数组：

// 声明和初始化二维数组
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

// 访问二维数组元素
int element = matrix[1][2]; // 访问第二行第三列的元素

这些是关于Java数组的基本操作。数组在Java中是非常常用的数据结构，用于存储和处理大量数据。

示例：数组Demo：

package com.structure;


public class ArrayDemo {

    public static void main(String[] args) {

        /**
         * 整数数组
         */
        int[] intArray = new int[5];
        for(int i = 0; i<5; i++){
            intArray[i] = i;
        }

        System.out.println("整数数组:");
        for (int value : intArray){
            System.out.print(value  + " ");
        }

        System.out.println();

        /**
         * 字符数组
         */
        String[] stringArray = {"one", "two", "three", "four", "five"};

        //打印字符串数组
        System.out.println("字符串数组:");
        for(String value : stringArray){
            System.out.print(value + " ");
        }
    }
}

二、向量

在 Java 中，Vector 是一个传统的、同步的、可变大小的集合类。它实现了动态数组，可以根据需要自动增长或缩小。Vector 是线程安全的，这意味着多个线程可以安全地访问它，而无需额外的同步。

以下是关于 Vector 的基本概念和操作：

1. 创建和初始化 Vector：

import java.util.Vector;

// 创建一个整数向量
Vector<Integer> integerVector = new Vector<>();

// 创建一个字符串向量，初始容量为10，每次增长2倍
Vector<String> stringVector = new Vector<>(10, 2);

2. 向 Vector 中添加元素：

// 添加元素到整数向量
integerVector.add(10);
integerVector.add(20);
integerVector.add(30);

// 添加元素到字符串向量
stringVector.add("apple");
stringVector.add("banana");
stringVector.add("orange");

3. 访问 Vector 中的元素：

// 获取整数向量中的元素
int firstElement = integerVector.get(0);
int secondElement = integerVector.elementAt(1);

// 获取字符串向量中的元素
String fruit = stringVector.get(2);

4. 遍历 Vector：

// 使用for循环遍历整数向量
for (int i = 0; i < integerVector.size(); i++) {
    System.out.print(integerVector.get(i) + " ");
}
System.out.println();

// 使用增强型for循环遍历字符串向量
for (String item : stringVector) {
    System.out.print(item + " ");
}
System.out.println();

5. 其他操作：

// 获取向量的大小
int sizeOfIntegerVector = integerVector.size();

// 判断向量是否为空
boolean isEmpty = stringVector.isEmpty();

// 删除元素
stringVector.remove("banana");

Vector 是一个相对较老的集合类，在现代 Java 中，一般推荐使用 ArrayList 或 LinkedList，因为它们在大多数情况下性能更好。但如果需要线程安全的集合，Vector 仍然是一个合适的选择。

Vector 是可以用来存储数据库中的数据的，但在现代的 Java 编程中，更常见的做法是使用更灵活的集合类，如 ArrayList 或 LinkedList。

示例：向量Demo

package com.structure;

import java.util.Vector;


/**
 * 我们使用了 Vector<Integer> 来存储整数。Vector 是 Java 中的一个传统的、线程安全的集合类。
 * 与 ArrayList 类似，它也是可变大小的数组实现。与 ArrayList 不同的是，Vector 是同步的，
 * 这意味着在多线程环境下使用时，操作是线程安全的。
 *
 * 在使用 Vector 时，可以像使用其他集合一样，通过 add 方法向其中添加元素，
 * 并通过增强型 for 循环遍历和打印元素。
 */
public class VectorDemo {

    public static void main(String[] args) {
        //定义一个整数变量
        Vector<Integer> integerVector = new Vector<>();

        //向向量中添加数据
        for(int i = 0; i < 5; i++){
            integerVector.add(i * 3);
        }

        //打印向量中的数据
        System.out.println("整数向量：");
        for(int value : integerVector){
            System.out.print(value + " ");
        }

        // 字符串向量
        Vector<String> stringVector = new Vector<>();
        stringVector.add("one");
        stringVector.add("two");
        stringVector.add("three");
        stringVector.add("four");
        stringVector.add("five");


        System.out.println();

        // 打印字符串向量
        System.out.println("字符串向量:");
        for (String value : stringVector) {
            System.out.print(value + " ");
        }
    }
}

三、集合：List接口

List 接口是 Java 集合框架中的一个基本接口，它表示有序、可重复的集合。List 继承自 Collection 接口，扩展了集合的功能，支持按索引访问元素，提供了一系列对列表进行操作的方法。常见的 List 实现类有 ArrayList、LinkedList 和 Vector。

关于ArrayList、LinkedList和Vector的区别

以下是关于 List 接口的主要特性和使用方法：

特性：

有序性： List 中的元素按照它们被添加的顺序保存，可以通过索引访问。
可重复性： List 允许存储相同的元素。

常用方法：

添加元素：

List<String> list = new ArrayList<>();

// 添加元素到列表的末尾
list.add("One");
list.add("Two");

// 在指定位置插入元素
list.add(1, "Three");

获取元素：

// 通过索引获取元素
String element = list.get(1);

修改元素：

// 通过索引修改元素
list.set(1, "NewTwo");

删除元素：

// 通过索引删除元素
list.remove(1);

// 删除指定元素（第一次出现的）
list.remove("Two");

遍历列表：

// 使用for循环
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

// 使用增强型for循环
for (String item : list) {
    System.out.println(item);
}

其他操作：

// 获取列表的大小
int size = list.size();

// 判断列表是否为空
boolean isEmpty = list.isEmpty();

示例0：

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

public class ListExample {
    public static void main(String[] args) {
        // 创建一个字符串列表
        List<String> stringList = new ArrayList<>();

        // 添加元素
        stringList.add("One");
        stringList.add("Two");
        stringList.add("Three");

        // 遍历并打印列表元素
        System.out.println("遍历列表:");
        for (String item : stringList) {
            System.out.println(item);
        }

        // 获取并修改元素
        String secondElement = stringList.get(1);
        System.out.println("第二个元素: " + secondElement);

        stringList.set(1, "NewTwo");

        // 删除元素
        stringList.remove("Three");

        // 打印修改后的列表
        System.out.println("修改后的列表:");
        for (String item : stringList) {
            System.out.println(item);
        }
    }
}

示例1： ListDemo（存整数、字符串）

package com.structure;

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListDemo {

    public static void main(String[] args) {
        /**
         * List (ArrayList)
         */
        //定义一个整数列表
        List<Integer> integerList = new ArrayList<>();
        //向列表中添加数据
        for(int i = 0; i < 5; i++){
            integerList.add(i * 2);
        }

        //打印列表中的数据
        System.out.println("整数列表");
        for(int value : integerList){
            System.out.print(value + " ");
        }
        System.out.println();


        /**
         * List (LinkedList)
         */
        //定义一个字符串列表
        List<String> stringList = new LinkedList<>();
        //向列表中添加数据
        stringList.add("one");
        stringList.add("two");
        stringList.add("three");

        //打印字符串列表
        System.out.println("字符串列表");
        for(String value : stringList){
            System.out.print(value + " ");
        }
    }
}

示例2： ListDemoSql（存数据）

package com.structure;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class ListDemoSql{

    public static void main(String[] args) {
        // 连接数据库
        String url = "jdbc:mysql://localhost:3306/testdb";
        String username = "root";
        String password = "123456";

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            // 查询数据库获取学生数据
            List<Student> studentList = getStudentDataFromDatabase(connection);

            // 打印学生列表
            System.out.println("学生列表:");
            for (Student student : studentList) {
                System.out.println(student);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 从数据库查询学生数据并存储到List中
    private static List<Student> getStudentDataFromDatabase(Connection connection) throws SQLException {
        List<Student> studentList = new ArrayList<>();

        String query = "SELECT * FROM student";
        try (Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery(query)) {

            while (resultSet.next()) {
                int studentId = resultSet.getInt("id");
                String name = resultSet.getString("stuname");
                int age = resultSet.getInt("age");

                // 创建Student对象并添加到List中
                Student student = new Student(studentId, name, age);
                studentList.add(student);
            }
        }

        return studentList;
    }


    // 定义Student类(内部类)
    static class Student {
        private int id;
        private String name;
        private int age;

        public Student(int id, String name, int age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

四、集合：set接口

Set 接口是 Java 集合框架中的一种集合类型，它代表了一个不包含重复元素的集合。Set 不保证元素的顺序，而且允许存储 null 元素（但通常不推荐在集合中存储 null）。

Set 接口继承自 Collection 接口，不允许重复元素的特性使得它特别适用于需要存储唯一元素的场景。Set 接口的主要实现类有 HashSet、LinkedHashSet 和 TreeSet。

关于HashSet、LinkedHashSet和 TreeSet的区别
以下是关于 Set 接口的主要特性和使用方法：

特性：

无序性： Set 不保证元素的顺序，即你不能依赖于元素的插入顺序来访问它们。
不允许重复： Set 不允许存储重复元素，如果试图添加重复元素，添加操作将被忽略。

常用方法：

添加元素：

Set<String> set = new HashSet<>();

// 添加元素
set.add("One");
set.add("Two");
set.add("Three");

删除元素：
```
// 删除元素
set.remove("Two");
```

检查包含关系：

// 检查元素是否存在
boolean containsElement = set.contains("One");

获取集合大小：

// 获取集合大小
int size = set.size();

遍历集合：

// 使用增强型for循环遍历集合
for (String item : set) {
    System.out.println(item);
}

其他操作：

// 清空集合
set.clear();

// 判断集合是否为空
boolean isEmpty = set.isEmpty();

示例0：

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

public class SetExample {
    public static void main(String[] args) {
        // 创建一个字符串集合
        Set<String> stringSet = new HashSet<>();

        // 添加元素
        stringSet.add("One");
        stringSet.add("Two");
        stringSet.add("Three");

        // 遍历并打印集合元素
        System.out.println("遍历集合:");
        for (String item : stringSet) {
            System.out.println(item);
        }

        // 删除元素
        stringSet.remove("Two");

        // 打印修改后的集合
        System.out.println("修改后的集合:");
        for (String item : stringSet) {
            System.out.println(item);
        }
    }
}

示例1：SetDemo（存整数、字符串）

package com.structure;

import java.util.*;

public class SetDemo {

    public static void main(String[] args) {
        /**
         * Set (HashSet)
         */
        //创建一个整数set集合
        Set<Integer> integerSet = new HashSet<>();
        //向列表中添加数据
        for(int i = 0; i < 5; i++){
            integerSet.add(i*i);
        }
        //打印列表中的数据
        System.out.println("HashSet整数");
        for (int value : integerSet){
            System.out.print(value + " ");
        }

        System.out.println();

        /**
         * Set (LinkedHashSet)
         */
        Set<Integer> integerSet1 = new LinkedHashSet<>();
        //向列表中添加数据
        for(int i = 0; i < 5; i++){
            integerSet1.add(i*i);
        }
        //打印列表中的数据
        System.out.println("LinkedHashSet整数");
        for(int value : integerSet1){
            System.out.print(value + " ");
        }

        System.out.println();


        /**
         * Set (TreeSet)
         */
        //定义一个字符串列表
        Set<String> stringSet = new TreeSet<>();
        //向列表中添加数据
        stringSet.add("one");
        stringSet.add("two");
        stringSet.add("three");
        stringSet.add("three");

        //打印字符串列表
        System.out.println("TreeSet字符串列表");
        for(String value : stringSet){
            System.out.print(value + " ");
        }
    }
}

示例2：SetDemoSql（检索唯一数据）

可以使用 Set 接口的实现类（如 HashSet、LinkedHashSet 或 TreeSet）来存储数据库中的数据。通常情况下，更常用的是使用 List 接口的实现类，如 ArrayList 或 LinkedList，因为 List 可以按顺序存储元素，而 Set 不保证元素的顺序。

如果你想要从数据库中检索一组唯一的元素，并且不关心元素的顺序，那么使用 Set 是一个不错的选择。例如：

import java.sql.*;
import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        // 连接数据库
        String url = "jdbc:mysql://localhost:3306/your_database";
        String username = "your_username";
        String password = "your_password";

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            // 查询数据库获取一组唯一的数据
            Set<String> uniqueData = getUniqueDataFromDatabase(connection);

            // 打印唯一的数据
            System.out.println("唯一的数据:");
            for (String item : uniqueData) {
                System.out.println(item);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 从数据库查询唯一的数据并存储到Set中
    private static Set<String> getUniqueDataFromDatabase(Connection connection) throws SQLException {
        Set<String> uniqueData = new HashSet<>();

        String query = "SELECT DISTINCT column_name FROM your_table";
        try (Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery(query)) {

            while (resultSet.next()) {
                String value = resultSet.getString("column_name");
                uniqueData.add(value);
            }
        }

        return uniqueData;
    }
}

在这个例子中，通过使用 HashSet 来存储数据库中的唯一数据。你可以根据实际需求选择其他的 Set 实现类。

五、集合：Map接口

Map 接口是 Java 集合框架中的一种键值对映射的数据结构，用于存储键值对并提供了根据键快速查找值的能力。每个键对应唯一的值，而一个值可以对应多个键。Map 接口定义了用于操作键值对的一系列方法。常见的实现类有：HashMap、LinkedHashMap、TreeMap等。
关于HashMap、LinkedHashMap和TreeMap的区别

以下是 Map 接口的一些主要特性和使用方法：

特性：

键唯一性： 每个键在一个 Map 中是唯一的，不能重复。
键值对映射： 每个键都对应一个值，形成键值对（key-value pair）。
无序性： Map 的实现类可能不保证元素的顺序，即不会按照插入或者其他顺序存储元素。

常用方法：

添加键值对：

Map<String, Integer> map = new HashMap<>();

// 添加键值对
map.put("One", 1);
map.put("Two", 2);
map.put("Three", 3);

获取值：

// 根据键获取值
int value = map.get("Two");

删除键值对：

// 根据键删除键值对
map.remove("Two");

判断键是否存在：

// 判断键是否存在
boolean containsKey = map.containsKey("Two");

获取所有键或值的集合：

// 获取所有键的集合
Set<String> keys = map.keySet();

// 获取所有值的集合
Collection<Integer> values = map.values();

遍历键值对：

// 遍历键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    String key = entry.getKey();
    int value = entry.getValue();
    System.out.println("Key: " + key + ", Value: " + value);
}

示例0：MapDemo

package com.structure;

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

public class MapDemo {
    public static void main(String[] args) {
        // 创建一个字符串到整数的映射
        //<key,value>
        Map<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        // 根据键获取值
        int value = map.get("Two");
        System.out.println("Value for key 'Two': " + value);

        // 删除键值对
        map.remove("Two");

        // 遍历键值对
        System.out.println("Key-Value pairs:");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            int val = entry.getValue();
            System.out.println("Key: " + key + ", Value: " + val);
        }
    }
}

这个例子演示了如何创建、添加、获取、删除、判断键是否存在、获取键和值的集合，以及遍历 Map 中的键值对。 HashMap 是 Map 接口的一个常用实现类，用于快速查找和存储键值对。

示例1：MapDemoSql（存数据）

使用 Map 存储数据库中的数据是一种常见的方式，其中数据库表的列名可以作为键，而表中的每一行数据则以 Map 的形式存储在集合中。以下是一个简单的示例，演示如何使用 Map 存储数据库中的数据：

package com.structure;

import java.sql.*;
import java.util.HashMap;
import java.util.Map;

public class MapDemoSql {
    public static void main(String[] args) {
        // 连接数据库
        String url = "jdbc:mysql://localhost:3306/testdb";
        String username = "root";
        String password = "123456";

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            // 查询数据库获取数据
            Map<String, Object> dataMap = getDataFromDatabase(connection, "student");

            // 打印数据
            System.out.println("Data from database:");
            for (Map.Entry<String, Object> entry : dataMap.entrySet()) {
                String columnName = entry.getKey();
                Object columnValue = entry.getValue();
                System.out.println(columnName + ": " + columnValue);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 从数据库查询数据并存储到Map中
    private static Map<String, Object> getDataFromDatabase(Connection connection, String student) throws SQLException {
        Map<String, Object> dataMap = new HashMap<>();

        // 获取表的列名
        ResultSetMetaData metaData = connection.createStatement().executeQuery("SELECT * FROM " + student + " LIMIT 1").getMetaData();
        int columnCount = metaData.getColumnCount();
        for (int i = 1; i <= columnCount; i++) {
            String columnName = metaData.getColumnName(i);
            dataMap.put(columnName, null); // 初始化值为null，具体情况可以根据需求更改
        }

        // 查询表数据
        String query = "SELECT * FROM " + student;
        try (Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery(query)) {

            // 遍历每一行数据
            while (resultSet.next()) {
                // 遍历列，将列名和对应的值存储到Map中
                for (int i = 1; i <= columnCount; i++) {
                    String columnName = metaData.getColumnName(i);
                    Object columnValue = resultSet.getObject(i);
                    dataMap.put(columnName, columnValue);
                }

                // 打印当前行的数据
                System.out.println("Data for current row:");
                for (Map.Entry<String, Object> entry : dataMap.entrySet()) {
                    String columnName = entry.getKey();
                    Object columnValue = entry.getValue();
                    System.out.println(columnName + ": " + columnValue);
                }
                System.out.println("------------------------");
            }
        }

        return dataMap;
    }
}

请注意，这只是一个简单的示例。在实际应用中，你可能需要根据具体的业务需求和数据库表结构进行调整。在这个示例中，getDataFromDatabase 方法获取数据库表的列名，然后查询表数据，并将每一行数据存储在 Map 中，其中键是列名，值是相应的列值。

六、集合：Queue接口

Queue 接口是 Java 集合框架中的一种队列（Queue）数据结构的表示。队列是一种先进先出（FIFO）的数据结构，即最先添加的元素最先被取出。Queue 接口继承自 Collection 接口，定义了一些与队列操作相关的方法。常见的实现类有：LinkedList（可以用作队列）、PriorityQueue等
关于LinkedList和PriorityQueue的区别
以下是一些 Queue 接口的常见方法：

添加元素：
- boolean add(E e): 将指定的元素插入到队列中，如果插入成功则返回 true，如果队列已满则抛出异常。
- boolean offer(E e): 将指定的元素插入到队列中，如果插入成功则返回 true，如果队列已满则返回 false。
获取并移除元素：
- E remove(): 获取并移除队列的头部元素，如果队列为空则抛出异常。
- E poll(): 获取并移除队列的头部元素，如果队列为空则返回 null。
获取但不移除元素：
- E element(): 获取但不移除队列的头部元素，如果队列为空则抛出异常。
- E peek(): 获取但不移除队列的头部元素，如果队列为空则返回 null。

Queue 接口有多个实现类，其中常用的包括：

LinkedList: 通过链表实现，可以作为队列或双端队列使用。
PriorityQueue: 通过堆实现的优先级队列，元素按照优先级排序。

示例0：QueueDemo

package com.structure;

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

public class QueueDemo {

    public static void main(String[] args) {
        // 创建一个队列
        Queue<String> queue = new LinkedList<>();

        // 添加元素
        queue.offer("Element 1");
        queue.offer("Element 2");
        queue.offer("Element 3");

        // 获取并移除元素
        String removedElement = queue.poll();
        System.out.println("Removed element: " + removedElement);

        // 获取但不移除元素
        String peekedElement = queue.peek();
        System.out.println("Peeked element: " + peekedElement);

        // 遍历队列
        System.out.println("Queue elements:");
        for (String element : queue) {
            System.out.println(element);
        }
    }
}

在这个示例中，我们创建了一个 LinkedList 实现的 Queue，并使用 offer 方法添加元素，poll 方法获取并移除元素，peek 方法获取但不移除元素，最后使用迭代器遍历队列中的元素。请注意，Queue 接口和其实现类提供了多种其他方法，具体使用取决于需求。

示例1：QueueDemoSql

使用 Queue 存储数据库数据的常见情况是进行异步处理，比如数据的批量插入或数据处理的任务队列。你可以将数据库查询的结果放入队列中，然后在后台的线程中逐个处理这些数据。下面是一个简单的示例，演示如何使用 Queue 存储数据库数据：

import java.sql.*;
import java.util.LinkedList;
import java.util.Queue;

public class DatabaseQueueExample {
    public static void main(String[] args) {
        // 连接数据库
        String url = "jdbc:mysql://localhost:3306/testdb";
        String username = "root";
        String password = "123456";

        // 创建一个数据库连接
        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            // 查询数据库获取数据
            Queue<String> dataQueue = getDataFromDatabase(connection, "your_table");

            // 处理队列中的数据（在实际应用中，这部分逻辑可能在后台线程中执行）
            processQueueData(dataQueue);

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 从数据库查询数据并存储到Queue中
    private static Queue<String> getDataFromDatabase(Connection connection, String tableName) throws SQLException {
        Queue<String> dataQueue = new LinkedList<>();

        // 查询表数据
        String query = "SELECT * FROM " + tableName;
        try (Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery(query)) {

            // 遍历每一行数据
            while (resultSet.next()) {
                // 获取列值并放入队列
                String columnValue = resultSet.getString("your_column_name");
                dataQueue.offer(columnValue);
            }
        }

        return dataQueue;
    }

    // 处理队列中的数据的示例方法
    private static void processQueueData(Queue<String> dataQueue) {
        while (!dataQueue.isEmpty()) {
            String data = dataQueue.poll();
            // 在实际应用中，这里可以添加具体的数据处理逻辑
            System.out.println("Processing data: " + data);
        }
    }
}

在这个示例中，getDataFromDatabase 方法将数据库中的某一列数据存储到 Queue 中，然后 processQueueData 方法模拟了对队列中数据的处理。请注意，实际应用中可能需要使用线程池等机制来异步处理队列中的数据，以避免阻塞主线程。

七、总结

（一）关于数组、向量、集合的优缺点以及使用场景：

Arrays（数组）、Vectors（向量）、和Collections（集合）是 Java 中不同的数据结构，它们各自有优缺点，并适用于不同的使用场景。以下是对它们的简要介绍：

1. 数组（Arrays）：

优点：

快速随机访问： 数组允许通过索引直接访问元素，因此对于随机访问来说非常高效。
基本类型支持： 数组可以直接存储基本数据类型，而不需要使用装箱拆箱。

缺点：

固定大小： 数组的大小在创建时就确定，并且无法动态改变。如果需要更灵活的大小，可能需要创建一个新的数组。
不支持集合操作： 没有提供高级的集合操作，如添加、删除元素时需要手动管理。

使用场景：

当元素数量已知且不经常变化时。
需要高效的随机访问元素。

2. 向量（Vector）：

优点：

动态大小： 向量可以动态增长或缩小，根据需要自动调整大小。
线程安全： Vector 是同步的，因此适用于多线程环境。

缺点：

性能： 相对于 ArrayList 和 LinkedList 等新的集合实现，Vector 的性能相对较差。
过时： 在 Java 集合框架被引入后，更推荐使用 ArrayList。

使用场景：

在多线程环境下需要同步的情况。
当使用旧代码或需要与旧代码集成时。

3. 集合（Collections）：

优点：

灵活性： 集合框架提供了丰富的接口和实现，包括 List、Set、Map 等，适用于不同的使用场景。
动态调整大小： 集合类（如 ArrayList、LinkedList）可以动态增长或缩小，不需要手动管理大小。

缺点：

性能： 一些集合类在某些特定情况下可能不如数组效率高。

使用场景：

当需要动态调整大小的数据结构时，可以选择 ArrayList、LinkedList 等。
当需要表示键值对关系时，可以选择 HashMap、TreeMap 等。

综合来说，根据实际需求，可以选择不同的数据结构。数组适用于已知大小的情况，向量适用于需要同步的多线程环境，而集合框架提供了更灵活、功能更强大的选择，适用于大多数情况。在选择时，还要考虑性能、线程安全性以及代码的简洁性。

（二）关于各种集合接口的优缺点以及使用场景：

Java 提供了丰富的集合接口，每个接口都有其特定的优缺点和适用场景。以下是一些常见的集合接口及其特点：

1. List 接口：

优点：

有序： List 接口的实现类（如 ArrayList、LinkedList）维护了元素的顺序。
可以存储重复元素： 允许存储相同的元素。

缺点：

随机访问性能： 在链表实现中，随机访问元素的性能相对较差。

使用场景：

当需要按照插入顺序存储元素，或者需要经常随机访问元素时。

2. Set 接口：

优点：

元素唯一： Set 不允许存储重复的元素。
集合操作： 提供了丰富的集合操作方法（如交集、并集、差集）。

缺点：

无序性： Set 接口的实现类（如 HashSet、LinkedHashSet、TreeSet）不保证元素的顺序。

使用场景：

当需要保证元素唯一性，而不关心元素的顺序时。
当需要执行集合操作时，如合并两个集合的元素。

3. Queue 接口：

优点：

FIFO（先进先出）： Queue 接口的实现类（如 LinkedList）通常按照队列的原则进行元素操作。

缺点：

不适用于随机访问： Queue 主要用于在队列两端进行元素的添加和移除。

使用场景：

当需要按照先进先出的规则进行元素操作时。
用于实现任务调度、消息传递等场景。

4. Map 接口：

优点：

键值对存储： Map 接口的实现类（如 HashMap、TreeMap）存储键值对，便于表示映射关系。
快速查找： 通过键可以快速查找对应的值。

缺点：

无序性： Map 接口的实现类不保证键值对的顺序。

使用场景：

当需要表示键值对映射关系时。
用于快速查找、关联数据。

总结：

List 适用于按照插入顺序存储元素的场景。
Set 适用于需要元素唯一性的场景。
Queue 适用于先进先出的队列场景。
Map 适用于键值对映射关系的场景。

在选择集合接口时，要根据实际需求考虑元素的唯一性、有序性以及对性能的要求。有时，结合使用多个集合接口的实现类能更好地满足特定的需求。例如，使用 LinkedHashMap 可以保留元素的插入顺序，同时又具备 Map 接口的键值对特性。

GUMP小甘

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java数据结构：数组、向量、集合

Arrays（数组）、Vectors（向量）、和Collections（集合）是 Java 中不同的数据结构，它们各自有优缺点，并适用于不同的使用场景。List 适用于按照插入顺序存储元素的场景。Set 适用于需要元素唯一性的场景。Queue 适用于先进先出的队列场景。Map 适用于键值对映射关系的场景。在选择集合接口时，要根据实际需求考虑元素的唯一性、有序性以及对性能的要求。有时，结合使用多个集合接口的实现类能更好地满足特定的需求。
复制链接

扫一扫