java 8 新特性学习

文章目录

前言一、Lambda 是什么？二、基本语法三、自己练习深刻理解使用四、java 8 四大内置核心函数式接口

`Consumer` 消费型接口`Supplier` 供给型接口主要方法 T get();`Predicate` 段言型接口用于做判断操作的主要方法 boolean test(T t);函数型接口主要方法 R apply(T t); 总结五、java 8 新特性方法引用与构造器引用六、java 8 新特性 Stream API

1. Stream API 描述2. 流(Stream)到底是什么呢？3. Stream 操作的三个步骤

前言

优化简洁的开发Java 8新特性 Lambda 表达式

一、Lambda 是什么？

Lambda 是Jdk 1.8 的一种新特性。
优点:

速度更快代码更少强大的 Stream API便于并行最大减少空指针异常 Optical 二、基本语法

		//1.无参无返回Lambda 表达式
        Runnable run = () -> System.out.println("Hello Lambda");
        run.run();
        //2.有一个参数无返回值 Lambda 表达式语法 无返回值可以去掉大括号
        Consumer consumer = e -> System.out.println(e);
        consumer.accept("Hello Lambda!");
        //有参数有返回值 Lambda 表达式语法 多条语句操作
        Comparator comparator = (x, y) -> {
            System.out.printf("函数式接口!");
            return Integer.compare(x,y);
        };
        comparator.compare(0,1);
        //3.有参数有返回值 Lambda 表达式语法 只有一条语句的话 返回和大括号都可以去掉
		//Lambda 表达式参数列表的数据类型可以不要写，因为JVM 根据编译器可以推断出来
        Comparator comparator1 = (x, y) -> Integer.compare(x,y);
        comparator1.compare(0,1);

        //Lambda 需要函数式接口的支持 函数式接口? 函数式接口是只有一个抽象方法的接口
        //使用注解 @FunctionalInterface 修饰指定是函数方法
        //使用函数式接口实现运算
        System.out.println(operation(100,(x)-> x + 900));
        
		public Integer operation(Integer num,MyFun myFun){
		    return myFun.getValue(num);
		}

三、自己练习深刻理解使用

	List employees = Arrays.asList(new Employee(1,30,4444.00,"小强")
    ,new Employee(2,16,9999.00,"小唐")
    ,new Employee(3,18,7777.00,"小李")
    ,new Employee(4,14,6666.00,"小心")
    ,new Employee(5,26,5555.00,"比尔鸭"));

    
    @Test
    public void LambdaSort(){
        Collections.sort(employees,(x,y)->{
            if (x.getAge()==y.getAge()) {
                return x.getName().compareTo(y.getName());
            }else {
                return - x.getAge().compareTo(y.getAge());
            }
        });
        for (Employee emp: employees) {
            System.out.println(emp);
        }
    }
    ![定制排序先按年龄比，年龄相同按姓名比结果](https://img-blog.csdnimg.cn/af91bbbfd530460eb8317c422438c82b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaWRlYeS4tg==,size_20,color_FFFFFF,t_70,g_se,x_16)
    
    @Test
    public void strHandlerTest(){
        //去除空格
        System.out.println(strHandler("ttt小",(str)-> str.trim()));
        //转换大写 一个参数一个返回可以省去括号
        System.out.println(strHandler("abcdefg",str -> str.toUpperCase(Locale.ROOT)));
        //转换小写
        System.out.println(strHandler("ABCDEFG",str -> str.toLowerCase(Locale.ROOT)));
        //截取
        System.out.println(strHandler("ABCDEFG",str -> str.substring(0,4)));
    }

    
    public String strHandler(String str,MyFunction myFunction){
        return myFunction.getValue(str);
    }
        
    @Test
    public void opCalculation(){
        //加
        op(100L,200L,(x,y)->x+y);
        //减
        op(100L,200L,(x,y)->x-y);
        //乘
        op(100L,200L,(x,y)->x*y);
    }
    
    public void op(Long l1,Long l2,MyFunction1 myFunction){
        System.out.println(myFunction.getValue(l1,l2));
    }

四、java 8 四大内置核心函数式接口 Consumer 消费型接口

    
    @Test
    public void happyTest(){
        happy(2000.00,m-> System.out.println("今天我买了个Switch花了"+m+"元"));
    }
    
    public void happy(Double money,Consumer consumer){
        consumer.accept(money);
    }

Supplier 供给型接口主要方法 T get();

 
    @Test
    public void numListTest(){
        List numList = getNumList(10,()->(int)(Math.random() * 100));
        for (Integer num: numList){
            System.out.println(num);
        }
    }
    
    public List getNumList(Integer num,Supplier supplier){
        List numList = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            numList.add(supplier.get());
        }
        return numList;
    }

Predicate 段言型接口用于做判断操作的主要方法 boolean test(T t);

    
    @Test
    public void nameLengthCheckTest(){
        List nameList = nameLengthCheck(employees,(x)->x.getName().length()<3);
        for (Employee employee:nameList) {
            System.out.println(employee);
        }
    }
    
    public List nameLengthCheck(List employees,Predicate predicate{
        List nameList = new ArrayList<>();
        for (Employee emp:employees){
            if (predicate.test(emp)){
                nameList.add(emp);
            }
        }
        return nameList;
    }

函数型接口主要方法 R apply(T t);

    
    @Test
    public void strHandlerTests(){
        //去除空格
        System.out.println(strHandlers("ttt小",(str)-> str.trim()));
        //转换大写 一个参数一个返回可以省去括号
        System.out.println(strHandlers("abcdefg",str -> str.toUpperCase(Locale.ROOT)));
        //转换小写
        System.out.println(strHandlers("ABCDEFG",str -> str.toLowerCase(Locale.ROOT)));
        //截取
        System.out.println(strHandlers("ABCDEFG",str -> str.substring(0,4)));
    }
    
    public String strHandlers(String str,Function function){
        return function.apply(str);
    }

总结

左右遇一括号省
左侧推断类型省
能省则省

五、java 8 新特性方法引用与构造器引用

方法引用:若方法体中的内容已经有方法实现了，那么我们可以使用方法引用

 	
    @Test
    public void test1(){
        
        //语法1: 对象::实例方法名
        PrintStream printStream = System.out;
        Consumer consumer = printStream::println;
        consumer.accept("对象::实例方法名");
        //语法2: 类::静态方法名
        Comparator comparator = Integer::compare;
        //语法3: 类::实例方法名
        BiPredicate predicate =String::equals;
        System.out.println(predicate.test("小","小"));
        
        Supplier supplier = Employee::new;
        System.out.println(supplier.get());
        //自定义函数式接口
        MyFunction2 myFunction2 = Employee::new;
        
        Function function = String[]::new;
        System.out.println(function.apply(20).length);
    }

六、java 8 新特性 Stream API 1. Stream API 描述

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是StreamAPI(java.util.stream.*)。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对、集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

2. 流(Stream)到底是什么呢？

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据，流讲的是计算！”

注意：
①Stream 自己不会存储光素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

3. Stream 操作的三个步骤

1.创建 Stream
一个数据源（如：集合、数组），获取一个流
2.中间操作
一个中间操作链，对数据源的数据进行处理•终止操作(终端操作)
3.终止操作
一个终止操作，执行中间操作链，并产生结果

	
    // 通过 Collection 系列集合创建
    List list = new ArrayList<>();
    Stream stream1 = list.stream();
    // 通过Arrays 创建数组流
    String[] strings = new  String[10] ;
    Stream stream2 = Arrays.stream(strings);
    // 通过 Stream 的of()方法 创建流
    Stream> stream3 = Stream.of(list);
    //创建无限流
    //迭代
    Stream stream4 =  Stream.iterate(0,(x)->x+2);
    stream4.limit(10).forEach(System.out::println);
    //生成
    Stream.generate(()->employees).limit(5).forEach(System.out::println);

java 8 新特性学习

Java相关栏目本月热门文章