平常经常面临各种数据集合的选取，下面整理一下常用的Java的数据集合用法

队列

Deque

双端队列（Double Ended Queue）

常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Deque;
import java.util.LinkedList;

public class QueueTst {
    public static void main(String[] args) {
        Deque<String> deque = new LinkedList<>();
        // add-remove; offer-poll
        String a = "A";
        deque.offerLast(a); // A
        deque.offerLast("B"); // A <- B
        deque.offerFirst("C"); // C <- A <- B
        System.out.println(deque.size()); // 3
        System.out.println(deque.getFirst()); // C
        System.out.println(deque.getLast()); // B, 还是C <- A <- B
        System.out.println(deque.pollFirst()); // C, 剩下A <- B
        System.out.println(deque.pollLast()); // B, 剩下A
        System.out.println(deque.contains(a)); // true
        System.out.println(deque.pollFirst()); // A
        System.out.println(deque.pollFirst()); // null
        System.out.println(deque.isEmpty()); // true
    }
}

Queue

单端队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.LinkedList;
import java.util.Queue;

public class Queuetst {
    public static void main(String[] args) {
      Queue<String> q = new LinkedList<>();
      // 添加3个元素到队列:
      q.offer("apple");
      q.offer("pear");
      q.offer("banana"); // banana<-pear<-apple
      // 从队列取出元素:
      System.out.println(q.peek()); // apple
      System.out.println(q.poll()); // apple
      System.out.println(q.poll()); // pear
      System.out.println(q.poll()); // banana
      System.out.println(q.poll()); // null,因为队列是空的
    }
}

Priority Queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.PriorityQueue;
import java.util.Queue;
public class PriorityQueueTst {
  public static void main(String[] args) {
    Queue<String> q = new PriorityQueue<>();
    // 添加3个元素到队列:
    q.offer("apple");
    q.offer("pear");
    q.offer("grape");
    q.offer("strawberry");
    q.offer("banana");
    System.out.println(q.poll()); // apple
    System.out.println(q.poll()); // banana,因为b在p的前面
    System.out.println(q.poll()); // grape
    System.out.println(q.poll()); // pear
    System.out.println(q.poll()); // strawberry
    System.out.println(q.poll()); // null,因为队列为空
  }
}

栈

一般用Deque实现栈的结构

不使用遗留类Stack

  • 只使用pop，push，peek等方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.*;

public class StackTst {

  public static void main(String[] args) {
    Deque<String> deque = new LinkedList<>();
    String a = "A";
    deque.push(a); // A
    deque.push("B"); // A <- B
    deque.push("C"); // C <- A <- B
    System.out.println(deque.size()); // 3
    System.out.println(deque.pop()); // C
    System.out.println(deque.pop()); // B
    System.out.println(deque.peek()); // A
    System.out.println(deque.pop()); // A
  }

}

哈希

HashSet

  • 相当于只存储key不存储value的Map
  • HashSet仅仅是对于HashMap的一个简单封装
1
2
3
4
5
6
7
8
Set<String> set = new HashSet<>();
System.out.println(set.add("abc")); // true
System.out.println(set.add("xyz")); // true
System.out.println(set.add("xyz")); // false，添加失败，因为元素已存在
System.out.println(set.contains("xyz")); // true，元素存在
System.out.println(set.contains("XYZ")); // false，元素不存在
System.out.println(set.remove("hello")); // false，删除失败，因为元素不存在
System.out.println(set.size()); // 2，一共两个元素

TreeSet

  • 实现了SortedSet接口，保证了元素是有序的
  • 加入的元素必须实现了Comparable接口，如果没有是心啊，那么必须传入一个Comparator对象，override 对应的Compare方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Set<String> set = new TreeSet<>();
set.add("apple");
set.add("banana");
set.add("pear");
set.add("orange");
for (String s : set) {
    System.out.println(s);
}

Set<int[]> set = new TreeSet<>(new Comparator(){
	@Override
    public int compare(int[] nums1, int[] nums2){
        // 按照元素1升序，按照元素2降序
    	if(nums1[0]==nums1[0]){
        	return nums1[1]-nums2[1]; 
        }
        return nums1[0] - nums2[0];
    }
})

堆

底层实现：
https://blog.csdn.net/u013309870/article/details/71189189

最大堆

1
2
3
4
5
6
7
8
9
10
11
PriorityQueue<Integer> pq =new PriorityQueue<>((a, b) -> b - a);
// 或者

PriorityQueue <Integer> maxHeap = new PriorityQueue<Integer>(new Comparator<Integer>() {

    @Override
    public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);
    }

});

最小堆

1
PriorityQueue<Integer> pq =new PriorityQueue<>();

链表

插入和删除更方便

1
List<Integer> list = new LinkedList();

数组

查找更方便

1
List<Integer> list = new ArrayList();