java刷题中常用的集合和相关函数

HashSet和HashMap

HashMap：

class Solution {
    public boolean uniqueOccurrences(int[] arr) {
        Map<Integer, Integer> occur = new HashMap<Integer, Integer>();
        for (int x : arr) {
            occur.put(x, occur.getOrDefault(x, 0) + 1);
        }
        Set<Integer> times = new HashSet<Integer>();
        for (Map.Entry<Integer, Integer> x : occur.entrySet()) {
            times.add(x.getValue());
        }
        return times.size() == occur.size();
    }
}

1.Map的getOrDefault()方法 ，可以在没有这个key时返回默认值

default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
}           

2.Map最常见的遍历方法

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for(Map.Entry<Integer, Integer> entry : map.entrySet()){
	System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue())
}

3.获取key的集合

    // 检查字符集是否相同
    if (!map1.keySet().equals(map2.keySet())) {
        return false;
    }

HashSet：

class Solution {
    public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
        HashSet<Integer> set1 = new HashSet<>();
        HashSet<Integer> set2 = new HashSet<>();
        for (int n : nums2) {
            set2.add(n);
        }
        for (int n : nums1) {
            set1.add(n);
        }
        for (int n : nums2) {
            set1.remove(n);
        }
        for (int n : nums1) {
            set2.remove(n);
        }

        return List.of(List.copyOf(set1), List.copyOf(set2));
    }
}

HashSet和HashMap区别：

1.HashMap中使用put()将元素加入map中，而HashSet使用add()将元素放入set中。

2.HashMap用于存储键值对，而HashSet用于存储对象。

3.HashMap不允许有重复的键，可以允许有重复的值。HashSet不允许有重复元素。

4.HashMap中使用put()，若该key已存入，会更新value。HashSet中使用add(),若有对象有相同key，会判断是不是相同对象，不同会继续存，相同会返回false不存、

栈Deque

1、java推荐使用deque替代stack

2、deque为双向队列，在一些工作中，需要封装成栈来保证安全

//底层是一个双向链表
Deque<Integer> deque = new LinkedList<>();

//注意这里不是ArrayList，因为deque不能用arraylist实现
//!!!
Deque<Integer> deque1 = new ArrayDeque<>();



//栈用法
deque.push();
deque.pop();
deque.peek();查看最上面，栈为空返回null


//双端队列用法
void addFirst(E e)：在队列的头部插入元素。
void addLast(E e)：在队列的尾部插入元素。
boolean offerFirst(E e)：尝试在队列头部插入元素，如果成功返回true，否则返回false。
boolean offerLast(E e)：尝试在队列尾部插入元素，如果成功返回true，否则返回false。
E removeFirst()：移除并返回队列头部的元素，如果队列为空，则抛出异常。
E removeLast()：移除并返回队列尾部的元素，如果队列为空，则抛出异常。
E pollFirst()：移除并返回队列头部的元素，如果队列为空，则返回null。
E pollLast()：移除并返回队列尾部的元素，如果队列为空，则返回null。
E getFirst()：返回队列头部的元素，但不移除，如果队列为空，则抛出异常。
E getLast()：返回队列尾部的元素，但不移除，如果队列为空，则抛出异常。
E peekFirst()：返回队列头部的元素，但不移除，如果队列为空，则返回null。
E peekLast()：返回队列尾部的元素，但不移除，如果队列为空，则返回null。

Queue队列

 

Queue<Integer> radiant = new LinkedList<Integer>();
int size()：获取队列长度；
boolean add(E)/boolean offer(E)：添加元素到队尾；
E remove()/E poll()：获取队首元素并从队列中删除；
E element()/E peek()：获取队首元素但并不从队列中删除。

PriorityQueue优先队列

//默认为小顶堆
Queue<Integer> heap = new PriorityQueue<>();
PriorityQueue<Integer> heap = new PriorityQueue<>();
//改为大顶堆
PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
//常用操作
add()
remove()
peek()