1.HashMap改进
HashMap默认大小为16，负载因子为0.75，以2倍方式扩容，最大容量为2的30次方（若传入的容量过大，将被最大值替换），值可为null。
1.1当执行get操作的时候：
（1）计算 key 的 hash 值，根据 hash 值找到对应数组下标: (n - 1) & hash；
（2）判断数组该位置处的元素是否刚好就是我们要找的，如果不是，走第三步；
（3）判断该元素类型是否是 TreeNode，如果是，用红黑树的方法取数据，否则，走第四步；
（4）遍历链表，直到找到相等(==或equals)的 key。
get(Object key)源代码：
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
直接调用getNode的源代码：
final Node getNode(int hash, Object key) {
Node[] tab; Node first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
1.2当执行put操作的时候：
（1）首先检查大小，看是否需要扩容（默认元素超过最大值的0.75时扩容），如果需要扩容就进行扩容；
（2）然后计算出key的hashcode，根据hashcode定位数值所在的bucketIndex；
（3）如果该位置上没有元素，就直接插入，结束；
（4）如果该位置上有元素就使用equal方法比较是否相同；
（5）如果key相同就把新的value替换旧的value,结束；
（6）如果key不同，就继续遍历链表，如果没找到key的话，就构造一个新的节点，然后把节点插入到链表中(1.7时头插法，1.8是尾插法)，表示put成功（jdk 1.8 之后链表长度超过阈值就会转化为红黑树）。
put(K key, V value)源代码：
public V put(K key, V value) {
//hash(key)返回的是key的hash值
return putVal(hash(key), key, value, false, true);
}
直接调用putVal的源代码：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node[] tab;
Node p;
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node e;
K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode) p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
1.3源码巧妙之处
（1）利用二进制的运算替代取模
index = (n - 1) & hash
remove等方法中设计成(n - 1) & hash ，是因为在 n 为 2次幂的情况下，(n - 1) & hash ≈ hash % n ，而二进制的运算速度远远高于取模。
（2）利用hashCode值向右移动16位，尽量避免哈希冲突
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
可以看到它求hash的过程，将32位的hashCode值向右移动16位，高位补0，也就是只要了高16位，这是为什么呢？因为hashcode的计算方法导致哈希值的差异主要在高位，所以使用h >>>16就是为了尽量避免哈希冲突。
（3）resize过程中巧妙利用hash值新增位
以下图为例，其中图1表示扩容前的key1和key2两种key确定索引位置的示例，图2表示扩容后key1和key2两种key确定索引位置的示例，n代表length。
图1
元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
图2
resize过程中不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，16扩充为32的resize示意图如下（一方面位运算更快，另一方面减少抗碰撞的Hash函数耗时）：
图3
resize()源代码：
final Node[] resize() {
Node[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node[] newTab = (Node[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode)e).split(this, newTab, j, oldCap);
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
k1.8改进：
（1）jdk1.7采用数组加链表的方式，jdk1.8中引入了红黑树，提高查询速度；
（2）jdk1.7中新元素是插在链表的头部，jdk1.8中元素是插在链表的尾部，链表不会倒置，可以解决扩容的时候陷入死循环的问题，但是可能会出现数据丢失(线程)。
jdk1.7中的HashMap死循环问题：
单线程情况下正常
图：单线程情况
多线程情况下异常
1）假设有两个线程，代码如下：
do {
Entry next = e.next; // 假设线程一执行到这里就被调度挂起了
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
而线程二执行完成了。于是有下面的这个样子
图a
注意，因为 Thread1 的 e 指向了 key(3)，而 next 指向了 key(7)，其在线程二 rehash 后，指向了线程二重组后的链表。可以看到链表的顺序被反转
2）线程一被调度回来执行
- 先是执行 newTalbe[i] = e;
- 然后是 e = next，导致了 e 指向了 key(7)
-
而下一次循环的 next = e.next 导致了 next 指向了 key(3)
图b
3）线程一接着工作。把 key(7) 摘下来，放到 newTable[i] 的第一个，然后把 e 和 next 往下移
图c
4）环形链接出现
e.next = newTable[i] 导致 key(3).next 指向了 key(7)
此时的 key(7).next 已经指向了 key(3)， 环形链表就这样出现了
图d
（3）确定哈希桶数组索引位置
（4）扩容时不用重新hash计算位置
2.stream流改进
（1）获取stream流对象
public static void main(String[] args) {
List list = Lists.newArrayList();
list.add("java1");
list.add("java2");
list.add("java3");
list.add("java4");
list.add("java5");
list.add("java6");
//获取我们的stream流对象，通过流对象进行操作
Stream stream = list.stream();
//简单的循环遍历
stream.forEach(System.out::println);
}
执行结果如下：
图——获取stream流对象执行结果
（2）stream流获取集合的长度
public static void main(String[] args) {
List list = Lists.newArrayList();
list.add("java1");
list.add("java2");
list.add("java3");
list.add("java4");
list.add("java5");
list.add("java6");
//获取我们的stream流对象，通过流对象进行操作
Stream stream = list.stream();
long count = stream.count();
System.out.println("count:" + count);
}
执行结果如下：
图——stream流获取集合的长度执行结果
（3）stream流对数据进行去重
public static void main(String[] args) {
List list = Lists.newArrayList();
list.add("java1");
list.add("java2");
list.add("java3");
list.add("java3");
list.add("java4");
list.add("java5");
list.add("java5");
list.add("java6");
//获取我们的stream流对象，通过流对象进行操作
Stream stream = list.stream();
// 对数据进行去重并循环遍历结果
stream.distinct().forEach(System.out::println);
}
执行结果如下：
图——stream流对数据进行去重
（4）stream流处理后的数据收集成一个集合
public static void main(String[] args) {
List list = Lists.newArrayList();
list.add("java1");
list.add("java2");
list.add("java3");
list.add("java3");
list.add("java4");
list.add("java5");
list.add("java5");
list.add("java6");
//获取我们的stream流对象，通过流对象进行操作
Stream stream = list.stream();
// 去重后收集成一个集合
List collect = stream.distinct().collect(Collectors.toList());
System.out.println(collect.toString());
}
执行结果如下：
图——stream流处理后的数据收集成一个集合
（5）stream流的循环
stream流里面有两个循环遍历的方式：
Stream peek(Consumer action);
void forEach(Consumer action);
既然出现了两种循环，肯定有一定的区别，如果你真的使用的话，你肯定会发现forEach使用后，我如果想再对stream流进行操作是不可行的，这是因为forEach是一种消费性接口，也就是返回值是void，也就是没有返回值的接口，而我们看其他的stream流提供的接口，大部分都是有返回值的，返回的也是一个Stream流对象。
public void test01() {
List aopiList = Lists.newArrayList();
Aopi aopi = new Aopi("1", 1);
Aopi aop2 = new Aopi("2", 2);
Aopi aop3 = new Aopi("3", 3);
Aopi aop4 = new Aopi("4", 4);
aopiList.addAll(Arrays.asList(aopi, aop2, aop3, aop4));
//第一种方式
aopiList.forEach(item -> item.setName(item.getName() + "_test"));
System.out.println(
aopiList.stream().min((o1, o2) -> {
if (Objects.equals(o1.getAge(), o2.getAge()))
return 0;
return o1.getAge() > o2.getAge() ? 1 : -1;
}).get().toString()
);
System.out.println("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");
//第二种方式
System.out.println(
aopiList.stream().peek(item -> item.setName(item.getName() + "_test")).min((o1, o2) -> {
if (Objects.equals(o1.getAge(), o2.getAge())) {
return 0;
}
return o1.getAge() > o2.getAge() ? 1 : -1;
}).get().toString()
);
}
结论：
1）：使用stream.foreach也可以更改list中的每个item的内部属性值等等，但是要进行“二次流处理”，才能得到list中最小的item（根据age筛选）
2）：stream.peek比stream.foreach()可以跟直接拿到最小的item（根据age筛选）
（6）stream流的map的使用
map可以对stream流中的一行数据进行操作
public static void main(String[] args) {
List list = Lists.newArrayList();
list.add("java1");
list.add("java2");
list.add("java3");
list.add("java4");
list.add("java5");
list.add("java6");
//获取我们的stream流对象，通过流对象进行操作
Stream stream = list.stream();
//将集合中的数据循环变为大写字母，然后过滤，找到包含6的数据，循环打印出来
stream.map(s -> s.toUpperCase()).filter(s -> s.contains("6")).forEach(System.out::println);
}
执行结果如下：
图——stream流的map的使用
（7）stream流中的分页操作
一个skip和一个limit，skip代表着要跳过结果集中的前几个数据，limit也就是取结果集中的几个数据，也就是一个是page字段，一个是size字段，可以做到简单的分页。
public static void main(String[] args) {
List list = Lists.newArrayList();
list.add("java1");
list.add("java2");
list.add("java3");
list.add("java4");
list.add("java5");
list.add("java6");
//获取我们的stream流对象，通过流对象进行操作
Stream stream = list.stream();
//stream流对数据进行分页查询
stream.skip(2).limit(2).forEach(s -> System.out.println(s));
}
执行结果如下：
图——stream流中的分页操作
（8） stream流中匹配条件
stream流中有两个匹配的接口，anyMatch和allMatch；
anyMatch: 只要有一条数据可以匹配，那就会返回true
allMatch： 必须要每一条数据都匹配才会返回true
public static void main(String[] args) {
List list = Lists.newArrayList();
list.add("java1");
list.add("java2");
list.add("java3");
list.add("java4");
list.add("java5");
list.add("java6");
//获取我们的stream流对象，通过流对象进行操作
Stream stream = list.stream();
if (stream.anyMatch(s -> s.contains("6"))) {
System.out.println("匹配");
}
}
执行结果如下：
图——stream流中匹配条件
（9）使用stream流对集合进行分组
这个功能，相当于将一个excel表格中的各个单元格进行合并，首先创建一个类，这里用于集合存放的数据类型，我相信这种场景我们会经常遇到的
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Demo {
private String name;
private Integer key;
}
接下来我们创建一个数据类型为Demo的集合，并放置一些默认的数据类型
public static void main(String[] args){
List demos = new ArrayList<>();
demos.add(getDemo("DaMing", 1));
demos.add(getDemo("DaMing", 2));
demos.add(getDemo("Amy", 3));
demos.add(getDemo("Sam", 4));
demos.add(getDemo("Sam", 5));
}
public static Demo getDemo(String name, Integer key) {
return new Demo(name, key);
}
现在这个集合里的数据如果对应在excel表格里的话，应该是这样的：
原始图
但是有时候，我们需要的并不应该是这样的数据结构，而是将他们都分好组，比如下图：
目标图
对应我们的steam流就应该是如下的操作：
public static void main(String[] args){
List demos = new ArrayList<>();
demos.add(getDemo("DaMing", 1));
demos.add(getDemo("DaMing", 2));
demos.add(getDemo("Amy", 3));
demos.add(getDemo("Sam", 4));
demos.add(getDemo("Sam", 5));
Map> collect = demos.stream().collect(Collectors.groupingBy(Demo::getName, Collectors.mapping(Demo::getKey, Collectors.toList())));
Set keys = collect.keySet();
keys.stream().forEach(s -> System.out.println(s + " --> " + collect.get(s).toString()));
}
public static Demo getDemo(String name, Integer key) {
return new Demo(name, key);
}
输出结果如下：
图——使用stream流对集合进行分组
3.日期和时间
Java 8 在java.time包下推出了一组全新的时间日期API，涵盖了日期、时间、日期时间、时区、时刻、间隔、时钟等。新的java.time包下的所有类都是不可变类型而且线程安全的，解决了在此之前日期时间中存在的线程安全、横跨多包、使用复杂等诸多问题。
（1）间和日期
// 本地时间
LocalTime lt = LocalTime.now();
// 本地日期
LocalDate ld = LocalDate.now();
// 本地日期时间
LocalDateTime ldt = LocalDateTime.now();
// 创建一个指定的时间
LocalDateTime ldt = LocalDateTime.of(2012, 2, 12, 12, 12, 12);
// 日期时间转日期或时间
LocalDate ld = ldt.toLocalDate();
LocalTime lt = ldt.toLocalTime();
（2）字符串互转
// 格式化模版
DateTimeFormatter DATETIME19 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 时间转字符串
String dtStr = DATETIME19.format(LocalDateTime.now());
// 字符串转时间
LocalDateTime ldt = LocalDateTime.parse(dtStr, DATETIME19);
（3）时间运算
//获取指定单位的值
int year = ldt.getYear();
int day = ldt.getDayOfMonth();
int week = ldt.getDayOfWeek().getValue();
int hour = ldt.getHour();
// 指定时间单位的值
LocalDateTime ldt2 = ldt1.withDayOfMonth(10).withYear(2020); // 返回的是一个新的对象，需要接收
// 在现有时间上做加法
LocalDateTime ldt2 = ldt1.plusYears(2).plusMonths(-2);
// 在现有时间上做减法
LocalDateTime ldt2 = LocalDateTime.now().minus(-2, ChronoUnit.MONTHS).minusDays(3)
// 获取一天的开始或结束
LocalDateTime ldtStart = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
LocalDateTime ldtEnd = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
// 时间是否在指定时间之前
boolean isBefore = ldt1.isBefore(ldt2);
// 时间是否在指定时间之后
boolean isAfter = ldt1.isAfter(ldt2);
// 比较两个日期是否相等 重写的equals可以直接比较
boolean equality = ld1.equals(ld2);
// 比较是否是周期性日期，比如 生日 节假日 账单日 等
MonthDay holiday = MonthDay.of(5, 1); // 五一
boolean equality = holiday.equals(MonthDay.from(LocalDateTime.now())); // 今天是否是五一
（4）间隔计算
LocalDateTime ldt1 = LocalDateTime.of(2012, 2, 12, 12, 12, 12);
LocalDateTime ldt2 = LocalDateTime.of(2015, 5, 15, 15, 15, 15);
// 时间的间隔 Duration 表示时分秒的时间量（累计向上单位的差，即计算实际的总共的差）
Duration duration = Duration.between(ldt1, ldt2);
long durnMill = duration.toMillis(); // 计算毫秒差
long durnMin = duration.toMinutes(); // 计算分钟差
long durnHour = duration.toHours(); // 计算小时差
long durnDay = duration.toDays(); // 计算天数差
// 日期的间隔 Period 表示年月日的时间量（只计算当前单位的差，不累计向上单位的差距）
Period period = Period.between(ldt1.toLocalDate(), ldt2.toLocalDate());
long perdDay = period.getDays(); // 只计算当前差，不累计年月差带来的天数差
long perdMonth = period.getMonths(); // 只计算当前差，不累计年数差带来的月数差
long perdYear = period.getYears();
// 计算实际总间隔天数的第二种方法
long diffEehDay =ldt1.toLocalDate().toEpochDay() - ldt2.toLocalDate().toEpochDay();
// 计算指定时间单位之差
long diffChrDay =ChronoUnit.DAYS.between(ldt1, ldt2); // 日期单位之差
long diffChrMin =ChronoUnit.MINUTES.between(ldt1, ldt2); // 分钟单位之差
（5）时间戳、瞬时点、Date、本地时间、转换
// 时间戳
long timestamp = System.currentTimeMillis();
// 瞬时点
Instant instant = Instant.now();
// Date
Date date = new Date();
// 时间戳 转 瞬时点
Instant instant = Instant.ofEpochMilli(timestamp);
// 瞬时点 转 时间戳
long timestamp = instant.toEpochMilli();
// Date 转 瞬时点
Instant instant = date.toInstant();
// 瞬时点 转 Date
Date date = Date.from(instant);
// 瞬时点 转 本地时间
LocalDateTime ldt = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
// 本地时间 转 时间戳
long timestamp = ldt.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
long timestamp = ldt.toInstant(ZoneOffset.of("+08:00")).toEpochMilli();
long timestamp = ldt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
（6）时区时间
// 时区ID的集合
Set zoneSet = ZoneId.getAvailableZoneIds();
// 默认时区
ZoneId zoneId = ZoneId.systemDefault();
// 时区时间
LocalDateTime cur = LocalDateTime.now(); // 本地默认时间 2019-04-29T14:45:07.156
LocalDateTime ldt = LocalDateTime.now(ZoneId.of("America/Los_Angeles")); // 时区当前时间 2019-04-28T23:45:07.156
OffsetDateTime odt = OffsetDateTime.now(ZoneId.of("America/Los_Angeles")); // 带偏移量时间 2019-04-28T23:45:07.156-07:00
ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("America/Los_Angeles")); // 带时区的时间 2019-04-28T23:45:07.156-07:00[America/Los_Angeles]
LocalDateTime ldto = odt.toLocalDateTime(); // 转本地类时间 2019-04-28T23:45:07.156
LocalDateTime ldtz = zdt.toLocalDateTime(); // 转本地类时间 2019-04-28T23:45:07.156
// 时钟 类似时间戳
Clock clockDefault = Clock.systemDefaultZone(); //系统默认
Clock clockUtc = Clock.systemUTC(); // UTC
Clock c1ockZone = Clock.system(ZoneId.of("+08:00")); //指定时区
Clock clockRegion = Clock.system(ZoneId.of("Asia/Shanghai")); //指定区域
long timestamp = clockDefault.millis(); //获取时间戳，等于System.currentTimeMillis()
参考地址：Java 关于jdk1.8的Stream流的一些使用总结
参考地址：Jdk1.8新特性 - 日期和时间