Java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我

Posted 你的笑只是保护色

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我相关的知识，希望对你有一定的参考价值。

1. 新特性简介

新特性简介

  1. 速度更快

  2. 代码更少：新增了Lambda表达式

  3. 强大的Stream API

  4. 便于并行

  5. 最大化减少空指针异常Optional




2. Lambda表达式

介绍

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。



基础语法

  1. Java8引入了一个新的操作符： ->，该操作符称为箭头操作符或Lambda操作符，箭头操作符将Lambda表达式拆分为2部分

  2. 左侧：Lambda表达式的参数列表

  3. 右侧：Lambda表达式中所执行的功能，即Lambda体

  4. 语法格式1：无参数，无返回值：

    () -> System.out.println( "hello world" );

    public class test 
    public static void main(String[] args) 
        Runnable r = new Runnable() 
            @Override
            public void run() 
                System.out.println("Hello World!");
            
        ;
        r.run();

        System.out.println("--------------------------------------");
        Runnable r1 = () -> 
            System.out.println("Hello Lambda");
        ;
        r1.run();

  5. 语法格式2：有一个参数，并且无返回值，小括号可省略不写，：

    public class test 
    public static void main(String[] args) 
        Consumer<String> con = x -> 
            System.out.println(x);
        ;
        con.accept("QWERTY");

  6. 语法格式3：有2个以上的参数，有返回值，并且Lambda体中有多条返回值

    public class test 
    public static void main(String[] args) 
        Comparator<Integer> com = (x,y) -> 
            System.out.println("函数式接口");
            return Integer.compare(x,y);
        ;

  7. 语法格式4：若Lambda体中只有一条语句，return和大括号都可省略不写

    public class test 
    public static void main(String[] args) 
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);

  8. 语法格式5：Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出数据类型，即“类型推断”

  9. Lambda表达式需要函数式接口的支持！

    函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，可以使用@FunctionalInterface修饰



案例1：简单运算

  1. 函数式运算接口

    @FunctionalInterface
public interface MyFun 
    Integer getValue(Integer num);

  2. 测试类

    public class test 

    public static void main(String[] args) 
        Integer result = operation(10,x ->
            return x * x;
        );
        System.out.println(result);
    

    //operation方法，参数1为一Integer类型数据，参数2为一运算接口
    public static Integer operation(Integer num, MyFun myFun)
        return myFun.getValue(num);


案例2：定制排序比较两个Employee，先按年龄比，年龄相同再按姓名比，使用Lambda作为参数传递

  1. Employee

    @Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee 
    private String name;
    private int age;
    private Double salary;

  2. 测试类

    public class test 

    public static void main(String[] args) 
        List<Employee> list = Arrays.asList(
                new Employee("1号", 25, 5000.0),
                new Employee("2号", 35, 3000.0),
                new Employee("3号", 35, 2000.0),
                new Employee("4号", 35, 8000.0),
                new Employee("5号", 65, 1000.0)
        );
        Collections.sort(list,(e1,e2)->
            if (e1.getAge() == e2.getAge())
                return e1.getName().compareTo(e2.getName());
            else 
                return -Integer.compare(e1.getAge(),e2.getAge());
            
        );
        Iterator<Employee> iterator = list.iterator();
        while (iterator.hasNext())
            System.out.println(iterator.next());



3. 函数式接口

四大核心函数式接口

  1. Consumer<T>：消费型接口

    void accept(T t);

  2. Supplier<T>：供给型接口

    T get();

  3. Function(T,R)：函数型接口

    R apply(T t);

  4. Predicate<T>：断言型接口

    boolean test(T t);



例子

  1. Consumer<T>：消费型接口

    @Test
public void test()
    this.happy(1000,m -> 
        System.out.println("我消费了"+ m);
    );


public void happy(double money, Consumer<Double> con)
    con.accept(money);

  2. Supplier<T>：供给型接口

    @Test
public void test()
    List<Integer> numList = this.getNumList(5, () -> (int) (Math.random() * 100));
    for (Integer integer : numList) 
        System.out.println(integer);
    


//产生指定数量的整数
public List<Integer> getNumList(int num, Supplier<Integer> sup)
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < num; i++) 
        list.add(sup.get());
    
    return list;

  3. Function(T,R)：函数型接口

    @Test
public void test()
    System.out.println(this.handler("str", str -> (str + "123")));


//处理字符串
public String handler(String str, Function<String,String> fun)
    return fun.apply(str);

  4. Predicate<T>：断言型接口

    @Test
public void test()
    List<String> stringList = Arrays.asList("qwe", "123", "hello", "ranhaifeng", "asdasdsaewqewqe");
    List<String> list = filterStr(stringList, s -> (s.length() > 3));
    for (String s : list) 
        System.out.println(s);
    


//将满足条件的字符串放入集合
public List<String> filterStr(List<String> list, Predicate<String> pre)
    List<String> stringList = new ArrayList<>();
    for (String s : list) 
        if (pre.test(s))
            stringList.add(s);
        
    
    return stringList;


其他接口




4. 方法引用与构造器引用

方法引用

  1. 方法引用:若 Lambda 体中的内容有方法已经实现了，我们可以使用“方法引用”，可以理解为方法引用是Lambda表达式的另外一种表现形式。

  2. 主要有三种语法格式：

    • 对象::实例方法名
    • 类::静态方法名
    • 类::实例方法名

  3. 例子

        //对象::实例方法
    @Test
    public void test()
        Consumer<String> con = x -> 
            System.out.println(x);
        ; 
        PrintStream out = System.out;
        Consumer<String> con1 = out::println;
        Consumer<String> con2 = System.out::println;
        con2.accept("qwe");
     

    //类::静态方法名
    @Test
    public void test()
        int x;int y;
        Comparator<Integer> com = (x,y)-> Integer.compare(x,y);
        Comparator<Integer> com1 = Integer::compare;
    


    // 类::实例方法名
    @Test
    public void test()
        BiPredicate<String,String> bp = (x,y) -> x.equals(y);
        BiPredicate<String,String> bp2 = String::equals;

  4. 注意：

    • Lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！
    • 若Lambda参数列表中的第一参数是实例方法的调用者，第二个参数是实例方法的参数时，可以使用ClassName::method


构造器引用

  1. 例子

        @Test
    public void test()
        Supplier<Object> sup = () -> new Object();
        Supplier<Object> sup2 = Object::new;

        //如果有多个构造器，如何判断是调用的实体类的哪个构造器呢？看下面的注意，即Function（T,R）内部的函数 R apply(T t) 是1个参数，那么就会调用是1个参数的构造器。
        Function<Integer,Employee> fun2 =Employee::new;

  2. 注意：需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致！



数组引用

    @Test
    public void test()
        Function<Integer,String[]> fun = x -> new String[x];

        Function<Integer,String[]> fun2 = String[]::new;



5. Stream API

介绍

  1. Java8中有两大最为重要的改变。第一个是 Lambda 表达式;另外一个则是Stream API(java.util.stream.*)。Stream是 Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL执行的数据库查询。也可以使用Stream API来并行执行操作简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。
  2. 流(Stream)到底是什么呢?
    是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是致据遏进的是让算*”
    注意:
  3. 注意：
    • Stream 自己不会存储元素。
    • Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
    • Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。



5.1 创建

Stream的创建

    @Test
    public void test()
        //1.可以通过Collection系列集合提供的stream()或parallelstream()
        List<String> list = Arrays.asList("1", "2", "3");
        Stream<String> stream = list.stream();

        //2.通过Arrays中的静态方法stream（）获取数组流
        int [] arr = new int[10];
        IntStream stream1 = Arrays.stream(arr);

        //3.通过Stream类中的静态方法of()
        Stream<String> stream2 = Stream.of("1", "2", "3");

        //4.创建无限流
        //迭代
        Stream<Integer> stream3 = Stream.iterate(0, x -> x + 2);
        stream3.limit(10).forEach(System.out::println);

        //生成
        Stream.generate(() -> Math.random()).limit(5).forEach(System.out::println);


5.2 筛选与切片

Stream的筛选与切片

  1. 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理!而在终止操作时一次性全部处理,称为“惰性求值”。

  2. filter：接收Lambda，从流中排除某些元素

    public class test 
    @Test
    public void test()
        List<Person> people = Arrays.asList(
                new Person("张三", 18, 9999.99),
                new Person("李四", 58, 5555.55),
                new Person("王五", 26, 3333.33),
                new Person("赵六", 36, 6666.66),
                new Person("田七", 12, 8888.88)
        );

        //中间操作	
        Stream<Person> stream = people.stream().filter(person -> 
            System.out.println("中间操作");
            return person.getAge() > 5;
        );
        //终止操作
        stream.forEach(System.out::println);

  3. limit：截断流，使其元素不超过给定数量

    //中间操作
people.stream()
        .filter(person -> person.getScore() > 5000)
        .limit(1)
        .forEach(System.out::println);

  4. skip(n)：跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit互补

    //中间操作
people.stream()
        .skip(2)
        .forEach(System.out<
    以上是关于Java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我的主要内容，如果未能解决你的问题，请参考以下文章
     

     Java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我
    

     Java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我
    

     RabbitMQ！女朋友看了都会的超详细保姆级附源码笔记！看完还不会请砍我！
    

     RabbitMQ！女朋友看了都会的超详细保姆级附源码笔记！看完还不会请砍我！
    

     RabbitMQ！女朋友看了都会的超详细保姆级附源码笔记！看完还不会请砍我！
    

     RabbitMQ！女朋友看了都会的超详细保姆级附源码笔记！看完还不会请砍我！