Java常用数据结构（类似于C++STL）

1. ArrayList

底层使用数组实现

ArrayList对于随机访问和更新操作（如get和set）具有较好的性能，时间复杂度为O(1)。但是在插入和删除元素时，需要移动元素的位置，因此性能较差，时间复杂度为O(n)。

相关简单操作：

List<Integer> list = new ArrayLIst<>();

add（）添加元素

get（i）获取到i下标位置的元素

1. sort

1 . 单纯的从小到大排序

Collections.sort(a);

2 . 固定区间进行排序 前开后闭

Collections.sort(a, 0, 3);

3 . 自定义排序方式

Collections.sort(arr, new Comparator<Integer>() {
                //重写compare方法，最好加注解，不加也没事
            public int compare(Integer a, Integer b) {
                //返回值>0交换
                return b-a;
            }
        });
Collections.sort(arr, (a, b) -> {
            //返回值>0交换
            return b-a;
        });
public class Main {
    public static void main(String[] args){
        Integer[] arr = {5,4,7,9,2,12,54,21,1};
        //降序
        //重新实现Comparator接口
        Arrays.sort(arr, new compa());
        System.out.println(Arrays.toString(arr));
    }
}
​
class compa implements Comparator<Integer>{
​
    @Override
    public int compare(Integer o1, Integer o2) {
        // A.compareTo(B) A>B 返回1，A=B 返回0，A<B 返回-1
        // compareTo()返回值>0就交换
        // 如果02 > o1 就交换 =>降序
        return o2.compareTo(o1);
    }
}

2.LinkedList

底层使用双向链表实现

在Java中，LinkedList实现了Deque接口，因此提供了一系列Deque接口中定义的方法

类似于双端队列

LinkedList对于插入和删除操作具有较好的性能，因为只需要改变链表中相邻节点的指针即可，时间复杂度为O(1)。但是对于随机访问和更新操作，性能较差，需要遍历链表，时间复杂度为O(n)。

相较于ArrayList的操作方法以外其余的特殊操作方法：

ArrayDeque

ArrayDeque是基于数组实现的双端队列，它不是线程安全的。ArrayDeque没有容量限制，可以根据需要动态地增长和收缩。在大多数情况下，ArrayDeque比LinkedList具有更快的性能，因为它是基于数组的，因此具有更好的局部性和更低的内存消耗。但是，ArrayDeque不支持容量限制，因此在需要限制容量的情况下，可能需要自行实现扩容策略。

ConcurrentLinkedDeque

ConcurrentLinkedDeque是Java并发包（java.util.concurrent）中提供的线程安全的双端队列实现类。它使用无锁算法实现，并发性能很高。ConcurrentLinkedDeque适用于多线程环境下需要高并发访问的场景。需要注意的是，ConcurrentLinkedDeque并不是阻塞队列，它不会阻塞线程，而是通过CAS操作实现并发控制。

3. Map

HashMap

普通用法

map.put("England", "London");
map.get("England");
map.remove("England");
map.clear();
map.size();
// Print keys
for (String i : capitalCities.keySet()) {
  System.out.println(i);
}
// Print values
for (String i : capitalCities.values()) {
  System.out.println(i);
}

进阶用法

// 元素添加 不需要判断元素是否已经存在 下面这个演示常用于元素个数计数
map.put(key,map.getOrDefault(key,0) + 1);
// 替换所有的value值
map.replaceAll((key, value) -> value * 2);

TreeMap

reeMap是Java中的一个基于红黑树实现的有序映射表，它实现了SortedMap接口，因此具有根据键的自然顺序或自定义顺序进行排序的功能。下面是对TreeMap的详细介绍：

特点： 有序性：TreeMap中的键值对根据键的自然顺序或自定义顺序进行排序。如果使用自然顺序，则键必须实现Comparable接口；如果使用自定义顺序，则在创建TreeMap时可以传入Comparator对象。 基于红黑树：TreeMap的底层数据结构是一棵红黑树，这使得TreeMap具有较高的查找、插入和删除性能，时间复杂度为O(log n)。 不允许null键：TreeMap不允许使用null作为键，但可以使用null作为值。 不是线程安全的：TreeMap不是线程安全的，如果需要在多线程环境中使用，需要进行适当的同步措施。

TreeMap<Integer, String> treeMap = new TreeMap<>();
// 或者
TreeMap<Integer, String> customTreeMap = new TreeMap<>(Comparator.reverseOrder());
​
// 可以使用以下方式进行遍历，也可以像HashMap一样进行key，value遍历
for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

​

4 .Set

HashSet

LinkedHashSet

TreeSet

EnumSet

通用操作

set.add("Apple");
set.remove("Banana");
boolean containsApple = set.contains("Apple");
int size = set.size();
set.clear();
​
for (String fruit : set) {
    System.out.println(fruit);
}
​
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    String fruit = iterator.next();
    System.out.println(fruit);
}
​
boolean isEmpty = set.isEmpty();
​
// 转换为Object类型的数组
Object[] array = set.toArray();
​
// 转换为指定类型的数组
String[] stringArray = set.toArray(new String[set.size()]);

​

5. Stack

Stack（栈）是Java中的一种经典数据结构，它遵循先进后出（LIFO，Last-In-First-Out）的原则，即最后压入栈的元素最先被弹出。在Java中，Stack类继承自Vector类，因此它是线程安全的，并且允许在任意位置插入和删除元素。

stack.push(3);
​
// 获取栈顶元素并弹出
int top = stack.pop(); // top = 3
​
// 获取栈顶元素但不弹出
int peeked = stack.peek(); // peeked = 2
​
// 判断栈是否为空
boolean isEmpty = stack.empty(); // false
​
// 搜索指定元素在栈中的位置
int position = stack.search(2); // position = 2

6 .Queue

LinkedList 同样适用于Queue

ArrayDeque

PriorityQueue

add(E e) 或 offer(E e)：向队列中添加元素。
remove() 或 poll()：移除并返回队列中优先级最高的元素。
peek()：返回队列中优先级最高的元素，但不移除。
size()：返回队列中元素的个数。
isEmpty()：判断队列是否为空。
clear()：清空队列中的所有元素。
​
// 创建堆 默认是小根堆
// 创建大根堆
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());