1、Queue接口
Queue接口是Collection接口的子接口。
Queue接口表示一个队列，分为队头与队尾。通常实现先进 先出的原则（ FIFO），但这不是必须的。
例如，
PriorityQueue是根据优先级来进行排序的。队列会根据具体的实现来组织与管理新加入元素的位置。无论 哪种实现方式，删除（获取）元素时，会删除（获取）队 列头部的元素。
package day15;
import java.util.LinkedList;
import java.util.Queue;
/*
* Queue接口
* 接口中的方法可以分成两组：
* 一组：add remove element
* 二组：offer poll peek
* 第一组在操作失败时，会产生异常。
* 第二组在操作失败时，不会产生异常，而是返回特定的值。
* 优先考虑使用第二组方法。
*
* Queue接口关于null值。
* Queue接口中不允许加入null值。因为null值是作为poll与peek
* 在操作失败时的返回值。
* 对于LinkedList实现类，允许加入null值，这是一种特例，因为
* 要做到兼容以前的程序。（我们要尽可能回避这种特例）
*/
public class QueueMethod {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<>();
// 向队列中加入元素。如果加入失败，抛出异常。
q.add(1);
// 向队列中加入元素。如果加入失败，返回false。
// （不会产生异常。）
q.offer(1);
// 删除并返回队列头部的元素。如果删除失败，抛出异常。
// q.remove();
// 删除并返回队列头部的元素。如果删除失败，返回null。
// q.poll();
// 获取并返回队列头部的元素（不会删除该元素）。如果
// 获取失败，抛出异常。
// q.element();
// 获取并返回队列头部的元素（不会删除该元素）。如果
// 获取失败，返回null。
// q.peek();
// 一种特例。
q.add(null);
}
}
2、PriorityQueue实现类
Queue接口的一个特殊的实现类，不是按照先进先出的原则， 而是根据特定机制对元素进行排序处理。排序的规则可能是：
自然排序
指定排序
说明：
PriorityQueue实现类没有元素的限制。
PriorityQueue对内部元素的排序不会体现在集合的遍历上。
/*
* PriorityQueue优先级队列
*/
package day15;
import java.util.PriorityQueue;
import java.util.Queue;
/*
* PriorityQueue是Queue的一个特殊实现类，其不是按照
* 传统的先进先出的原则实现的，而是按照元素的优先级在内部
* 进行排序。注意：内部的元素排序不会表现在元素的遍历上。
*
* 对于无参的构造器，使用自然排序。
* 也可以传递一个比较器。
*/
public class PriorityQueueTest {
public static void main(String[] args) {
// Queue<Integer> q = new PriorityQueue<>();
Queue<Integer> q = new PriorityQueue<>((a, b) -> b - a);
// q.add(null);
q.offer(100);
q.offer(20);
q.offer(15);
q.offer(68);
// 在使用PriorityQueue对元素进行遍历时，
// 不保证任何遍历顺序（遍历顺序没有任何保证）。
// q.forEach(System.out::println);
while (q.size() > 0) {
System.out.println(q.poll());
}
}
}
3、Deque接口
Deque（ Double Ended Queue）接口是Queue接口的子接口。
Deque接口表示一个双端的队列，即可以从队列的两端增加 与删除（获取）元素。
Deque接口可以同时实现队列（ FIFO）与堆栈（ LIFO）的功 能。
Deque接口有两个常用的实现类：
ArrayDeque
LinkedList
package day15;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
public class DequeMethod {
public static void main(String[] args) {
// Deque<Integer> dq = new LinkedList<>();
Deque<Integer> dq = new ArrayDeque<>();
// 从队头加入元素。失败时会产生异常。
dq.addFirst(1);
// 从队尾加入元素。
dq.addLast(1);
// 从队头加入元素。失败时不会产生异常，而是返回false。
dq.offerFirst(1);
// 从队尾加入元素。
dq.offerLast(1);
// 删除并返回队列头部的元素。
dq.removeFirst();
// 删除并返回队列尾部的元素。
dq.removeLast();
// 删除并返回队列头部的元素。失败时不会产生异常，而是返回null。
dq.pollFirst();
// 删除并返回队列尾部的元素。失败时不会产生异常，而是返回null。
dq.pollLast();
// 获取队列头部的元素（不会删除该元素）。
dq.getFirst();
// 获取队列尾部的元素（不会删除该元素）。
dq.getLast();
// 获取队列头部的元素（不会删除该元素）。失败时不会产生
// 异常，而是返回null。
dq.peekFirst();
// 获取队列尾部的元素（不会删除该元素）。失败时不会产生
// 异常，而是返回null。
dq.peekLast();
// 删除队列中首次出现的元素（参数指定）。删除成功返回true，
// 否则返回false。
dq.removeFirstOccurrence(2);
// 删除队列中最后一次出现的元素（参数指定）。删除成功返回true，
// 否则返回false。
dq.removeLastOccurrence(1);
// 向队列头部加入元素。（作为堆栈使用）
dq.push(1);
// 删除队列头部的元素。（作为堆栈使用）
dq.pop();
}
}
4、Map接口
package day15;
import java.util.HashMap;
import java.util.Map;
public class MapTest {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>();
// 加入键值对，返回该键之前绑定的值。如果该键之前没有
// 绑定值，则返回null。
System.out.println(map.put(1, "abc"));
// map中的键值不能重复，如果加入了重复了键值，
// 则该键值会绑定后来的value。
System.out.println(map.put(1, "cdf"));
// 获取键(key)绑定的值(value)
System.out.println(map.get(1));
}
}
5、HashMap实现类
HashMap是Map最常使用的实现类。
遍历Map的方式： 使用keyset 使用entrySet 使用forEach
package day15;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapMethod {
public static void main(String[] args) {
Map<Integer, Integer> map = new HashMap<>();
map.put(1, 100);
map.put(2, 200);
// 返回map中键值对的数量。
// System.out.println(map.size());
// 判断map是否为空（键值对数量是否为0），
// 如果为空，返回true，否则返回false。
// System.out.println(map.isEmpty());
// 判断map中是否含有参数指定的key。含有返回true，
// 否则返回false。
// System.out.println(map.containsKey(1));
// 判断map中是否含有参数指定的value。含有返回true，
// 否则返回false。
// System.out.println(map.containsValue(200));
// 删除与参数指定键值相等的键值对。返回该键所绑定
// 的value值。如果该键没有绑定value值，返回null。
// System.out.println(map.remove(10));
Map<Integer, Integer> map2 = new HashMap<>();
map2.put(3, 300);
map2.put(4, 400);
// 将参数map中所有的键值对加入到当前map中。
map.putAll(map2);
// System.out.println(map);
// 清空map。（删除map中所有的键值对）
// map.clear();
System.out.println(map);
// 返回一个set，该set中包含map中所有的key值。
Set<Integer> set = map.keySet();
// set.forEach(System.out::println);
// 返回一个Collection，该Collection中包含
// map中所有的value值。
Collection<Integer> c = map.values();
// c.forEach(System.out::println);
// 返回一个set，该set中存放map中所有的Entry（键值对）。
Set<Entry<Integer, Integer>> entrys = map.entrySet();
}
}
package day15;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
* 对Map进行遍历
*/
public class MapTraverse {
public static void main(String[] args) {
Map<Integer, Integer> map = new HashMap<>();
map.put(1, 100);
map.put(2, 200);
map.put(3, 300);
map.put(4, 500);
// 1 使用keySet方法。
Set<Integer> keys = map.keySet();
keys.forEach(k -> System.out.println(k + ":" + map.get(k)));
// 2使用entrySet方法
Set<Entry<Integer, Integer>> entry = map.entrySet();
entry.forEach(e -> System.out.println(e.getKey() + ":" + e.getValue()));
map.forEach((k, v) -> System.out.println(k + ":" + v));
}
}
6、LinkedHashMap与TreeMap
LinkedHashMap继承自HashMap。 TreeMap 继承自 AbstractMap。
在特征上与LinkedHashSet与TreeSet类似。
NavigableMap是SortedMap的子接口。
TreeMap是NavigableMap的实现类。
package day15;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapTest {
public static void main(String[] args) {
// Map<String, Integer> map = new HashMap<>();
Map<String, Integer> map = new LinkedHashMap<>();
map.put("addf", 11);
map.put("zdfeaa", 22);
map.put("fous", 33);
map.put("onensdf", 44);
map.put("tisoe", 55);
/*
* 与HashSet相同，HashMap在获取元素时，也不能保证 获取的顺序与元素加入时的顺序一致。实际上，HashSet
* 底层就是使用HashMap来实现的。 如果期望获取元素的顺序与元素加入时的顺序一致，可以使用 LinkedHashMap来实现。
*/
map.forEach((k, v) -> System.out.println(k + ":" + v));
}
}
package day15;
import java.util.Map;
import java.util.TreeMap;
public class TreeMapTest {
public static void main(String[] args) {
// TreeMap是根据key值进行排序的。
// Map<Integer, String> map = new TreeMap<>();
Map<Integer, String> map = new TreeMap<>((a, b) -> b - a);
// 可以指定比较器，如果没有提供比较器，则使用自然排序。
map.put(1, "sdf");
map.put(5, "ccc");
map.put(-2, "csa");
map.forEach((k, v) -> System.out.println(k + ":" + v));
}
}
7、聚合操作
流是一组元素的序列。集合对象可以通过相关方法获得流。
通过集合对象的流，就可以在流的基础上对集合元素进行相 关的操作，如过滤，映射，迭代等，该操作称为流操作，也 称为聚合操作。
流管道为一系列顺序的聚合操作。管道由数据源（数组，集 合， IO通道等）， 中间操作（ 0或多个）与终端操作（ 1个） 组成
聚合操作可以分为中间操作与终端操作。
聚合操作聚合操作的中间操作会产生一个新的流，供后续中 间操作或终端操作使用。而终端操作不会再产生流。
中间操作是惰性的，这样可以在一定程度上提高性能。流只 有在终端操作开始时才会执行。
中间操作可以分为有状态操作与无状态操作。
一旦执行终端操作，则整个流被消费掉，不可再次使用。
8、案例
输出集合中所有的元素，可以使用：
forEach方法
聚合操作的forEach操作。
package day15;
import java.util.ArrayList;
import java.util.Collection;
public class ForEach {
public static void main(String[] args) {
Collection<Integer> c = new ArrayList<>();
for (int i = 0; i < 50; i++) {
c.add(i);
}
// c.forEach(System.out::println);
// c.stream().forEach(System.out::println);
// c.stream().filter(t -> t > 3).forEach(System.out::println);
// c.forEach(System.out::println);
// c.stream().forEach(System.out::println);
c.parallelStream().forEach(System.out::println);
}
}
9、聚合操作与迭代器
不同之处：
聚合操作从流中处理数据，其不会改变底层的数据源。而迭 代器则对集合进行操作，会改变集合。
聚合操作使用内部迭代方式，而迭代器使用外部迭代进行处 理。
聚合操作（内部迭代）可以根据需要并行处理数据，而迭代 器仅能进行顺序迭代
10、中间操作
中间操作 filter map / mapToInt / mapToLong / mapToDouble distinct sorted peek limit skip
11、缩减操作
将流中的内容合并，作为一个值返回，这种操作成为缩减操作。
缩减操作如下：
max
min
average
sum
count
reduce
collect
说明：缩减操作都是终端操作。
package day15;
import java.util.*;
public class AggOP {
public static void main(String[] args) {
Collection<Integer> c = new ArrayList<>();
c.add(200);
c.add(-2);
c.add(16);
c.add(28);
c.add(-2);
// c.stream().filter(t -> t > 20).forEach(System.out::println);
// c.stream().distinct().forEach(System.out::println);
// c.stream().filter(t -> t >
// 20).distinct().sorted().forEach(System.out::println);
// c.stream().peek(System.out::println).forEach(System.out::println);
// c.stream().limit(30).forEach(System.out::println);
// c.stream().skip(2).forEach(System.out::println);
Collection<Person> cp = new ArrayList<>();
cp.add(new Person("1", 20));
cp.add(new Person("2", 10));
cp.add(new Person("3", 14));
cp.add(new Person("4", 24));
cp.add(new Person("1", 20));
// cp.stream().map(p -> p.getName()).forEach(System.out::println);
// cp.stream().map(p -> p.getAge()).forEach(System.out::println);
// cp.stream().mapToInt(p -> p.getAge()).forEach(System.out::println);
// cp.stream().distinct().forEach(System.out::println);
int max = cp.stream().mapToInt(Person::getAge).max().getAsInt();
int min = cp.stream().mapToInt(Person::getAge).min().getAsInt();
double avg = cp.stream().mapToInt(Person::getAge).average().getAsDouble();
int sum = cp.stream().mapToInt(Person::getAge).sum();
long count = cp.stream().mapToInt(Person::getAge).count();
// System.out.println(max);
// System.out.println(min);
// System.out.println(avg);
// System.out.println(sum);
// System.out.println(count);
// int x =
// cp.stream().mapToInt(Person::getAge).reduce(Math::max).getAsInt();
// int x =
// cp.stream().mapToInt(Person::getAge).reduce(Integer::sum).getAsInt();
// int x = cp.stream().mapToInt(Person::getAge).reduce(100, Math::max);
// System.out.println(x);
// List<Integer> list = cp.stream().filter(p -> p.getAge() >
// 15).mapToInt(p -> p.getAge()).distinct().sorted()
// .collect(() -> new ArrayList<>(), (t, e) -> t.add(e), (a, b) ->
// a.addAll(b));
List<Integer> list = cp.stream().filter(p -> p.getAge() > 15).mapToInt(p -> p.getAge()).distinct().sorted()
.collect(ArrayList::new, List::add, List::addAll);
list.forEach(System.out::println);
}
}
class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
12、Arrays类
Arrays类是一个工具类，提供对数组的一系列操作。
Arrays类的排序方法（ sort）也可以使用自然排序，也可以 指定排序规则。
asList方法
package day15;
import java.util.Arrays;
import java.util.List;
public class AsList {
public static void main(String[] args) {
int[] x = { 1, 2, 3, 5, 8 };
List<int[]> list = Arrays.asList(x);
System.out.println(list.size());
Integer[] y = { 1, 2, 3, 5, 8 };
List<Integer> list2 = Arrays.asList(y);
System.out.println(list2.size());
// 通过asList方法返回的List是不能改变的。
// 因为数组长度是不能改变的。
// list2.add(100);
}
}
13、Collections类
Collections类提供了一系列操作集合的方法。所有的方法都是 静态的。
sort
binarySearch
reverse
shuffle
fill
min / max
frequency
package day15;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsMethod {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(500);
list.add(-20);
list.add(78);
list.add(222);
list.add(78);
// 对List进行排序（自然排序）。
// Collections.sort(list);
// 对List进行排序（比较器）。
// Collections.sort(list, (a, b) -> b - a);
// 对于排序，List本身也能够进行排序
// list.sort(null);
// list.sort((a, b) -> b - a);
// list.forEach(System.out::println);
// 在List中查询指定的关键字，如果找到，返回关键字的
// 索引，如果没有找到，返回-插入点-1。
// 要求：List必须是升序排列的，否则结果是不确定的。
// int index = Collections.binarySearch(list, 333);
// System.out.println(index);
// 对List的顺序实现翻转。
// Collections.reverse(list);
// list.forEach(System.out::println);
// 对List进行洗牌操作。
// Collections.shuffle(list);
// list.forEach(System.out::println);
// 使用参数指定的元素对List进行填充。
// Collections.fill(list, 90);
// list.forEach(System.out::println);
// 返回集合中的最大值（自然排序）
// int x = Collections.max(list);
// System.out.println(x);
// 返回集合中的最大值（比较器）
// int x = Collections.max(list, (a, b) -> b - a);
// System.out.println(x);
// 返回集合中的最小值（自然排序）
// System.out.println(Collections.min(list));
// 返回集合的最小值（比较器）
// System.out.println(Collections.min(list, (a, b) -> b - a));
// 返回关键字（第2个参数）在集合中（第1个参数）出现的频率。
System.out.println(Collections.frequency(list, 78));
}
}