JDK8的新特性总结

时间：2022-11-01 15:49:42人气：次作者：快盘下载我要评论

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{
    ;Override
    public void run() {
        System.out.println(;小狗跑;);
    }

    ;Override
    public 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(){
        ;Override
        public 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>(){
        ;Override
        public 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>;断言型接口;有入参;有返回值;返回值类型确定是boolean
    
    boolean 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 {
    ;Override
    public 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里面可以声明多个自动关闭的对象;越早声明的对象;会越晚被关掉。



        上一篇：WiFi万能钥匙怎么共享WIFI密码?-WiFi万能钥匙共享密码方法教程
        下一篇：AutoCAD2007如何绘制螺旋图形-绘制螺旋图形的方法

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)

网友评论

推荐文章

最新文章

文章排行