JDK8的新特性总结

文章目录

1.接口默认方法实现
2.新增Base64加解密API
- 2.1.Base64编码简介
- 2.2.JDK1.8之前Base64的API
- 2.3.JDK1.8之后Base64的API
3.时间日期处理类
- 3.1.LocalDate常用的API
- 3.2.日期格式化
- 3.3.日期的比较
4.空指针处理Optional类
5.Lambda表达式
6.函数式编程
- 6.1.Java8内置的四大函数式接口
- 6.2.函数式编程Function
- 6.3.函数式编程BiFunction
- 6.4.函数式编程Consumer
- 6.5.函数式编程Supplier
- 6.6.函数式编程Predicate
- 6.7.方法与构造方法引用
7.Stream流式操作集合框架
- 7.1.Stream简介
- 7.2.map和filter函数
- 7.3.sorted和limit函数
- 7.4.allMatch和anyMatch函数
- 7.4.max和min函数
- 7.5.并行流parallelStream
- 7.6.reduce函数
- 7.7.集合foreach
8.Collector收集器和集合统计
- 8.1.collector收集器
- 8.2.joining函数
- 8.3.partitioningBy分组
- 8.4.groupingBy分组
- 8.5.counting函数
- 8.6.summarizing集合统计
9.Collection和Lambda实战
10.内存空间和异常处理
- 10.1.新内存空间Matespace
- 10.2.try-with-resources(JDK7)

JDK安装

win64位-JDK1.8下载||https://pan.baidu.com/s/1fMNaZ0JgySo2MzBT90T5Tw ||jjw3
Linux64位-JDK1.8||https://pan.baidu.com/s/1CDpW-UNYyje-p0BxaNtncQ ||nwyd
Mac-JDK1.8下载||https://pan.baidu.com/s/1liT9kSLicpXEAd7AdA0nOg ||5bpk

1.接口默认方法实现

在jdk1.8以前接⼝⾥⾯是只能有抽象⽅法，不能有任何⽅法的实现的
jdk1.8⾥⾯打破了这个规定，引⼊了新的关键字default，使⽤default修饰⽅法，可以在接⼝⾥⾯定义具体的⽅法实现
默认⽅法：接⼝⾥⾯定义⼀个默认⽅法，这个接⼝的实现类实现了这个接⼝之后，不⽤管这个default修饰的⽅法就可以直接调⽤，即接⼝⽅法的默认实现

（1）编写接口

public interface Animal {void run();void eat();/*** 接口的默认方法*/default void sleep(){System.out.println("睡觉");}/*** 静态方法*/static void st(){System.out.println("静态方法");}
}

（2）编写实现类

public class Dog implements Animal{@Overridepublic void run() {System.out.println("小狗跑");}@Overridepublic void eat() {System.out.println("小狗吃");}public static void main(String[] args) {Dog dog = new Dog();dog.run();dog.eat();//直接能掉接口的默认实现dog.sleep();//直接调用静态方法Animal.st();}
}

（3）运行结果

2.新增Base64加解密API

2.1.Base64编码简介

Base64是网络上常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法，基于64个字符A-Z、0-9、a-z、+、/的编码方式，是一种能将任意二级制数据用64种字节组合成字符串的方法，而这个二进制数据和字符串资料之间是可以相互转换的，实际应用上，Base64不但可以将二进制数据可视化，还可以用于数据传输的加密

2.2.JDK1.8之前Base64的API

早期使用JDK里sun.misc套件下的BASE64Encoder和BASE64Decoder这两个类

（1）编码实战

    public static void main(String[] args) {//目标字符串String str = "lixiang";//加密BASE64Encoder encoder = new BASE64Encoder();String strEncode = encoder.encode(str.getBytes("UTF-8"));System.out.print("加密后："+strEncode);//解密BASE64Decoder decoder = new BASE64Decoder();String strDecode = new String(decoder.decodeBuffer(strEncode),"UTF-8");System.out.print("解密后："+strDecode);}

（2）运行结果

缺点：编码和解码的效率比较差，公开信息说以后要取消这个方法
Apache Commons Codec有提供Base64的编码与解码，但是需要引第三方依赖

2.3.JDK1.8之后Base64的API

JDK1.8之后java.util中提供了Base64的类

（1）编码实战

    public static void main(String[] args) {//目标字符串String str = "lixiang";//加密Base64.Encoder encoder = Base64.getEncoder();String strEncode = encoder.encodeToString(str);System.out.print("加密后："+strEncode);//解密Base64.Decoder decoder = Base64.getDecoder();String strDecoder = new String(decoder.decode(strEncode),"UTF-8");System.out.print("解密后："+strDecoder); }

（2）运行结果

优点：不需要引包，效率远大于un.misc 和 Apache Commons Codec

3.时间日期处理类

时间处理JDK1.8之前用的是SimpleDateFormat，Calendar等类，缺点是java.util.Date是线程不安全的，而且日期/时间对象比较，加减麻烦
JDK1.8新发布Date-Time API进行加强对日期时间的处理
包所在位置：java.time
核心类

LocalDate:不包含具体时间的日期
LocalTime:不包含日期的时间
LocalDateTime:包含了日期及时间

3.1.LocalDate常用的API

LocalDate today = LocalDate.now();获取当前日期的年份：today.getYear()获取当前日期的月份：today.getMonth()获取当前日期的月份（数字）：today.getMonthValue()获取当前日期是当月的多少号：today.getDayOfMonth()获取当前日期是这一周的周几：today.getDayOfWeek();获取当前日期+1年,必须返回新的对象才会+1：today.plusYears(1)获取当前日期+1月,必须返回新的对象才会+1：today.plusMonths(1)获取当前日期+1周,必须返回新的对象才会+1：today.plusWeeks(1)获取当前日期+1天,必须返回新的对象才会+1：today.plusDays(1)获取当前日期-1天,必须返回新的对象才会-1：today.minusDays(1)获取当前日期-1周,必须返回新的对象才会-1：today.minusWeeks(1)获取当前日期-1年,必须返回新的对象才会-1：today.minusYears(1)获取当前日期-1月,必须返回新的对象才会-1：today.minusMonths(1)日期比较，当前日期与目标日期之后：date.isAfter(today)日期比较，当前日期与目标日期之前：date.isBefore(today)修改当前日期的年份：today.withYear(1999)修改当前日期的月份：today.withMonth(3)修改当前对象在当月的日期：today.withDayOfMonth(5)比较两个日期是否相等：date.isEqual(today)

3.2.日期格式化

JDK1.8之前：SimpleDateFormat来进行格式化，但SimpleDateFormat并不是线程安全的
JDK1.8之后：引入线程安全的日期与时间DateTimeFormatter

//获取当前时间
LocalDateTime today = LocalDateTime.now();
System.out.println("today:"+today);//日期格式化
LocalDateTime today = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String date = dtf.format(today);

//定制日期对象,参数分别对应，年、月、日、时、分、秒
LocalDateTime localDateTime = LocalDateTime.of(2021,11,12,8,10,2);

3.3.日期的比较

LocalDateTime date1 = LocalDateTime.of(2021,11,12,8,10,2);
LocalDateTime date2 = LocalDateTime.of(2020,11,12,8,10,2);Duration duration = Duration.between(date1,date2);
//两个时间差的天数
System.out.println(duration.toDays());
//两个时间的小时差
System.out.println(duration.toHours());
//两个时间的分钟差
System.out.println(duration.toMinutes());
//两个时间的毫秒差
System.out.println(duration.toMillis());
//两个时间的纳秒差
System.out.println(duration.toNanos());

4.空指针处理Optional类

（1）Optional类的用处

主要解决的问题是空指针异常（NullPointerException）

（2）创建Optional类

of
- null值作为参数传进去会报异常
- Optional optional = Optional.of(空对象);

ofNullable
- null值作为参数传进去不会报异常
- Optional optional = Optional.ofNullable(空对象);

（3）访问Optional对象的值

get
- 获取Optional对象中的值
- optional.get()
isPresent
- 判断optional是否存在，如果不存在返回false，一般在获取Optional对象中的值之前调用判断
- optional.isPresent()

Student student = null;//Optional<Student> optional = Optional.of(student);Optional<Student> optional = Optional.ofNullable(student);//拿值之前先判断optional是否为空
if(optional.isPresent()){Student student1 = optional.get();
}else{System.out.println("optional中值为空");
}

（4）兜底orElse方法

orElse()如果有只就返回该值，否则就传送一个默认值

Student student1 = null;
Student student2 = new Student("李祥",20);//当student1为空时，就返回student2对象，不为空就返回student1对象
Student orElse = Optional.ofNullable(student1).orElse(student2);System.out.println(orElse);

//判断对象年龄如果为空值就传送一个默认7
Optional.ofNullable(student1).map(obj->obj.getAge()).orElse(7);
System.out.println("age:"+integer);

5.Lambda表达式

（1）什么是Lambda表达式

在JDK8之前，java是不支持函数式编程的，所谓函数编程，可以理解成将一个函数（行为动作）作为一个方法的参数传递过去执行，面向对象编程是对数据的抽象，而函数式编程是对行为的抽象

（2）JDk8之前创建线程的方式与Lambda创建线程的方式

JDK8之前创建线程

public static void main(String[] args) {new Thread(new Runable(){@Overridepublic void run(){System.out.print("测试");}}).start();}

Lambda表达式创建线程

public static void main(String[] args) {//new Thread(()->{System.out.print("测试");}).start();new Thread(()->System.out.print("测试")).start();
}

（3）集合容器元素排序

JDK8之前集合排序

public static void main(String[] args) {Arrays.asList("aaa","bbb","ccc","fff","ddd");Collections.sort(list,new Comparator<String>(){@Overridepublic int compare(String a,String b){return a.compareTo(b);}});
}

Lambda表达式方式排序

public static void main(String[] args) {Arrays.asList("aaa","bbb","ccc","fff","ddd");Collections.sort(list,(x,y) -> x.comparaTo(y));
}

（4）Lambda表达式的使用场景

一个接口中只包含一个需要实现的方法，可以使用Lambda表达式，这样的接口称为函数式接口，语法：(params) -> expression
(x,y) -> {System.out.print(x+y);}(x,y):这一部分为参数，当只有一个参数时可以省略括号，x->,当没有参数时，直接写括号()->:表示指向执行的方法体{System.out.print(x+y);}:表示执行的方法体，可以是表法式，也可以是代码块，当是表达式的时候可以省略{}，没有{}时;不要写，代码块时要加上{}，就和平常的语句逻辑一样。好处：Lambda表达式的实现方式时在本质以匿名内部类的方式进行实现，减少代码冗余，提高开发效率。

（5）自定义Lambda接口

定义一个函数接口，需要加上@FuncationInterface注解，只允许有一个默认的方法实现。
定义一个可以使用加减乘除的接口，之前需要定义四个方法，现在只需一个方法
编写接口，定义方法，加上FunctionInterface注解

@FunctionInterface
public interface OperFunction<R,T>{R operator(T t1,T t2);
}

定义方法，将接口作为方法入参

public static Integer operator(Integer x,Integer y,OperFunction<Integer,Integer> of){return of.operator(x,y);
}

测试

public static void main(String[] args) {System.out.print(operator(x,y,(x,y)->x+y));System.out.print(operator(x,y,(x,y)->x-y));System.out.print(operator(x,y,(x,y)->x*y));System.out.print(operator(x,y,(x,y)->x/y));
}

6.函数式编程

6.1.Java8内置的四大函数式接口

Lambda表达式必须先定义接口，创建相关方法之后可使用，这样做十分不方便，java8已经内置了许多接口，例如下面四个功能性接口，所以一般很少会由用户去定义新的函数时接口。
java8的最大特性就是函数式接口，所有标注了@FunctionalInterface注解的接口都是函数式接口。

Consumer<T>：消费型接口，有入参，无返回值。void accept(T t);Supplier<T>：供给型接口，无入参，有返回值。T get();Function<T,R>：函数型接口，有入参，无返回值R apply(T t);Predicate<T>：断言型接口，有入参，有返回值，返回值类型确定是booleanboolean test(T t);

6.2.函数式编程Function

Function
- 传入一个值经过函数的计算返回另一个值
- T：入参类型，R：出参类型

@FunctionalInterface
public interface Function<T, R> {    /**     * Applies this function to the given argument.     * @param t the function argument     * @return the function result    */    R apply(T t);
}

作用：将转换后逻辑提取出来，解耦合

public class FunctionObj implements Function {@Overridepublic Object apply(Object o) {return o+"：apply处理";}
}

public static void main(String[] args) {Object lixiang = apply("lixiang", new FunctionObj());System.out.println(lixiang);
}public static Object apply(String o,FunctionObj obj){return obj.apply(o);
}

6.3.函数式编程BiFunction

BiFunction Function只能接受一个参数，如果要传递两个参数，则用BiFunction。

@FunctionalInterface
public interface BiFunction<T,U,R>{R apply(T t,U u);
}

public static void main(String[] args) {  System.out.println(operator(10,21,(a,b)->a+b));   System.out.println(operator(10,2,(a,b)->a-b)); System.out.println(operator(8,4,(a,b)->a*b)); System.out.println(operator(10,2,(a,b)->a/b)); }
public static Integer operator(Integer a, Integer b, BiFunction<Integer,Integer, Integer> bf) {       return bf.apply(a, b);
}

6.4.函数式编程Consumer

Consumer消费型接口：有入参，无返回值
将 T 作为输入，不反回任何内容
- 调用方法：void accept(T t);

@FunctionalInterface
public interface Consumer<T> {void accept(T t);
}

用途：因为没有出参常用于打印，发送短信等消费动作

    public static void main(String[] args) {sendMessage("11111111",phone -> System.out.println(phone+"已经被发送"));}public static void sendMessage(String phone, Consumer<String> consumer){consumer.accept(phone);}

6.5.函数式编程Supplier

Supplier：供给型接口：无入参，有返回值
T：出参类型
- 调用方法：T get();

@FunctionalInterface
public interface Supplier<T> {T get();
}

用途：泛型一定和方法的返回值是一种类型，如果需要获得一个数据，并且不需要传入参数，可以使用Supplier接口，例如无参的工厂方法。

    public static void main(String[] args) {Student student = newStudent();System.out.println(student);}public static Student newStudent(){Supplier<Student> supplier=()-> new Student("lixiang",20);return supplier.get();}

6.6.函数式编程Predicate

Predicate：断言型接口：有入参，有出参，返回值类型是boolean
T：入参类型，出餐类型是Boolean
调用方法：boolean test(T t)

@FunctionalInterface
public interface Predicate<T> {boolean test(T t);
}

用途：接收一个参数，用于判断是否满足一定的条件过滤数据

public static void main(String[] args) {List<String> list = Arrays.asList("awewrwe","vdssdsd","aoooo","psdddsd");List<String> results = filter(list, obj -> obj.startsWith("a"));System.out.println(results);}public static List<String> filter(List<String> list,Predicate<String> predicate){List<String> results = new ArrayList<>();for (String s : list) {if(predicate.test(s)){results.add(s);}}return results;}

6.7.方法与构造方法引用

以前调用方法：对象.方法名()，类名.方法名()
JDK8提供了另外一种方式 :: (双冒号)

方法引用是一种更简洁易懂的lambda表达式，操作符是双冒号::,用来直接访问类或者实例已经存在的方法或者构造方法。通过语法引用，可以将方法的引用赋值给一个变量语法：左边是容器（可以是类名，实例名），中间是"::"，右边是相应的方法名静态方法：ClassName::methodName
实例方法：Instance::methodName
构造函数：类名::new单个参数
Function<入参1，返回类型> func = 方法引用应用 func.apply(݇入参);两个参数
BiFunction<݇入参1, 入参2> func = 方法引用
应用 func.apply(入参1，入参2);

测试调用

public static void main(String[] args) {//静态方法的调用Function<String,Integer> function1 =  Integer::parseInt;Integer num = function1.apply("1024");System.out.println("转化后："+num);//实例方法的调用String context = "lixiang";Function<Integer,String> function2 = context::substring;String str = function2.apply(1);System.out.println("截取后的字符串："+str);//构造方法的调用,双参数BiFunction<String,Integer,Student> function3 = Student::new;Student lixiang = function3.apply("lixiang", 20);System.out.println(lixiang);//构造方法的调用，单个参数Function<String,Student> function4 = Student::new;Student lisi = function4.apply("lisi");System.out.println(lisi);//函数作为参数传递到另一个方法中String sayHello = sayHello(String::toUpperCase, "lixiang");System.out.println(sayHello);}public static String sayHello(Function<String,String> function,String str){String apply = function.apply(str);return apply;}

7.Stream流式操作集合框架

7.1.Stream简介

（1）什么是stream

Stream中文称为"流"，通过将集合转化为这么一种叫做流的元素队列，通过声明性方式，能够对集合中的每一个元素进行一些列并行或穿行的流水线操作。
元素是特定类型的对象，所以元素集合看作一种流，流在管道中传输，且可以在管道的节点上进行处理，比如 排序，聚合，过滤等

操作详情
- 数据元素就是原始的集合，List、Map、Set等
- 生成流，可以是串行流stream()或者并行流parallelStream()
- 中间操作，可以是排序，聚合，过滤，转换等
- 终端操作，很多流操作本身就会返回一个流，所以多个操作可以直接连接起来，最后统一收集

（2）案例

        List<String> list = Arrays.asList("SpringBoot", "SpringCloud", "Redis", "RabbitMQ");List<String> collect = list.stream().map(obj -> obj + "-拼接").collect(Collectors.toList());for (String s : collect) {System.out.println(s);}

7.2.map和filter函数

（1）map函数

将流中的每一个元素T映射成R（类似类型转换）
应用场景：转换对象，类似DO对象转换成DTO对象
map函数源码

测试

    public static void main(String[] args) {List<User> users = Arrays.asList(new User(1, "小东", "123"),new User(2, "小李", "123"),new User(3, "小王", "123"),new User(4, "小张", "123"));List<UserDTO> collect = users.stream().map(user -> {UserDTO userDTO = new UserDTO();userDTO.setUserId(user.getId());userDTO.setUsername(user.getName());return userDTO;}).collect(Collectors.toList());for (UserDTO userDTO : collect) {System.out.println(userDTO);}}

（2）filter函数

用于通过设置的条件过滤出元素
应用场景：过滤出符合条件的元素
filter函数源码

测试

 List<String> list = Arrays.asList("SpringBoot", "SpringCloud", "Redis", "RabbitMQ","JUC");
//filter
List<String> collect5 = list.stream().filter(str -> str.length() > 4).collect(Collectors.toList());
System.out.println(collect5);

7.3.sorted和limit函数

（1）sorted函数

sorted()对流进行自然的排序，其中的元素必须实现Comparable接口
应用场景：需要对集合的元素进行定制化排序
sorted源码

测试

//排序，sort()，默认升序
List<String> collect1 = list.stream().sorted().collect(Collectors.toList());
System.out.println("sort()按照英文字母升序："+collect1);//根据长度排序，默认升序
List<String> collect2 = list.stream().sorted(Comparator.comparing(obj -> obj.length())).collect(Collectors.toList());
System.out.println("sort()按照英文字母的长度升序："+collect2);//根据长度排序,降序
List<String> collect3 = list.stream().sorted(Comparator.comparing(obj -> obj.length(),Comparator.reverseOrder())).collect(Collectors.toList());
System.out.println("sort()按照英文字母的长度降序："+collect3);

（2）limit函数

limit()截断流使其最多包含指定的数量的元素
应用场景：排行榜，截取前多少名
limit源码

测试

//根据长度排序,降序,截取前三个
List<String> collect4 = list.stream().sorted(Comparator.comparing(String::length,Comparator.reverseOrder())).limit(3).collect(Collectors.toList());
System.out.println(collect4);

7.4.allMatch和anyMatch函数

（1）allMatch函数

检查是否匹配所有元素，主有全部符合才返回true
allMatch源码

测试

List<String> list = Arrays.asList("SpringBoot", "SpringCloud", "Redis", "RabbitMQ","Netty","JUC","Docker");boolean allFlag = list.stream().allMatch(str -> str.length()>5);System.out.println("allFlag全部满足返回true:"+allFlag);

（2）anyMatch函数

检查是否匹配所有元素，主有全部符合才返回true
anyMatch源码

测试

List<String> list = Arrays.asList("SpringBoot", "SpringCloud", "Redis", "RabbitMQ","Netty","JUC","Docker");boolean allFlag = list.stream().anyMatch(str -> str.length()>5);System.out.println("allFlag全部满足返回true:"+allFlag);

7.4.max和min函数

（1）max函数

获取集合元素中的最大值
max源码

测试

Optional<Student> max = list.stream().max(Comparator.comparingInt(Student::getAge));if (max.isPresent()){System.out.println("最大年龄："+max.get().getAge());
}

（2）min函数

获取集合中的最小值
min源码

测试

Optional<Student> min = list.stream().min((student1, student2) -> {return Integer.compare(student1.getAge(), student2.getAge());
});if(min.isPresent()){System.out.println("最小年龄："+min.get().getAge());
}

7.5.并行流parallelStream

为什么会有这个并行流
- 集合做重复的操作，如果使用串行执行会相当耗时，因此一般会采用多线程来加快，Java8的paralleStream用fork/join框架提供了并发执行能力
- 底层原理
  - 线程池（ForkJoinPool）维护一个线程队列
  - 可以分割任务，将父任务拆分成子任务，完全贴合分治思想
fork/join框架

两个区别

List<Integer> numbers = Arrays.asList(1,2,3,4,5,6,7,8,9,10);//串行流
System.out.print("串行流：");
numbers.stream().forEach(num -> System.out.print(num+" "));System.out.println();//并行流
System.out.print("并行流：");
numbers.parallelStream().forEach(num -> System.out.print(num+" "));

存在问题
parallelStream并行是否一定比Sream串行快？
- 错误，数据量少的情况，可能串行更快，ForkJoin会耗性能
多数情况下并行比串行块，是否可以都用并行
- 不行，部分情况会线程安全问题，parallelStream里面使用的外部变量，比如集合一定要使用线程安全集合，不然就会引用多线程安全问题

for (int i = 0; i < 10; i++) {//List<Integer> list = new ArrayList<>();CopyOnWriteArrayList list = new CopyOnWriteArrayList();IntStream.range(1,100).parallel().forEach(list::add);System.out.println(list.size());
}

7.6.reduce函数

什么是reduce操作
- 聚合操作，中文意思是“减少”
- 根据一定的规则将Stream中的元素进行计算后返回一个唯一的值
- 源码分析

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);//将集合内的元素相加
Integer integer = list.stream().reduce((x, y) -> x + y).get();System.out.println("集合内元素相加："+integer);//初始值100，将集合内的元素相加
Integer integer1 = list.stream().reduce(100,(x,y) -> x+y);System.out.println("100累加集合内的元素："+integer1);//判断最大值返回
Integer integer2 = list.stream().reduce((x, y) -> x > y ? x : y).get();System.out.println("集合内最大元素："+integer2);

7.7.集合foreach

集合遍历方式
- for循环
- 迭代器Iterator
源码分析

JDK8里面的新增接口

List<Student> result = Arrays.asList(new Student(32),new Student(33),new Student(21),new Student(29),new Student(18));
result.forEach(obj -> System.out.println(obj.getAge()));

注意点：
- 不能修改包含外部的变量的值
- 不能用break或者return或者continue等关键词结束或者跳出循环

8.Collector收集器和集合统计

8.1.collector收集器

collect()方法的作用
- 一个终端操作，用于对流中的数据进行归集操作，collect方法接收的参数是一个Collector
- 有两个方法重载，在Stream接口里面

//重载方法一
<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R>combiner);
//重载方法二
<R, A> R collect(Collector<? super T, A, R> collector)

Collector的作用
- 就是收集器，也是一个接口，它的工具类Collectors提供了很多工厂方法
Collectors的作用
- 提供了很多常见的集合的收集
- Collectors.toList()

public static <T> Collector<T, ?, List<T>> toList() {return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new,List::add,(left, right) -> { left.addAll(right); return left; },CH_ID);
}

ArrayList::new，创建一个ArrayList作为累加器
List::add，对流中的元素直接加到累加器中
reduce，对子任务归集结果直接全部添加到前一个子任务结果中
CH_ID是一个unmodifableSet集合

常见的收集器

Collector.toMaps()：创建一个map收集器
Collector.toSet()：创建一个set收集器
Collector.toCollection()：自定义收集器
- Collector.toCollection(LinkedList::new)
- Collector.toCollection(TreeSet::new)

8.2.joining函数

拼接函数，将集合内的元素按照一定规则拼接起来，Collectors.joining()

//三种重载方法
Collectors.joining() //无参数默认按照空字符拼接
Collectors.joining("-") //一个参数，按照“-”进行分割
Collectors.joining("-","{","}") //三个参数，第一个为分隔符，后两个为前缀后缀

源码

测试

List<String> list = Arrays.asList("SpringBoot","Docker","Java","SpringCloud","Netty");String collect1 = list.stream().collect(Collectors.joining());System.out.println(collect1);String collect2 = list.stream().collect(Collectors.joining("-"));System.out.println(collect2);String collect3 = list.stream().collect(Collectors.joining("-", "{", "}"));System.out.println(collect3);

8.3.partitioningBy分组

Collectors.partitioningBy()会根据筛选条件进行分组，返回一个Map<Boolean,List>类型，boolean为true的表示符合条件的，false的为不符合筛选条件的。
源码

测试

List<String> list = Arrays.asList("Java","SpringBoot","HTML5","CSS3");Map<Boolean, List<String>> collect = list.stream().collect(Collectors.partitioningBy(obj -> obj.length() > 4));System.out.println(collect);

8.4.groupingBy分组

Collectors.groupingBy(),会根据实体Bean的某个属性进行分组，更实用，返回的是Map<String,List>,key为要分组的实体Bean的属性值
源码

测试

List<Student> students = Arrays.asList(new Student("lx", 23, "北京"),new Student("ls", 24, "天津"),new Student("zs", 23, "⼴东"),new Student("ww", 22, "⼴东"),new Student("ld", 20, "北京"),new Student("xs", 20, "⼴东"),new Student("ok", 25, "北京"));
Map<String, List<Student>> collect = students.stream().collect(Collectors.groupingBy(obj -> obj.getProvince()));
//第二种方式
//Map<String, List<Student>> collect1 = students.stream().collect(Collectors.groupingBy(Student::getProvince));collect.forEach((key,value) -> {System.out.println("----"+key);value.forEach(obj-> System.out.println(obj));});

8.5.counting函数

用于统计groupingBy于分组之后，每组元素的个数
源码

测试

List<Student> students = Arrays.asList(new Student("lx", 23, "北京"),new Student("ls", 24, "天津"),new Student("zs", 23, "⼴东"),new Student("ww", 22, "⼴东"),new Student("ld", 20, "北京"),new Student("xs", 20, "⼴东"),new Student("ok", 25, "北京"));Map<String, Long> collect1 = students.stream().collect(Collectors.groupingBy(Student::getProvince, Collectors.counting()));collect1.forEach((key,value) -> {System.out.println("---"+key);System.out.println("---"+value);
});

8.6.summarizing集合统计

集合相关的统计都能实现，根据实体Bean的某个属性进行统计，求最大值，最小值，总和等等
分类
- summarizingInt
- summarizingLong
- summarizingDouble
测试，统计各个学生的年龄信息

IntSummaryStatistics collect = students.stream().collect(Collectors.summarizingInt(Student::getAge));
System.out.println("平均值："+collect.getAverage());
System.out.println("总人数："+collect.getCount());
System.out.println("年龄总和："+collect.getSum());
System.out.println("最大值："+collect.getMax());
System.out.println("最小值："+collect.getMin());

9.Collection和Lambda实战

（1）需求：求两个集合的交集、差集、去重并集，两集合的各自平均值，总和

（2）创建两个集合

//总价 35
List<VideoOrder> videoOrders1 = Arrays.asList( new VideoOrder("20190242812", "springboot教程", 3), new VideoOrder("20194350812", "微服务SpringCloud", 5), new VideoOrder("20190814232", "Redis教程", 9), new VideoOrder("20190523812", "⽹⻚开发教程", 9), new VideoOrder("201932324", "百万并发实战Netty", 9));//总价 54
List<VideoOrder> videoOrders2 = Arrays.asList( new VideoOrder("2019024285312", "springboot教程", 3), new VideoOrder("2019081453232", "Redis教程", 9), new VideoOrder("20190522338312", "⽹⻚开发教程", 9), new VideoOrder("2019435230812", "Jmeter压⼒测试", 5), new VideoOrder("2019323542411", "Git+Jenkins持续集成", 7), new VideoOrder("2019323542424", "Idea全套教程", 21));

（3）注意一点要重写equals和hashcode方法

@Override
public boolean equals(Object o) {if(o instanceof VideoOrder){VideoOrder o1 = (VideoOrder)o;return this.title.equals(o1.title);}return super.equals(o);
}@Override
public int hashCode() {return title.hashCode();
}

（4）计算两个集合的交集

List<VideoOrder> clist = videoOrder1.stream().filter(videoOrder2::contains).collect(Collectors.toList());

（5）计算两个集合的差集

List<VideoOrder> nclist = videoOrder1.stream().filter(obj -> !videoOrder2.contains(obj)).collect(Collectors.toList());

（6）计算两个集合的去重并集

List<VideoOrder> allList = videoOrder1.paralleStream().distinct().collect(Collectors.toList());
allList.addAll(videoOrder2);

（7）计算订单价格的平均值

double avg = videoOrder1.stream().collect(Collectors.averagingInt(VideoOrder::getMoney)).doubleValue();

（8）计算订单价格的总和

Integer sum = videoOrders1.stream().collect(Collectors.summingInt(VideoOrder::getMoney));

10.内存空间和异常处理

10.1.新内存空间Matespace

JVM 种类有很多，⽐如 Oralce-Sun Hotspot, Oralce JRockit, IBM J9, Taobao JVM，我们讲的是Hotspot才有，JRockit以及J9是没有这个区域
JVM内存JDK8之前的HotSpot JVM，有个区域叫做”永久代“（permanent generation），通过在命令行设置参数：-XX:MaxPermSize来设定永久代最大可分配的内存空间
如果JDK8中设置了PermSize和Max PermSize会被忽略并且警告
作用：该块内存主要是被JVM用来存放class和mate信息的，当class被加载loader的时候会被存储到该内存区中，入方法的编译信息及字节码、常量池和符号解析、类的层级信息，字段、名字等
java.lang.OutOfMemoryError: PermGen space
- 异常原因：永久代空间不够，可能类太多导致
JDK8使用本地内存存储类元数据信息，叫做元空间（Metaspcae）
在默认情况下Metaspcae的大小至于本地内存大小有关系
常⽤的两个参数
- -XX:MetaspaceSize=N 指Metaspace扩容时触发FullGC的初始化阈值
- -XX:MaxMetaspaceSize=N 指⽤于限制Metaspace增⻓的上限，防⽌因为某些情况导致Metaspace⽆限的使⽤本地内存
不管两个参数如何设置，都会从20.8M开始，然后随着类加载越来越多不断扩容调整直到最⼤
查看MetaspaceSize的大小
jstat -gc pid

10.2.try-with-resources(JDK7)

自动关流
jdk7之前处理异常

    public static void main(String[] args) throws FileNotFoundException {String filePath = "F:\\1.txt";test(filePath);}private static void test(String filePath) throws FileNotFoundException {OutputStream outputStream = new FileOutputStream(filePath);try {outputStream.write((filePath+"学习").getBytes());} catch (IOException e) {e.printStackTrace();}finally {try {outputStream.close();} catch (IOException e) {e.printStackTrace();}}}

jdk7之后处理异常

    public static void main(String[] args) throws FileNotFoundException {String filePath = "F:\\1.txt";test(filePath);}private static void test(String filePath) throws FileNotFoundException {//自动关流，当有多个文件时，直接用；分割就可以try (OutputStream outputStream = new FileOutputStream(filePath)){outputStream.write((filePath + "学习").getBytes());} catch (IOException e) {e.printStackTrace();}}

实现了AutoCloseable接口的类，在try()里面声明该类实例的时候，try结束后自动i盗用的close方法，这个动作会早于finally里面调用的方法。
不管是否出现异常，try()里面的实例都会被调用close方法。
try里面可以声明多个自动关闭的对象，越早声明的对象，会越晚被关掉。

    public static void main(String[] args) throws FileNotFoundException {String filePath = "F:\\1.txt";test(filePath);}private static void test(String filePath) throws FileNotFoundException {OutputStream outputStream = new FileOutputStream(filePath);try {outputStream.write((filePath+"学习").getBytes());} catch (IOException e) {e.printStackTrace();}finally {try {outputStream.close();} catch (IOException e) {e.printStackTrace();}}}

jdk7之后处理异常

    public static void main(String[] args) throws FileNotFoundException {String filePath = "F:\\1.txt";test(filePath);}private static void test(String filePath) throws FileNotFoundException {//自动关流，当有多个文件时，直接用；分割就可以try (OutputStream outputStream = new FileOutputStream(filePath)){outputStream.write((filePath + "学习").getBytes());} catch (IOException e) {e.printStackTrace();}}

实现了AutoCloseable接口的类，在try()里面声明该类实例的时候，try结束后自动i盗用的close方法，这个动作会早于finally里面调用的方法。
不管是否出现异常，try()里面的实例都会被调用close方法。
try里面可以声明多个自动关闭的对象，越早声明的对象，会越晚被关掉。