Which Java Container is Useful for Competitive Programming?

2025年5月2日 | 阅读 15 分钟

在竞争性编程中，使用高效可靠的库确实能极大地提高生产力和性能。在本教程中，我们将重点介绍 Collection Framework 中最重要的容器。

Java 标准库包含以下数据结构

1. ArrayList

ArrayList 是 Java 集合框架的一部分，属于 java.util 包。ArrayList 提供了一种使用可调整大小的数组的方式，这对于大小的动态更改非常有用，因此 ArrayList 在许多编程场景中都可能受到青睐，包括竞争性编程，因为其中经常使用动态数组操作。它提供直接访问，并且在列表大小不固定时可能适用。

关键特性

索引访问：元素可以通过整数索引进行访问，提供快速的随机访问（O(1) 时间复杂度）。
维护插入顺序：元素按照插入的顺序存储。
非同步：默认情况下不是线程安全的。对于多线程环境，可以使用 Collections.synchronizedList(new ArrayList<>())。

文件名：ArrayListExample.java

import java.util.ArrayList;
import java.util.Collections;
public class ArrayListExample {
    public static void main(String[] args) {
        // Create an ArrayList to store integers
        ArrayList<Integer> list = new ArrayList<>();
        // Add elements to the ArrayList
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        System.out.println("Initial list: " + list);
        // Access elements from the ArrayList
        int firstElement = list.get(0);
        System.out.println("First element: " + firstElement);
        // Modify an element in the ArrayList
        list.set(2, 25);
        System.out.println("List after modification: " + list);
        // Remove an element from the ArrayList by index
        list.remove(1); // Removes the element at index 1 (the second element)
        System.out.println("List after removing element at index 1: " + list);
        // Remove an element from the ArrayList by value
        list.remove(Integer.valueOf(40)); // Removes the first occurrence of the element 40
        System.out.println("List after removing element with value 40: " + list);
        // Check if the ArrayList contains a specific element
        boolean contains30 = list.contains(30);
        System.out.println("List contains 30: " + contains30);
        // Get the size of the ArrayList
        int size = list.size();
        System.out.println("Size of the list: " + size);
        // Iterate over the elements in the ArrayList using a for-each loop
        System.out.print("Elements in the list: ");
        for (int element : list) {
            System.out.print(element + " ");
        }
        System.out.println();
        // Iterate using a traditional for loop with indices
        System.out.print("Elements in the list (using indices): ");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        // Sort the ArrayList
        list.add(5);
        list.add(35);
        Collections.sort(list);
        System.out.println("Sorted list: " + list);
        // Clear all elements from the ArrayList
        list.clear();
        System.out.println("List after clearing all elements: " + list);
    }
}   

输出

 
Initial list: [10, 20, 30, 40]
First element: 10
List after modification: [10, 20, 25, 40]
List after removing element at index 1: [10, 25, 40]
List after removing element with value 40: [10, 25]
List contains 30: false
Size of the list: 2
Elements in the list: 10 25 
Elements in the list (using indices): 10 25 
Sorted list: [5, 10, 25, 35]
List after clearing all elements: []

2. LinkedList

LinkedList 是 Java 集合框架的一部分，位于 java.util 包中。它提供了双向链表数据结构的实现。LinkedList 中的每个元素都存储在一个节点中，该节点包含指向下一个节点和上一个节点的引用，这使得在列表的两端以及特定位置进行高效的插入和删除成为可能。

关键特性

双向链表：每个节点都包含指向下一个和上一个节点的引用，支持双向遍历。
高效的插入/删除：如果已知位置，插入和删除是 O(1) 操作，不像数组需要移动元素。
索引访问：由于需要从头部或尾部进行遍历，按索引访问元素的时间复杂度为 O(n)。
维护插入顺序：元素按照插入的顺序存储。
非同步：默认情况下不是线程安全的。对于多线程环境，可以使用 Collections.synchronizedList(new LinkedList<>())。

文件名：LinkedListExample.java

import java.util.LinkedList;
public class LinkedListExample {
    public static void main(String[] args) {
        // Create a LinkedList to store strings
        LinkedList<String> linkedList = new LinkedList<>();
        // Add elements to the LinkedList
        linkedList.add("Apple");
        linkedList.add("Banana");
        linkedList.add("Orange");
        linkedList.add("Mango");
        // Print the initial list
        System.out.println("Initial list: " + linkedList);
        // Add elements at specific positions
        linkedList.addFirst("Grapes"); // Add at the beginning
        linkedList.addLast("Pineapple"); // Add at the end
        linkedList.add(2, "Strawberry"); // Add at index 2
        // Print the list after additions
        System.out.println("List after additions: " + linkedList);
        // Access elements by index
        String firstFruit = linkedList.getFirst();
        String lastFruit = linkedList.getLast();
        String fruitAtSecondPosition = linkedList.get(2);
        // Print the accessed elements
        System.out.println("First fruit: " + firstFruit);
        System.out.println("Last fruit: " + lastFruit);
        System.out.println("Fruit at index 2: " + fruitAtSecondPosition);
        // Modify an element
        linkedList.set(3, "Cherry"); // Replace "Mango" with "Cherry"
        // Print the list after modification
        System.out.println("List after modification: " + linkedList);
        // Remove elements by index
        linkedList.removeFirst(); // Remove the first element
        linkedList.removeLast(); // Remove the last element
        linkedList.remove(1); // Remove the element at index 1
        // Print the list after removals
        System.out.println("List after removals: " + linkedList);
        // Check for the presence of an element
        boolean containsBanana = linkedList.contains("Banana");
        System.out.println("List contains 'Banana': " + containsBanana);
        // Iterate over elements in the list
        System.out.print("Elements in the list: ");
        for (String fruit : linkedList) {
            System.out.print(fruit + " ");
        }
        System.out.println();
        // Clear all elements from the list
        linkedList.clear();
        System.out.println("List after clearing all elements: " + linkedList);
    }
}   

输出

 
Initial list: [Apple, Banana, Orange, Mango]
List after additions: [Grapes, Apple, Strawberry, Banana, Orange, Mango, Pineapple]
First fruit: Grapes
Last fruit: Pineapple
Fruit at index 2: Strawberry
List after modification: [Grapes, Apple, Strawberry, Cherry, Orange, Mango, Pineapple]
List after removals: [Apple, Cherry, Orange, Mango]
List contains 'Banana': false
Elements in the list: Apple Cherry Orange Mango 
List after clearing all elements: []

3. HashMap

HashMap 是 Java 集合框架的一部分，位于 java.util 包中。它提供了使用哈希表数据结构的 Map 接口的实现。HashMap 存储键值对，并允许基于其键快速检索值。它在添加、删除和检索元素等操作方面提供了高效的性能，因此是许多编程任务的流行选择。

关键特性

哈希表实现：HashMap 内部使用哈希表存储键值对。
快速访问：假设哈希函数和元素分布均匀，基本操作（add、remove、containsKey、get）的平均时间复杂度为 O(1)。
无序集合：与 LinkedHashMap 不同，HashMap 中的元素顺序不保证一致。
允许空值：HashMap 中的键和值都可以为 null。
非同步：默认情况下不是线程安全的。对于多线程环境，可以使用 Collections.synchronizedMap(new HashMap<>())。
初始容量和负载因子：HashMap 允许指定初始容量和负载因子来控制性能和内存使用。

文件名：HashMapExample.java

import java.util.HashMap;
import java.util.Map;
public class HashMapExample {
    public static void main(String[] args) {
        // Create a HashMap to store <String, Integer> key-value pairs
        HashMap<String, Integer> hashMap = new HashMap<>();
        // Add elements to the HashMap
        hashMap.put("John", 25);
        hashMap.put("Alice", 30);
        hashMap.put("Bob", 28);
        System.out.println("Initial HashMap: " + hashMap);
        // Add more elements to the HashMap
        hashMap.put("Emily", 35);
        hashMap.put("Dave", 40);
        // Print the HashMap after additions
        System.out.println("HashMap after additions: " + hashMap);
        // Retrieve the value associated with a key
        int ageOfJohn = hashMap.get("John");
        System.out.println("Age of John: " + ageOfJohn);
        // Modify an element
        hashMap.put("Alice", 32); // Update the value associated with key "Alice"
        System.out.println("HashMap after modification: " + hashMap);
        // Remove an element
        hashMap.remove("Bob");
        System.out.println("HashMap after removal: " + hashMap);
        // Check if the HashMap contains a specific key
        boolean containsAlice = hashMap.containsKey("Alice");
        System.out.println("HashMap contains 'Alice': " + containsAlice);
        // Check if the HashMap contains a specific value
        boolean containsAge40 = hashMap.containsValue(40);
        System.out.println("HashMap contains age 40: " + containsAge40);
        // Get the size of the HashMap
        int size = hashMap.size();
        System.out.println("Size of the HashMap: " + size);
        // Iterate over keys
        System.out.println("Iterating over keys:");
        for (String key : hashMap.keySet()) {
            System.out.println("Key: " + key);
        }
        // Iterate over values
        System.out.println("Iterating over values:");
        for (Integer value : hashMap.values()) {
            System.out.println("Value: " + value);
        }
        // Iterate over key-value pairs
        System.out.println("Iterating over key-value pairs:");
        for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
        // Clear all elements from the HashMap
        hashMap.clear();
        System.out.println("HashMap after clearing all elements: " + hashMap);
    }
}   

输出

 
Initial HashMap: {Bob=28, Alice=30, John=25}
HashMap after additions: {Emily=35, Bob=28, Alice=30, John=25, Dave=40}
Age of John: 25
HashMap after modification: {Emily=35, Bob=28, Alice=32, John=25, Dave=40}
HashMap after removal: {Emily=35, Alice=32, John=25, Dave=40}
HashMap contains 'Alice': true
HashMap contains age 40: true
Size of the HashMap: 4
Iterating over keys:
Key: Emily
Key: Alice
Key: John
Key: Dave
Iterating over values:
Value: 35
Value: 32
Value: 25
Value: 40
Iterating over key-value pairs:
Key: Emily, Value: 35
Key: Alice, Value: 32
Key: John, Value: 25
Key: Dave, Value: 40
HashMap after clearing all elements: {}

4. Queue

Java 中的 Queue 接口是 java.util 包的一部分，表示一个为在处理前保存元素而设计的集合。它遵循先进先出 (FIFO) 原则，其中元素添加到队列的末尾并从前端移除。该接口扩展了 Collection 接口，并提供了用于插入、移除和检查元素的各种方法。

关键特性

接口：Queue 是一个接口，因此它需要由 LinkedList、PriorityQueue 和 ArrayDeque 等具体类实现。
阻塞队列：对于线程安全操作，可以使用 ArrayBlockingQueue、LinkedBlockingQueue 和 PriorityBlockingQueue 等 BlockingQueue 实现。
非阻塞队列：LinkedList 和 PriorityQueue 等标准 Queue 实现不是线程安全的。

文件名：QueueExample.java

import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
    public static void main(String[] args) {
        // Create a Queue using LinkedList
        Queue<Integer> queue = new LinkedList<>();
        // Adding elements to the queue
        queue.add(10);
        queue.add(20);
        queue.add(30);
        queue.add(40);
        System.out.println("Initial Queue: " + queue);
        // Accessing the head of the queue
        int headElement = queue.peek(); // Retrieves but does not remove the head of the queue
        System.out.println("Head of the Queue: " + headElement);
        // Removing elements from the queue
        int removedElement = queue.remove(); // Retrieves and removes the head of the queue
        System.out.println("Removed Element: " + removedElement);
        System.out.println("Queue after removal: " + queue);
        // Adding another element to the queue
        queue.offer(50); // Adds an element to the end of the queue
        System.out.println("Queue after adding another element: " + queue);
        // Polling the queue (retrieves and removes the head)
        int polledElement = queue.poll();
        System.out.println("Polled Element: " + polledElement);
        System.out.println("Queue after polling: " + queue);
        // Checking if the queue contains a specific element
        boolean containsElement = queue.contains(20);
        System.out.println("Queue contains 20: " + containsElement);
        // Iterating over the elements in the queue
        System.out.println("Iterating over elements in the queue:");
        for (Integer element : queue) {
            System.out.println(element);
        }
        // Clearing the queue
        queue.clear();
        System.out.println("Queue after clearing: " + queue);
        // Checking if the queue is empty
        boolean isEmpty = queue.isEmpty();
        System.out.println("Is the queue empty: " + isEmpty);
    }
}   

输出

 
Initial Queue: [10, 20, 30, 40]
Head of the Queue: 10
Removed Element: 10
Queue after removal: [20, 30, 40]
Queue after adding another element: [20, 30, 40, 50]
Polled Element: 20
Queue after polling: [30, 40, 50]
Queue contains 20: false
Iterating over elements in the queue:
30
40
50
Queue after clearing: []
Is the queue empty: true

5. Stack

Java 中的 Stack 类是 java.util 包的一部分，表示一个后进先出 (LIFO) 的对象栈。它扩展了 Vector 类，并提供了五个允许将向量视为堆栈的操作。提供了常见的 push 和 pop 操作，以及一个用于查看堆栈顶部项的方法、一个用于测试堆栈是否为空的方法，以及一个用于搜索堆栈中的项并发现其距离顶部的距离的方法。

关键特性

扩展 Vector：Stack 继承了 Vector 的同步方法，这使其成为线程安全的。
类型安全：泛型实现允许类型安全的堆栈。
实用工具：提供标准的堆栈操作，如 push、pop、peek、empty 和 search。

文件名：StackExample.java

import java.util.Stack;
public class StackExample {
    public static void main(String[] args) {
        // Create a Stack
        Stack<Integer> stack = new Stack<>();
        // Pushing elements onto the stack
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.push(40);
        System.out.println("Initial Stack: " + stack);
        // Peeking at the top element
        int topElement = stack.peek();
        System.out.println("Top Element: " + topElement);
        // Popping elements from the stack
        int poppedElement = stack.pop();
        System.out.println("Popped Element: " + poppedElement);
        System.out.println("Stack after pop: " + stack);
        // Checking if the stack is empty
        boolean isEmpty = stack.empty();
        System.out.println("Is the stack empty: " + isEmpty);
        // Searching for an element in the stack
        int position = stack.search(20);
        System.out.println("Position of 20 in the stack: " + position);
        // Iterating over the elements in the stack
        System.out.println("Iterating over elements in the stack:");
        for (Integer element : stack) {
            System.out.println(element);
        }
        // Clearing the stack
        while (!stack.empty()) {
            stack.pop();
        }
        System.out.println("Stack after clearing: " + stack);
    }
}   

输出

 
Initial Stack: [10, 20, 30, 40]
Top Element: 40
Popped Element: 40
Stack after pop: [10, 20, 30]
Is the stack empty: false
Position of 20 in the stack: 2
Iterating over elements in the stack:
10
20
30
Stack after clearing: []

6. Deque

Java 中的 Deque 接口是 java.util 包的一部分，代表“双端队列”。它是一个线性集合，支持在两端插入和删除元素，使其比标准队列更灵活。Deque 可以兼作 FIFO（先进先出）队列和 LIFO（后进先出）堆栈。

关键特性

多功能性：可用作队列 (FIFO) 或堆栈 (LIFO)。
接口：Deque 是一个接口，实现包括 ArrayDeque 和 LinkedList。
容量限制：某些实现可能具有容量限制（例如，ArrayDeque），而其他实现（如 LinkedList）则没有。
空元素：大多数实现不允许空元素。

文件名：DequeExample.java

import java.util.ArrayDeque;
import java.util.Deque;
public class DequeExample {
    public static void main(String[] args) {
        // Create a Deque using ArrayDeque
        Deque<Integer> deque = new ArrayDeque<>();
        // Adding elements to the deque
        deque.addFirst(10);  // Adds 10 to the front
        deque.addLast(20);   // Adds 20 to the back
        deque.offerFirst(5); // Adds 5 to the front
        deque.offerLast(25); // Adds 25 to the back
        System.out.println("Initial Deque: " + deque);
        // Accessing elements from the deque
        int firstElement = deque.getFirst(); // Retrieves but does not remove the first element
        int lastElement = deque.getLast();   // Retrieves but does not remove the last element
        System.out.println("First Element: " + firstElement);
        System.out.println("Last Element: " + lastElement);
        // Removing elements from the deque
        int removedFirst = deque.removeFirst(); // Removes and returns the first element
        int removedLast = deque.removeLast();   // Removes and returns the last element
        System.out.println("Removed First Element: " + removedFirst);
        System.out.println("Removed Last Element: " + removedLast);
        System.out.println("Deque after removals: " + deque);
        // Pushing and popping elements (stack operations)
        deque.push(30); // Pushes 30 onto the front
        System.out.println("Deque after push: " + deque);
        int poppedElement = deque.pop(); // Pops the front element
        System.out.println("Popped Element: " + poppedElement);
        System.out.println("Deque after pop: " + deque);
        // Peeking elements
        int peekFirst = deque.peekFirst(); // Retrieves but does not remove the first element
        int peekLast = deque.peekLast();   // Retrieves but does not remove the last element
        System.out.println("Peek First Element: " + peekFirst);
        System.out.println("Peek Last Element: " + peekLast);
        // Checking size and emptiness
        int size = deque.size();          // Returns the number of elements in the deque
        boolean isEmpty = deque.isEmpty(); // Checks if the deque is empty
        System.out.println("Size of Deque: " + size);
        System.out.println("Is Deque Empty: " + isEmpty);
        // Iterating over the elements in the deque
        System.out.println("Iterating over elements in the deque:");
        for (Integer element : deque) {
            System.out.println(element);
        }
        // Clearing the deque
        deque.clear(); // Removes all elements from the deque
        System.out.println("Deque after clearing: " + deque);
    }
}   

输出

 
Initial Deque: [5, 10, 20, 25]
First Element: 5
Last Element: 25
Removed First Element: 5
Removed Last Element: 25
Deque after removals: [10, 20]
Deque after push: [30, 10, 20]
Popped Element: 30
Deque after pop: [10, 20]
Peek First Element: 10
Peek Last Element: 20
Size of Deque: 2
Is Deque Empty: false
Iterating over elements in the deque:
10
20
Deque after clearing: []

7. HashSet

HashSet 是 Java 集合框架的一部分，并实现了 Set 接口。它使用哈希表进行存储，假设哈希函数能正确地将元素分散到存储桶中，从而为 add、remove、contains 和 size 等基本操作提供恒定的时间性能。

关键特性

无重复：HashSet 不允许重复元素。如果尝试添加重复元素，add 方法将返回 false。
顺序：HashSet 不保证任何特定的元素顺序。元素是根据它们的哈希码存储的，并且迭代顺序可能会随时间而改变。
空元素：HashSet 允许一个空元素。
非同步：HashSet 不是同步的。如果多个线程并发访问一个哈希集，并且至少有一个线程修改了该集，则必须在外部进行同步。

文件名：HashSetExample.java

import java.util.HashSet;
import java.util.Iterator;
public class HashSetExample {
    public static void main(String[] args) {
        // Create a HashSet
        HashSet<String> set = new HashSet<>();
        // Adding elements to the HashSet
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Date");
        System.out.println("Initial HashSet: " + set);
        // Adding a duplicate element (will not be added)
        boolean isAdded = set.add("Apple");
        System.out.println("Is 'Apple' added again: " + isAdded);
        System.out.println("HashSet after adding duplicate: " + set);
        // Checking if an element exists
        boolean containsBanana = set.contains("Banana");
        System.out.println("Contains 'Banana': " + containsBanana);
        // Removing an element
        boolean isRemoved = set.remove("Date");
        System.out.println("Is 'Date' removed: " + isRemoved);
        System.out.println("HashSet after removal: " + set);
        // Iterating over the elements in the HashSet
        System.out.println("Iterating over elements in the HashSet using for-each loop:");
        for (String fruit : set) {
            System.out.println(fruit);
        }
        // Iterating over the elements in the HashSet using iterator
        System.out.println("Iterating over elements in the HashSet using iterator:");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        // Checking the size of the HashSet
        int size = set.size();
        System.out.println("Size of HashSet: " + size);
        // Checking if the HashSet is empty
        boolean isEmpty = set.isEmpty();
        System.out.println("Is HashSet empty: " + isEmpty);
        // Clearing the HashSet
        set.clear();
        System.out.println("HashSet after clearing: " + set);
    }
}   

输出

 
Initial HashSet: [Apple, Cherry, Date, Banana]
Is 'Apple' added again: false
HashSet after adding duplicate: [Apple, Cherry, Date, Banana]
Contains 'Banana': true
Is 'Date' removed: true
HashSet after removal: [Apple, Cherry, Banana]
Iterating over elements in the HashSet using for-each loop:
Apple
Cherry
Banana
Iterating over elements in the HashSet using iterator:
Apple
Cherry
Banana
Size of HashSet: 3
Is HashSet empty: false
HashSet after clearing: []

8. TreeMap

TreeMap 是 Java 集合框架的一部分，并实现了 NavigableMap 接口。它是一种基于红黑树的实现，可确保映射按照其键的自然顺序或按指定的比较器以排序顺序排列。当您需要一个维护顺序的映射时，TreeMap 非常有用。

关键特性

排序顺序：TreeMap 按键的升序维护其元素。
NavigableMap 功能：它提供了通过映射进行导航的方法（例如，firstEntry()、lastEntry()、ceilingEntry()、floorEntry() 等）。
性能：由于底层的红黑树结构，基本操作（get、put、remove）的时间复杂度为 O(log n)。

文件名：TreeMapExample.java

import java.util.TreeMap;
import java.util.Map;
public class TreeMapExample {
    public static void main(String[] args) {
        // Create a TreeMap
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        // Adding elements to the TreeMap
        treeMap.put(3, "Three");
        treeMap.put(1, "One");
        treeMap.put(2, "Two");
        treeMap.put(5, "Five");
        treeMap.put(4, "Four");
        System.out.println("Initial TreeMap: " + treeMap);
        // Accessing an element
        String value = treeMap.get(3);
        System.out.println("Value for key 3: " + value);
        // Removing an element
        treeMap.remove(2);
        System.out.println("TreeMap after removing key 2: " + treeMap);
        // Checking if a key exists
        boolean containsKey = treeMap.containsKey(1);
        System.out.println("TreeMap contains key 1: " + containsKey);
        // Checking if a value exists
        boolean containsValue = treeMap.containsValue("Five");
        System.out.println("TreeMap contains value 'Five': " + containsValue);
        // Getting the first and last keys
        Integer firstKey = treeMap.firstKey();
        Integer lastKey = treeMap.lastKey();
        System.out.println("First key: " + firstKey);
        System.out.println("Last key: " + lastKey);
        // Navigating the map
        Integer ceilingKey = treeMap.ceilingKey(3);
        Integer floorKey = treeMap.floorKey(3);
        System.out.println("Ceiling key for 3: " + ceilingKey);
        System.out.println("Floor key for 3: " + floorKey);
        // Iterating over the elements in the TreeMap
        System.out.println("Iterating over elements in the TreeMap:");
        for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
            System.out.println(entry.getKey() + " => " + entry.getValue());
        }
        // Checking the size of the TreeMap
        int size = treeMap.size();
        System.out.println("Size of TreeMap: " + size);
        // Checking if the TreeMap is empty
        boolean isEmpty = treeMap.isEmpty();
        System.out.println("Is TreeMap empty: " + isEmpty);
        // Clearing the TreeMap
        treeMap.clear();
        System.out.println("TreeMap after clearing: " + treeMap);
    }
}   

输出

 
Initial TreeMap: {1=One, 2=Two, 3=Three, 4=Four, 5=Five}
Value for key 3: Three
TreeMap after removing key 2: {1=One, 3=Three, 4=Four, 5=Five}
TreeMap contains key 1: true
TreeMap contains value 'Five': true
First key: 1
Last key: 5
Ceiling key for 3: 3
Floor key for 3: 3
Iterating over elements in the TreeMap:
1 => One
3 => Three
4 => Four
5 => Five
Size of TreeMap: 4
Is TreeMap empty: false
TreeMap after clearing: {}

下一个主题Prim's 算法 Java

Which Java Container is Useful for Competitive Programming?

Java 标准库包含以下数据结构

1. ArrayList

关键特性

2. LinkedList

关键特性

3. HashMap

关键特性

4. Queue

关键特性

5. Stack

关键特性

6. Deque

关键特性

7. HashSet

关键特性

8. TreeMap

关键特性

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Which Java Container is Useful for Competitive Programming?

Java 标准库包含以下数据结构

1. ArrayList

关键特性

2. LinkedList

关键特性

3. HashMap

关键特性

4. Queue

关键特性

5. Stack

关键特性

6. Deque

关键特性

7. HashSet

关键特性

8. TreeMap

关键特性

相关帖子

Java Graph

Java 中的无法访问代码错误

Java 中的序数

Java 中的一维数组

Java Frameworks

Java 中的普遍肤浅

Eclipse 主题更改

Java Decompiler

Print Adjacency List for a Directed Graph in Java

Java 中交换首尾单词并反转中间字符

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器