Java Common Class Library for Leetcode.

Declare

1
2
3
4
5
6
7
8
9
10
int[] list = new int[length];
ArrayList<Integer> tmp = new ArrayList<Integer>();
LinkedList<Integer> stack = new LinkedList<Integer>();

PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>(){
	public int compare(Integer num1, Integer num2){
		return num1.compareTo(num2);//小顶堆 队首元素最小
		return num2.compareTo(num1);//大顶堆 队首元素最大
	}
});

java.util.Queue

add(item)与offer(item)

两者都是在队列中添加一个元素 区别在于在一个满队列中执行

add()抛出一个unchecked异常 offer()会返回false可用作判断

poll()与remove()

两者都是从队列中删除第一个元素 区别在于在一个空队列中执行

poll()会返回null remove()与Collection接口的版本相似会抛出异常

element()与peek()

两者都是用于在队列的头部查询元素 区别在于在一个空队列中执行

element()抛出一个异常 peek()返回null

put(item)

添加一个元素 若队列满 阻塞

take()

移除并返回队列头部的元素

java.util.PriorityQueue

无限制队列可动态增长 默认情况下队列对象按自然顺序排序

优先队列头部是最小元素 轮询时从队列返回头对象

1
2
3
4
5
6
7
PriorityQueue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>(){
@Override
public int compare(Integer o1, Integer o2){
	return o1.compareTo(o2);//最小优先队列
    return o2.compareTo(o1);//最大优先队列
}
});

如果只是声明PriorityQueue<Integer> heap = new PriorityQueue<>(); 则构建了最大优先队列

若构建最大优先队列 则队首大 队尾小 反之反之

offer() 向队列中插入元素

add() 将指定的元素插入此优先级队列

peek() 获取队首元素(即最小元素)但是不删除

poll() 获取并删除队首元素(即最小元素)

java.util.Stack

push(item)与pop()

入栈和出栈 并作为函数的值返回该对象

add(item)

同样是入栈 但是返回布尔值

peek()

查看栈顶对象但不移除

search(object o)

返回对象在堆栈中距离栈顶的位置

java.util.LinkedList

add()

boolean add(E e)：在链表后添加一个元素，如果成功，返回true，否则返回false

void addFirst(E e)：在链表头部插入一个元素

void addLast(E e)：在链表尾部添加一个元素

void add(int index, E element)：在指定位置插入一个元素

remove()

E remove()；移除链表中第一个元素

boolean remove(Object o)：移除链表中指定的元素

E remove(int index)：移除链表中指定位置的元素

E removeFirst()：移除链表中第一个元素

E removeLast()：移除链表中最后一个元素

boolean removeFirstOccurrence(Object o)：移除链表中第一次出现所在位置的元素

boolean removeLastOccurrence(Object o)：移除链表中最后一次出现所在位置的元素

get()

E get(int index)：按照下标获取元素

E getFirst()：获取第一个元素

E getLast()：获取倒数第一个元素

other

void size()：获取长度

void push(E e)：与addFirst一样，实际上它就是addFirst

E pop()：与removeFirst一样，实际上它就是removeFirst

E poll()：查询并移除第一个元素

E peek()：获取第一个元素，但是不移除

E peekFirst()：获取第一个元素，但是不移除

E peekLast()：获取最后一个元素，但是不移除

boolean isEmpty()：判断是否为空

boolean offer(E e)：在链表尾部插入一个元素

boolean offerFirst(E e)：与addFirst一样，实际上它就是addFirst

boolean offerLast(E e)：与addLast一样，实际上它就是addLast

java.util.ArrayList

add()

boolean add(Element e) 增加指定元素到链表尾部

void add(int index, Element e) 增加指定元素到链表指定位置

remove()

void clear() 从链表中删除所有元素

E remove(int index) 删除链表中指定位置的元素

protected void removeRange(int start, int end) 删除链表中从某一个位置开始到某一个位置结束的元素

other

void size() 获取长度

E get(int index) 获取链表中指定位置处的元素

Object[] toArray() 获取一个数组，数组中所有元素是链表中的元素.（即将链表转换为一个数组）

E set(int index, E element) 将链表中指定位置上的元素替换成新元素

boolean contains(Object o) 如果链表包含指定元素，返回true

int indexOf(Object o) 返回元素在链表中第一次出现的位置，如果返回-1，表示链表中没有这个元素

int lastIndexOf(Object o) 返回元素在链表中最后一次出现的位置，如果返回-1，表示链表中没有这个元素

java.util.Map

add()

put(Object key, Object value) 该方法会将原先key所对应的键值对覆盖掉，即可以用该方法修改Map中的值

void putAll(Map m) 从指定映射中将所有映射关系复制到此映射中

remove()

Object remove(Object k) 如果存在一个键的映射关系，则将其从此映射中移除

get()

Object get(Object key) 获取给定key对应的值，否则返回null

other

int size( ) 返回此映射中的键-值映射关系数

boolean containsKey(Object Key) 如果此映射包含指定键的映射关系，则返回 true

boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true

boolean equals(Object obj) 比较指定的对象与此映射是否相等

boolean isEmpty( ) 如果此映射未包含键-值映射关系，则返回 true

java.util.HashMap

getOrDefault(Object key, V defaultValue) 获取指定 key 对应对 value，如果找不到 key ，则返回设置的default值

Concurrent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class Main {
    private static List<Object> list = new ArrayList<>();

    public static void main(String[] args) {
        Thread c1 = new Thread(Main::add);
        c1.setName("厨师1");
        Thread c2 = new Thread(Main::add);
        c2.setName("厨师2");

        c1.start();
        c2.start();

        Thread s1 = new Thread(Main::take);
        s1.setName("顾客1");
        Thread s2 = new Thread(Main::take);
        s2.setName("顾客2");
        Thread s3 = new Thread(Main::take);
        s3.setName("顾客3");

        s1.start();
        s2.start();
        s3.start();
    }
    private static void add(){
        while(true){
            try{
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (list){
                list.add(new Object());
                System.out.println(new Date()+Thread.currentThread().getName()+"添加了新菜！");
                list.notify();
            }
        }

    }

    private static void take() {
        while(true){
            try {
                synchronized (list) {
                    while (list.isEmpty()) list.wait();
                    System.out.println(new Date()+Thread.currentThread().getName()+"拿走了菜！");
                    list.remove(0);
                }
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}