JDK8新增常用功能

都2021年了，居然还不知道1.8都增加了什么特性以及很方便的东东，同样说一些常用的一些东东

HashMap 深入了解入口

在jdk1.8前，HashMap采用数组+链表实现，同一个hash值的节点都存储在一个链表里，但是当一个桶中的元素较多，通过key值依次查询的效率较低。而在jdk1.8中，hashMap采用数组+链表+红黑树实现，当链表长度超过阈值8时，链表转为红黑树，这样大大减少了查找时间
看下结构图对比：

ConcurrentHashMap 深入了解入口

在 JDK1.7中，本质上还是采用链表+数组的形式存储键值对的。但是，为了提高并发，把原来的整个 table 划分为 n 个 Segment 。所以，从整体来看，它是一个由 Segment 组成的数组。然后，每个 Segment 里边是由 HashEntry 组成的数组，每个 HashEntry之间又可以形成链表。我们可以把每个 Segment 看成是一个小的 HashMap，其内部结构和 HashMap 是一模一样的
当对某个 Segment 加锁时，如图中 Segment2，并不会影响到其他 Segment 的读写。每个 Segment 内部自己操作自己的数据。这样一来，我们要做的就是尽可能的让元素均匀的分布在不同的 Segment中。最理想的状态是，所有执行的线程操作的元素都是不同的 Segment，这样就可以降低锁的竞争。
JDK8中ConcurrentHashMap参考了JDK8 HashMap的实现，采用了数组+链表+红黑树的实现方式来设计，内部大量采用CAS操作。
JDK1.8版本的ConcurrentHashMap的数据结构已经接近HashMap
ConcurrentHashMap只是增加了同步的操作来控制并发，从JDK1.7版本的ReentrantLock+Segment+HashEntry，到JDK1.8版本中synchronized+CAS+HashEntry+红黑树

• 数据结构：取消了Segment分段锁的数据结构，取而代之的是数组+链表+红黑树的结构。
• 保证线程安全机制：JDK1.7采用segment的分段锁机制实现线程安全，其中segment继承自ReentrantLock。JDK1.8采用CAS+Synchronized保证线程安全。
• 锁的粒度：原来是对需要进行数据操作的Segment加锁，现调整为对每个数组元素加锁（Node）。
• 链表转化为红黑树:定位结点的hash算法简化会带来弊端,Hash冲突加剧,因此在链表节点数量大于8时，会将链表转化为红黑树进行存储。
• 查询时间复杂度：从原来的遍历链表O(n)，变成遍历红黑树O(logN)。

接口default方法

先上代码：

接口类：

public interface MainService {

    public default void testA(){
        System.out.println("我是接口中。。default方法");
    }

    public void plat();
}

实现类：

public class MainServiceImpl implements MainService{

    @Override
    public void plat() {
        System.out.println("plat方法");
    }

//可以选择default方法的实现与否
    @Override
    public void testA() {
        System.out.println("覆盖default。。");
    }
}

测试类：

public class MainTest {

    public static void main(String[] args) {
        MainService mainService = new MainServiceImpl();
        mainService.testA();
    }
}

控制台输出：

//如果重写default方法
覆盖default。。
//未重写default方法
我是接口中。。default方法

Java接口中的默认方法有什么用?
接口体现了一种模板方法的设计模式，接口定义了一些方法，如果我们要实现这个接口，我们必须覆盖这个方法，因此，就限制了实现类的一些行为，起到一个控制的作用，但是又不是完全的控制，在实现类中的你还可以定义自己的方法，也就是可以拓展。

Lamdba表达式

简单的使用例子

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

函数式接口

demo

    public static void main(String[] args) {
//        MainService mainService = new MainServiceImpl();
//        mainService.testA();

//那么就可以使用Lambda表达式来表示该接口的一个实现
        MainService m = number -> System.out.println("函数式接口。。。" + number);
        m.plat(123);
    }

@FunctionalInterface
public interface MainService {

    public default void testA(){
        System.out.println("我是接口中。。default方法");
    }

//只能定义一个抽象方法 但是可以有多个非抽象方法的接口。
    public void plat(int number);

}

运行结果

函数式接口。。。123

stream api 参考

在Java 8中，集合接口有两个方法来生成流：

• stream() - 为集合创建串行流
• parallelStream() - 为集合创建并行流

forEach

// 输出了10个随机数
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

map

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filter

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.stream().filter(string -> string.isEmpty()).count();

sorted

Random random = new Random();
// sorted 方法用于对流进行排序
random.ints().limit(10).sorted().forEach(System.out::println);

collectors

// Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList()); 
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);

统计

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

日期时间API

主要API有Local(本地)和Zoned(时区) ：LocalDate、LocalTime、LocalDateTime类。。。

// 从默认时区的系统时钟获取当前的日期时间。不用考虑时区差
        LocalDateTime date = LocalDateTime.now();
        System.out.println(date);
        System.out.println(date.getYear());
        System.out.println(date.getMonthValue());
        System.out.println(date.getDayOfMonth());
        System.out.println(date.getHour());
        System.out.println(date.getMinute());
        System.out.println(date.getSecond());
        System.out.println(date.getNano());

        // 手动创建一个LocalDateTime实例
        LocalDateTime date2 = LocalDateTime.of(2017, 12, 17, 9, 31, 31, 31);
        System.out.println("date2=" + date2);
        // 进行加操作，得到新的日期实例
        LocalDateTime date3 = date2.plusDays(12);
        System.out.println("date3=" + date3);
        // 进行减操作，得到新的日期实例
        LocalDateTime date4 = date3.minusYears(2);
        System.out.println("date4=" + date4);

        LocalTime localTime = LocalTime.now();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LocalTime localTime2 = LocalTime.now();
        //获取两个时间的差
        Duration du2 = Duration.between(localTime, localTime2);
        System.out.println(du2.toDays());
        System.out.println(du2.toHours());
        System.out.println(du2.toMinutes());

        LocalDate localDate =LocalDate.now();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LocalDate localDate2 = LocalDate.of(2016,12,12);
        //获取两个时间的差
        Period pe = Period.between(localDate2, localDate);
        System.out.println(pe.getDays());

		// temperalAdjust 时间校验器
        LocalDateTime ldt1 = LocalDateTime.now();
        System.out.println(ldt1);
        // 获取一年中的第一天
        LocalDateTime ldt2 = ldt1.withDayOfYear(1);
        System.out.println(ldt2);
        // 获取一个月中的第一天
        LocalDateTime ldt3 = ldt1.withDayOfMonth(1);
        System.out.println(ldt3);
        // 获取下一个周三
        LocalDateTime ldt4 = ldt1.with(TemporalAdjusters.next(DayOfWeek.WEDNESDAY));
        System.out.println(ldt4);
        // 获取下一个工作日
        LocalDateTime ldt5 = ldt1.with((t) -> {
            LocalDateTime ldt6 = (LocalDateTime)t;
            DayOfWeek dayOfWeek = ldt6.getDayOfWeek();
            if (DayOfWeek.FRIDAY.equals(dayOfWeek)){
                return ldt6.plusDays(3);
            }
            else if (DayOfWeek.SATURDAY.equals(dayOfWeek)){
                return ldt6.plusDays(2);
            }
            else {
                return ldt6.plusDays(1);
            }
        });
        System.out.println(ldt5);

		// DateTimeFormatter: 格式化时间/日期
        // 自定义格式
        LocalDateTime ldt = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        String strDate1 = ldt.format(formatter);
        String strDate = formatter.format(ldt);
        System.out.println(strDate);
        System.out.println(strDate1);

        // 使用api提供的格式
        DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE;
        LocalDateTime ldt2 = LocalDateTime.now();
        String strDate3 = dtf.format(ldt2);
        System.out.println(strDate3);

        // 解析字符串to时间
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime time = LocalDateTime.now();
        String localTime = df.format(time);
        LocalDateTime ldt4 = LocalDateTime.parse("2017-09-28 17:07:05",df);
        System.out.println("LocalDateTime转成String类型的时间："+localTime);
        System.out.println("String类型的时间转成LocalDateTime："+ldt4);

        //2018-05-04
        LocalDate today = LocalDate.now();
        // 取本月第1天： 2018-05-01
        LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth());
        // 取本月第2天：2018-05-02
        LocalDate secondDayOfThisMonth = today.withDayOfMonth(2);
        // 取本月最后一天，再也不用计算是28，29，30还是31： 2018-05-31
        LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth());
        // 取下一天：2018-06-01
        LocalDate firstDayOf2015 = lastDayOfThisMonth.plusDays(1);
        // 取2018年10月第一个周三 so easy?：  2018-10-03
        LocalDate thirdMondayOf2018 = LocalDate.parse("2018-10-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.WEDNESDAY));

Base64

Java 8 内置了 Base64 编码的编码器和解码器
方法：