Java容器简介

java常用容器简介

前言：在Java中，容器是一种用于存储和组织数据的对象。它们提供了一种方便的方式来管理和操作数据集合。Java提供了多种类型的容器，包括数组、集合和映射等。这些容器可以用于不同的目的，例如存储一组对象、实现数据结构或进行高效的搜索和排序操作。容器在Java中扮演着重要的角色，它们是开发Java应用程序的基础。

一、容器的概念

容器顾名思义就是装东西的器皿，而编程中的容器是指用来存放数据的"器皿"，方便管理和操作；如Set、List、Queue等

为了更直观的了解容器的分类与构成，以下是一张关于容器分类的思维导图：

二、介绍几种常用容器

1、Collection

• List

1.ArrayList：

ArrayList是一种基于数组实现的动态数组，可以动态增长和缩小。它提供了快速的随机访问和高效的增删操作，适用于频繁访问和修改列表元素的场景。

ArrayList 的简单演示使用：

import java.util.ArrayList;  
  
public class ArrayListExample {  
    public static void main(String[] args) {  
        // 创建一个ArrayList实例，用于存储整数  
        ArrayList<Integer> numbers = new ArrayList<>();  
  
        // 添加元素到ArrayList  
        numbers.add(10);  
        numbers.add(20);  
        numbers.add(30);  
  
        // 获取ArrayList的大小  
        int size = numbers.size();  
        System.out.println("ArrayList的大小: " + size);  
  
        // 遍历ArrayList并打印元素  
        System.out.println("ArrayList的元素:");  
        for (int i = 0; i < size; i++) {  
            int number = numbers.get(i);  
            System.out.println(number);  
        }  
  
        // 检查ArrayList中是否包含某个元素  
        boolean contains = numbers.contains(20);  
        System.out.println("ArrayList是否包含元素 20: " + contains);  
  
        // 修改ArrayList中的元素  
        numbers.set(1, 50);  
        System.out.println("修改后的ArrayList元素:");  
        for (int number : numbers) {  
            System.out.println(number);  
        }  
  
        // 删除ArrayList中的元素  
        numbers.remove(2);  
        System.out.println("删除后的ArrayList元素:");  
        for (int number : numbers) {  
            System.out.println(number);  
        }  
  
        // 清空ArrayList  
        numbers.clear();  
        System.out.println("清空ArrayList后的大小: " + numbers.size());  
    }  
}

返回目录

2.LinkedList：

LinkedList是一种双向链表实现的容器，它具有高效的插入和删除操作，但访问效率较低。它适用于频繁进行插入和删除操作的场景。

LinkedList 的简单演示使用：

import java.util.LinkedList;  
  
public class LinkedListExample {  
    public static void main(String[] args) {  
        // 创建一个LinkedList实例，用于存储字符串  
        LinkedList<String> names = new LinkedList<>();  
  
        // 添加元素到LinkedList的末尾  
        names.add("Alice");  
        names.add("Bob");  
        names.add("Charlie");  
  
        // 在LinkedList的开头添加元素  
        names.addFirst("Adam");  
  
        // 在LinkedList的指定索引位置插入元素  
        names.add(2, "Eve");  
  
        // 获取LinkedList的大小  
        int size = names.size();  
        System.out.println("LinkedList的大小: " + size);  
  
        // 遍历LinkedList并打印元素  
        System.out.println("LinkedList的元素:");  
        for (String name : names) {  
            System.out.println(name);  
        }  
  
        // 获取并移除LinkedList的第一个元素  
        String firstElement = names.pollFirst();  
        System.out.println("第一个元素被移除: " + firstElement);  
  
        // 获取并移除LinkedList的最后一个元素  
        String lastElement = names.pollLast();  
        System.out.println("最后一个元素被移除: " + lastElement);  
  
        // 检查LinkedList中是否包含某个元素  
        boolean contains = names.contains("Bob");  
        System.out.println("LinkedList是否包含元素 Bob: " + contains);  
  
        // 获取LinkedList的第一个和最后一个元素  
        String first = names.getFirst();  
        String last = names.getLast();  
        System.out.println("LinkedList的第一个元素: " + first);  
        System.out.println("LinkedList的最后一个元素: " + last);  
  
        // 清空LinkedList  
        names.clear();  
        System.out.println("清空LinkedList后的大小: " + names.size());  
    }  
}

返回目录

3.Stack：

Stack是一种后进先出（LIFO）的数据结构，Java提供了Stack类。Stack适用于回溯算法、表达式求值等场景。

Stack 的简单演示使用：

import java.util.Stack;  
  
public class StackExample {  
    public static void main(String[] args) {  
        // 创建一个Stack实例，用于存储字符串  
        Stack<String> stack = new Stack<>();  
  
        // 将元素压入栈  
        stack.push("Alice");  
        stack.push("Bob");  
        stack.push("Charlie");  
  
        // 获取栈的大小  
        int size = stack.size();  
        System.out.println("栈的大小: " + size);  
  
        // 查看栈顶元素  
        String topElement = stack.peek();  
        System.out.println("栈顶元素: " + topElement);  
  
        // 遍历栈并打印元素  
        System.out.println("栈的元素 (自顶向下):");  
        for (String element : stack) {  
            System.out.println(element);  
        }  
  
        // 弹出栈顶元素  
        String poppedElement = stack.pop();  
        System.out.println("弹出的栈顶元素: " + poppedElement);  
  
        // 再次查看栈顶元素  
        topElement = stack.peek();  
        System.out.println("执行pop操作后的栈顶元素: " + topElement);  
  
        // 检查栈是否为空  
        boolean empty = stack.isEmpty();  
        System.out.println("栈是否为空: " + empty);  
  
        // 清空栈  
        stack.clear();  
        System.out.println("清空栈后的大小: " + stack.size());  
    }  
}

返回目录

• Set

1.HashSet：

HashSet是一种基于哈希表实现的无序集合，它不能包含重复元素，并且不保证元素的顺序。HashSet提供了快速的查找和插入操作，适用于需要高效查找和去重的场景。

HashSet 的简单演示使用：

import java.util.HashSet;  
  
public class HashSetExample {  
    public static void main(String[] args) {  
        // 创建HashSet  
        HashSet<String> set = new HashSet<>();  
  
        // 添加元素  
        set.add("元素1");  
        set.add("元素2");  
        set.add("元素3");  
  
        // 检查HashSet中是否包含某个元素  
        boolean containsElement = set.contains("元素1");  
        System.out.println("HashSet中是否包含元素1？" + containsElement);  
  
        // 遍历HashSet中的元素  
        for (String element : set) {  
            System.out.println(element);  
        }  
  
        // 删除HashSet中的元素  
        set.remove("元素2");  
    }  
}

返回目录

2.TreeSet：

TreeSet是一种基于红黑树实现的有序集合，它按照元素的自然顺序或自定义比较器进行排序。TreeSet提供了高效的插入、删除和查找操作，并保持元素的有序性。

TreeSet 的简单演示使用：

import java.util.TreeSet;  
  
public class TreeSetExample {  
    public static void main(String[] args) {  
        // 创建TreeSet  
        TreeSet<String> set = new TreeSet<>();  
  
        // 添加元素  
        set.add("元素1");  
        set.add("元素2");  
        set.add("元素3");  
  
        // 检查TreeSet中是否包含某个元素  
        boolean containsElement = set.contains("元素1");  
        System.out.println("TreeSet中是否包含元素1？" + containsElement);  
  
        // 遍历TreeSet中的元素  
        for (String element : set) {  
            System.out.println(element);  
        }  
  
        // 删除TreeSet中的元素  
        set.remove("元素2");  
    }  
}

返回目录

• Queue

Queue：

Queue是一种先进先出（FIFO）的数据结构，Java提供了Queue接口和其实现类，如LinkedList和PriorityQueue。队列适用于任务调度和异步处理等场景。

Queue 的简单演示使用：

import java.util.LinkedList;  
import java.util.Queue;  
  
public class QueueExample {  
    public static void main(String[] args) {  
        // 创建一个队列  
        Queue<String> queue = new LinkedList<>();  
  
        // 向队列中添加元素  
        queue.offer("元素1");  
        queue.offer("元素2");  
        queue.offer("元素3");  
  
        // 获取队头元素并输出  
        String head = queue.peek();  
        System.out.println("队头元素为：" + head);  
  
        // 遍历队列中的元素  
        System.out.println("队列中的元素：");  
        for (String element : queue) {  
            System.out.println(element);  
        }  
  
        // 删除队头元素  
        String removedElement = queue.poll();  
        System.out.println("被删除的队头元素为：" + removedElement);  
  
        // 再次遍历队列中的元素  
        System.out.println("删除队头元素后的队列中的元素：");  
        for (String element : queue) {  
            System.out.println(element);  
        }  
    }  
}

返回目录

2、Map

1.HashMap：

HashMap是一种基于哈希表实现的键值对映射，它提供了快速的插入、删除和查找操作。HashMap允许key和value为空，但不保证元素的顺序。

HashMap 的简单演示使用：

import java.util.HashMap;  
import java.util.Map;  
  
public class HashMapExample {  
    public static void main(String[] args) {  
        // 创建一个HashMap  
        Map<String, Integer> map = new HashMap<>();  
  
        // 添加键值对到HashMap中  
        map.put("键1", 1);  
        map.put("键2", 2);  
        map.put("键3", 3);  
  
        // 获取指定键对应的值并输出  
        int value1 = map.get("键1");  
        System.out.println("键1对应的值为：" + value1);  
  
        // 遍历HashMap中的键值对  
        System.out.println("HashMap中的键值对：");  
        for (Map.Entry<String, Integer> entry : map.entrySet()) {  
            String key = entry.getKey();  
            int value = entry.getValue();  
            System.out.println(key + " -> " + value);  
        }  
  
        // 删除指定键的键值对  
        map.remove("键2");  
  
        // 再次遍历HashMap中的键值对  
        System.out.println("删除键2后的HashMap中的键值对：");  
        for (Map.Entry<String, Integer> entry : map.entrySet()) {  
            String key = entry.getKey();  
            int value = entry.getValue();  
            System.out.println(key + " -> " + value);  
        }  
    }  
}

返回目录

2.TreeMap：

TreeMap是一种基于红黑树实现的有序键值对映射，它按照键的自然顺序或自定义比较器进行排序。TreeMap提供了高效的插入、删除和查找操作，并保持键的有序性。

TreeMap 的简单演示使用：

import java.util.Map;  
import java.util.TreeMap;  
  
public class TreeMapExample {  
    public static void main(String[] args) {  
        // 创建一个TreeMap  
        TreeMap<String, Integer> treeMap = new TreeMap<>();  
  
        // 向TreeMap中添加键值对  
        treeMap.put("键1", 1);  
        treeMap.put("键3", 3);  
        treeMap.put("键2", 2);  
  
        // 获取指定键对应的值并输出  
        int value1 = treeMap.get("键1");  
        System.out.println("键1对应的值为：" + value1);  
  
        // 遍历TreeMap中的键值对  
        System.out.println("TreeMap中的键值对：");  
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {  
            String key = entry.getKey();  
            int value = entry.getValue();  
            System.out.println(key + " -> " + value);  
        }  
  
        // 删除指定键的键值对  
        treeMap.remove("键2");  
  
        // 再次遍历TreeMap中的键值对  
        System.out.println("删除键2后的TreeMap中的键值对：");  
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {  
            String key = entry.getKey();  
            int value = entry.getValue();  
            System.out.println(key + " -> " + value);  
        }  
  
        // 获取TreeMap中的第一个键和最后一个键  
        String firstKey = treeMap.firstKey();  
        String lastKey = treeMap.lastKey();  
  
        System.out.println("TreeMap中的第一个键：" + firstKey);  
        System.out.println("TreeMap中的最后一个键：" + lastKey);  
    }  
}

三、参考

如果想进一步深入探索Java容器请参阅Java官方文档)

返回顶部