Java8 特性

最新推荐文章于 2024-05-04 22:32:48 发布
最新推荐文章于 2024-05-04 22:32:48 发布
阅读量205 收藏 2
点赞数 2
分类专栏： North drift
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/china_songlei/article/details/80012848
版权
一：Lambda表达式
    理解：
        Lambda表达式相当于代替匿名内部类的，但要求：匿名内部类实现的接口中只有一个抽象方法  

    应用场景：
        Lambda表达式同匿名内部类的应用场景，一般作为接口的实例传递给方法
        直接做为接口的实例赋值给接口

    注意事项：
        ①参数类型可以省略
        ②如果Lambda体中只有一句话，则大括号也可以省略
        ③如果Lambda体中只有一句话而且是return语句，则return也可以省略
        ④如果只有一个参数，则小括号也可以省略

    @Test
    public void test2() {
        //匿名内部类
        Comparator<String> c1 = new Comparator<String>() {
            
            @Override
            public int compare(String o1, String o2) {
                System.out.println("");
                return o1.compareTo(o2);
            }
        };

        //Lambda
        
        Comparator<String> c2 = ( o1, o2)-> o1.compareTo(o2);
        
    }



二：函数式接口

    常用函数：
  1. * 消费型接口Consumer
  2. * 供给型接口Supplier
  3. * 函数型接口Function
  4. * 断定型接口Predicate

    //测试：消费型接口Consumer
    @Test
    public void test1() {
        Consumer<Integer> con2 = t->{
            if (t>1000) {
                System.out.println("吃大烤鸭");
            }else{
                System.out.println("吃肉夹馍");
            }
        };
        con2.accept(2000);
    }


    //测试供给型接口Supplier
    @Test
    public void test2() {
         Supplier <String> sup = ()->"john".toUpperCase();
        System.out.println(sup.get());

    }



    //测试函数型接口Function
    @Test
    public void test3() {
         Function <Double,Double> fun = d->Math.pow(d, 2);
        
        System.out.println(fun.apply(100d));
    }


    
    //测试断定型接口Predicate
    @Test
    public void test4() {
        
         Predicate <Employee> pre = e->e.getName().contains("a");
        
        System.out.println(pre.test(new Employee("john", 12, 1000, '女')));

    



三、各类引用
   
    1、方法引用
    理解：
        满足一定条件的Lambda表达式的代替，也是作为函数式接口的实例出现！
        方法引用仅仅是Lambda表达式的语法糖形式，提高语义性和阅读性
    

     要求：
        1、Lambda体中只有一句话
        2、仅有的这一句话为方法的调用
        3、调用的方法中的参数列表和返回 ，与实现的抽象方法的参数列表和返回一致！

        如果是类名调用普通方法，则要求：抽象方法的第一次参数为调用方法的调用者，其他参数类型一致！

    //测试形式1：对象::普通方法
    @Test
    public void test1() {
        //使用Lambda表达式
        Consumer<String> con = s->System.out.println(s);
        
        //使用方法引用
        
        Consumer<String> con2 = System.out::println;
        con2.accept("hello");

    }


    //测试形式2:类::静态方法
    
    @Test
    public void test2() {
        
        //使用Lambda表达式
        Comparator<Integer> com1 = (i1,i2)->Integer.compare(i1, i2);
        Comparator<Double> com3 = (i1,i2)->Double.compare(i1, i2);
        
        //使用方法引用
        Comparator<Integer> com2 = Integer::compare;
        Comparator<Double> com4 = Double::compare;

    }


    //测试形式3：类::普通方法
    @Test
    public void test3() {
        
        //使用匿名内部类
        Comparator<String> com1 = new Comparator<String>(){

            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
            
        };
        
        //使用Lambda表达式
        Comparator<String> com2 = (o1,o2)->o1.compareTo(o2);
                 
        //使用方法引用
        Comparator<String> com3 = String::compareTo;

    }


    2、构造器引用
     理解：
        构造器引用 相当于对满足一定条件的Lambda表达式的简化

    条件：
        1、Lambda体中仅仅只有一句话
        2、Lambda体中仅有的一句话为通过调用构造器创建对象
        3、构造器的参数列表和抽象方法的参数列表保持一致。抽象方法的返回类型正好为该对象的类型！

    
    //案例1：String s = new String();
    @Test
    public void test1() {
        //使用匿名内部类
        Supplier<String> sup1 = new Supplier<String>(){

            @Override
            public String get() {
                return new String();
            }
            
        };
        
        //使用构造器引用
        Supplier<String> sup2 = String::new;

    }

    //案例2：String s = new String("hello");
    @Test
    public void test2() {
        //使用匿名内部类
        Function<String,String> fun1 = new Function<String,String>(){

            @Override
            public String apply(String t) {
                return new String(t);
            }
            
        };
        
        //使用构造器引用
        
        Function<String,String> fun2 = String::new;
        
    }


    //案例3： Employee emp = new Employee(String name, int age, double salary, char sex);
    @Test
    public void test3() {
        
        //使用匿名内部类
        A<String,Integer,Double,Character,Employee> a = new A<String,Integer,Double,Character,Employee>(){

            @Override
            public Employee method(String t, Integer r, Double m, Character u) {
                return new Employee(t,r,m,u);
            }
            
        };
        
        //使用构造器引用
        
        A<String,Integer,Double,Character,Employee> b = Employee::new;

    }
    interface A<T,R,M,U,V>{
        V method(T t,R r,M m,U u);
    }


    3、 数组引用
    理解：
        数组引用相当于满足一定条件的Lambda表达式的代替，也是作为函数式接口的实例出现

    要求：
        1、Lambda体中仅仅只有一句话
        2、仅有的一句话为创建数组对象
        3：抽象方法的参数类型为数组的长度类型，返回类型为创建的数组类型

    //案例1：return new String[5];    
    /*
     * 返回类型：String[]
     * 参数类型:Integer
     */
    @Test
    public void test1() {
        //使用匿名内部类
        Function<Integer,String[]> fun1 =  new Function<Integer,String[]>(){

            @Override
            public String[] apply(Integer t) {
                return new String[t];
            }
            
        };
        
        //使用数组引用
        
        Function<Integer,String[]> fun2 = String[]::new;

    }



    //案例2：return new StringBuffer[6];
    @Test
    public void test2() {
        Function<Integer,StringBuffer[]> fun = StringBuffer[]::new;
        
    }



四，Stream API

注意：
    1、分为三部进行执行，如果不执行最后的最后一步终止前面则不会执行
    2、Stream为“一次性消费”，即创建一次只能是使用一次。



    1、开始操作（创建Stream对象指向一个具体的数据源）
        此类用于演示Stream的开始操作：
            方式一：根据集合获取Stream对象  （数据源：集合）
            方式二：根据数组获取Stream对象  (数据源：数组)
            方式三：根据一组序列值获取Stream对象（数据源：一组值）
            方式四：创建无限流，根据一个规则获取Stream对象（数据源：自定义规则）

    //方式一：根据集合获取Stream对象  （数据源：集合） ★
    @Test
    public void test1() {
        
        List<Employee> list = EmployeeData.getEmployees();
        //获取串行流对象
        Stream<Employee> stream = list.stream();
        
        //获取并行流对象
        Stream<Employee> parallelStream = list.parallelStream();
        
        //终止操作
        //使用匿名内部类：
//        stream.forEach(new Consumer<Employee>(){
//
//            @Override
//            public void accept(Employee t) {
//                System.out.println(t);
//            }
//            
//        });
        
        //使用Lambda表达式:
        
//        stream.forEach(t->System.out.println(t));
        
        //使用方法引用：
        
        stream.forEach(System.out::println);

    }

    //方式二：根据数组获取Stream对象  (数据源：数组)
    @Test
    public void test2() {
        
        String[] arr = {"john","lucy","lily"};
//        Stream<String> stream = Arrays.stream(arr);
//        
//        stream.forEach(System.out::println);
        
        Arrays.stream(arr).forEach(System.out::println);

    }

    // 方式三：根据一组序列值获取Stream对象（数据源：一组值）
    @Test
    public void test3() {
        
        Stream<Character> of = Stream.of('a','b','c','d');
        
        of.forEach(System.out::println);

    }

    //方式四：生成无限流
    @Test
    public void test4() {
        //匿名内部类
//        Stream<Double> generate = Stream.generate(new Supplier<Double>(){
//
//            @Override
//            public Double get() {
//                return Math.random();
//            }
//            
//        });
//        
        //Lambda
//        Stream<Double> generate2 = Stream.generate(()->Math.random());
        
        //方法引用
        
        Stream<Double> generate3 =  Stream.generate(Math::random);
        
        generate3.forEach(System.out::println);

    }


     2 、 Stream的中间操作
        *中间操作可以形成流水线操作
        
    常见方法：
        filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        limit(n)——截断流，使其元素不超过给定数量。
        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        map(Function<元素类型,R>)——映射，根据元素本身一一映射成新的元素
        flatMap(Function<元素类型,Stream>)——映射
        sorted()——自然排序
        sorted(Comparator)——定制排序

    List<Employee> list;
    @Before
    public void before(){
         list = EmployeeData.getEmployees();
    }



    //筛选与切片
    @Test
    public void test1() {
        
        //1.获取Stream对象
        Stream<Employee> stream = list.stream();
        
        //2.中间操作
        //filter：根据条件过滤
//        Stream<Employee> filter = stream.filter(t->t.getAge()>30);
        //limit:用于限制最大元素个数
//        Stream<Employee> limit = stream.limit(50);
        //skip:跳过指定的个数
//        Stream<Employee> skip = stream.skip(3);
        //distinct:去重
        Stream<Employee> distinct = stream.distinct();

        //3.终止操作
        distinct.forEach(System.out::println);

    }

    //测试：映射
    @Test
    public void test2() {
        
        //1.获取Stream对象
        Stream<Employee> stream = list.stream();
        
        //2.中间操作
        //map:映射
//        Stream<String> map = stream.map(new Function<Employee,String>(){
//
//            @Override
//            public String apply(Employee t) {
//                return t.getName();
//            }});
        
//        Stream<String> map = stream.map(Employee::getName);
        
        //flatMap:映射
        //使用匿名内部类：
//        stream.flatMap(new Function<Employee,Stream<Object>>(){
//
//            @Override
//            public Stream<Object> apply(Employee t) {
//                return TestStreamMiddle.employeeToStream(t);
//            }
//            
//        });
        
        //使用方法引用
        
        Stream<Object> flatMap = stream.map(TestStreamMiddle::employeeToStream);
        
        //3.终止操作
        
        flatMap.forEach(System.out::println);

    }

    //测试排序
    @Test
    public void test3() {

        //1.获取stream对象
        Stream<Employee> stream = list.stream();
        
        //2.中间操作
        
        //sorted（）:根据元素本身的比较性实现自然排序
        
//        Stream<Employee> sorted = stream.sorted();
        //sorted(comparator):根据比较器实现定制排序
        
        //进阶1：使用匿名内部类
//        stream.sorted(new Comparator<Employee>(){
//
//            @Override
//            public int compare(Employee o1, Employee o2) {
//                return Double.compare(o2.getSalary(), o1.getSalary());
//            }
//            
//        });
        //进阶2：使用Lambda
        
        Stream<Employee> sorted2 = stream.sorted((o1,o2)->Double.compare(o2.getSalary(), o1.getSalary()));
        
        
        
        //3.终止操作
        
        sorted2.forEach(System.out::println);
    }
    //自定义规则实现：将员工转换成Stream类型
    public static Stream<Object> employeeToStream(Employee e){
        Stream<Object> of = Stream.of(e.getName(),e.getAge(),e.getSalary(),e.getSex());
        return of;
    }


    3、Stream的终止操作
        常见方法：
            count:统计个数
            max(Comparator):求最大值
            min(Comparator):求最小值
            forEach（Consumer）:内部迭代
            reduce(BinaryOperator<T>):归约、合并


    List<Employee> list;
    @Before
    public void before(){
         list = EmployeeData.getEmployees();
    }


    //测试：count  统计Stream中的元素个数
    @Test
    public void test1() {
        //1.获取stream对象
        Stream<Employee> stream = list.stream();
        
        //2.终止操作
        
        long count = stream.count();
        System.out.println(count);

    }

    //测试：max/min  获取Stream中的最大值或最小值
    @Test
    public void test2() {
        //1.获取stream对象
        Stream<Employee> stream = list.stream();
        
        //2.终止操作
        
//        Optional<Employee> max = stream.max((e1,e2)->Integer.compare(e1.getAge(), e2.getAge()));
        Optional<Employee> min = stream.min((e1,e2)->Integer.compare(e1.getAge(), e2.getAge()));
        
        System.out.println(min);

    }

    //测试：forEach 获取Stream中的内部迭代
    @Test
    public void test3() {
        //1.获取stream对象
        Stream<Employee> stream = list.stream();
        
        //2.终止操作
        stream.forEach(System.out::println);
        
    }

    //测试：reduce 归约，合并
    @Test
    public void test4() {
        //1.获取stream对象
        Stream<Employee> stream = list.stream();
        
        //2.终止操作
        /*
         * BinaryOperator:
         * T apply(T t1,T t2);
         */
        
        //进阶1：匿名内部类：
//        stream.reduce(new BinaryOperator<Employee>(){
//
//            @Override
//            public Employee apply(Employee t, Employee u) {
//                return null;
//            }
//            
//        });
        Stream<Double> map = stream.map(e->e.getSalary());
                
        
        Optional<Double> reduce = map.reduce((t,u)->t+u);
        System.out.println(reduce);
        
    }



五：Optional类
    主要是为了减少空指针异常



































china_songlei
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java如何根据属性名这个字符串创建SFunction ---结合了我自己的项目来说的
m0_59084856的博客
05-04 890
比如我有一个Person类 里面有name属性 我怎么根据name这个字符串和Person这个class 获取SFunction
java new function_Java 8 新特性:3-函数（Function）接口
weixin_39881575的博客
02-16 746
(原)以前，在创建泛型时，是这么写的：List list = new ArrayList();现在，可以这么写了：List list = new ArrayList<>();在java8中，这种写法被叫作diamond语法，有些书里叫他钻石语法，有些则称之为菱形语法，说的就是这种语法。看下面的例子：package com.demo.jdk8;import java.util.Arr...
java new function_function,new function()和 new Function()
weixin_29648175的博客
02-13 797
函数是javascrpit中的一等公民，提供了function关键字和Function()这个内置对象。function和new function()以及new Function()之间的区别一直都会让人造成困扰，下面是一些简单的学习心得。function最常用的function用法就是定义函数var foo = function(){var temp = 100;this.temp = 200;...
java new function_java – 创建一个接受可变长度的Function参数的方法,该参数可能有不同的类型...
weixin_36032446的博客
02-16 696
这样一个函数的问题是你必须松开所有编译时类型检查和转换.这将是一个实现,使用和然后将功能组合在一起.由于所有的铸造,这看起来很丑陋,我不确定你能做得更好.另请注意,当只需要1时,这需要创建2个流管道.public static void main(String[] args) throws Exception {String str = "1,2,3,4,5,6";Function splitBy...
Java8之Function接口
大鹏小站的博客
10-14 1万+
Java8 添加了一个新的特性Function，是一个函数式接口 所有标注了@FunctionalInterface注解的接口都是函数式接口，具体来说，所有标注了该注解的接口都将能用在lambda表达式上。 先看源码 @FunctionalInterface public interface Function<T, R> { R apply(T t); /** ...
Java 中函数 Function 的使用和定义
qq_58417838的博客
12-25 4267
UnaryOperator 单个泛型的函数。
java 8 特性
11-28
Java 8 是一个里程碑式的版本，它引入了一系列重要的新特性，极大地提升了开发效率和代码的简洁性。在本文中，我们将深入探讨其中的关键变化，包括Lambda表达式、函数式接口、Stream API、日期与时间API以及方法引用...
Java8特性从入门到精通
10-10
### Java8特性从入门到精通 #### 一、Lambda 表达式详解 Java8的发布标志着Java语言向函数式编程迈进了一大步。在Java8之前，虽然可以通过匿名内部类等方式来模拟函数式编程的一些特性，但这些方法在代码的可读性...
java和java8特性功能
08-28
Java8是其发展历程中的一个重要里程碑，引入了许多创新特性和功能，极大地提升了开发效率和代码质量。本篇文章将深入探讨Java及其在Java8版本中引入的关键特性。 1. **基础特性** - **面向对象**：Java是一种纯...
java8如何根据属性名这个字符串创建SFunction
最新发布
m0_59084856的博客
05-04 430
比如我有一个Person类 里面有name属性 我怎么根据name这个字符串和Person这个class 获取SFunction。
java8的function,Java8 Function 用法简介
weixin_36356002的博客
03-14 1822
Java8 Function 用法简介FunctionTestimport java.util.function.Function;/*** 执行结果是输出: 2/4* * 解析：* * 1. Function test ，相当于一个待实现的接口，告诉你入参是 Numbers 类型 (上例子中是一个自定义的实体类)，出参是Integer 类型。然后业务逻辑是怎样，可以自己实现。* * 2. Fu...
2007-12-12公映的《色即是空2》（sex is zero 2）字幕文件
weixin_30732825的博客
03-06 6247
/Files/thinhunan/sjsk2.rar 转载于:https://www.cnblogs.com/think/archive/2008/03/06/1094263.html
Java 8 新特性-Function函数式接口
热门推荐
小白的博客
03-19 3万+
说明java.util.function包是Java 8增加的一个新技术点"函数式接口"，此包共有43个接口。这些接口是为了使Lamdba函数表达式使用的更加简便，当然你也可以自己自定义接口来应用于Lambda函数表达式。Lambda是Java 8 的最大特点，本文对此并没有进行详解。本文还应用了Java 8的另一个特点“引用方法”(引用方法是用的冒号“::”来进行方法的调用)，有兴趣的Frien...
Java中new function另外新建个文件的写法
微电子学与固体电子学-俞驰
08-01 560
Flink官网看到这么个例子: DataSet<WC> words = // [...] DataSet<WC> wordCounts = words // DataSet grouping on field "word" .groupBy("word") // apply ReduceFunction on grouped Dat
Jdk8新特性三：jdk8之函数式编程Function
公子&小白的博客
02-17 4258
Jdk8新特性三：jdk8之函数式编程Function 文章目录Jdk8新特性三：jdk8之函数式编程FunctionFunction接口的使用BiFunction接口解决传入两个参数问题JDK8函数式编程消费型接口Consumer\Function接口的使用 Lambda表达式必须先定义接口，创建相关方法后才能使用，这样弄十分不便，干脆开发者就直接内置了接口，所有标注@FunctionalIn...
new function()理解
Dream_Lee的博客
09-06 5191
好久没更新啦~ 一、背景 朋友给我发了一个题，我的答案和正确答案刚好相反。惊！ 正确答案是：false和true 接下来我讲一下我对这道题所涉及的知识点的理解 说明： 只要 new 表达式之后的 constructor 返回（return）一个引用对象（数组，对象，函数等），都将覆盖new创建的匿名对象。 如果返回（return）一个原始类型（无 return 时其实为 return 原始类型...
JAVA8 Function及Stream编程
blacksoil55的博客
10-26 6253
JAVA8引入函数式编程后，增加了灵活性，原来需要通过ScriptEngine调用脚本语言，现在通过Function接口即可。 方便了编码，代码也比较简洁些。 1. Function     函数式编程的格式如下集中方式：     a. 标准方式     (Type1 param1, Type2 param2, ..., TypeN paramN) -> {     statment1
Java 8特性详解：从Lambda到日期API
本文档将汇总所有主要的Java 8特性，以供读者参考和学习。 一、新语言特性 1. **Lambda表达式和函数接口** (Lambdas and Functional Interfaces) Java 8引入了lambda表达式，它简化了对匿名函数的处理，使得代码更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值