Java之Lambda表达式

最新推荐文章于 2024-01-06 18:10:43 发布
最新推荐文章于 2024-01-06 18:10:43 发布
阅读量953 收藏 7
点赞数 4
分类专栏： Java复习 Java+大数据之旅 文章标签： java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llAl_lAll/article/details/120164889
版权

🍤Lambda表达式

一、Lambda表达式练习
1、题目一:调用Collections.sort()方法,通过定值排序比较两个Employee(先按年龄比,年龄相同按姓名比),使用Lambda作为参数传递

分析:

  1. 定制排序:指自定义比较器|定制排序
    自然排序:内部比较器|自然排序
  2. 先比较年龄,年龄相同才比较姓名
public class Lambda02 {
    public static void main(String[] args) {
        List<Emp> ls=new ArrayList<>();
        ls.add(new Emp(20,"张三"));
        ls.add(new Emp(18,"李四"));
        ls.add(new Emp(18,"小明"));
        ls.add(new Emp(19,"王五"));
        Collections.sort(ls,(x,y)->{
            if(x.getAge()==y.getAge()){
                return x.getName().compareTo(y.getName());
            }
            return x.getAge()-y.getAge();
        });
        System.out.println(ls);
    }
}

class Emp{
    public Emp() {
    }

    @Override
    public String toString() {
        return "Emp{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Emp(int age, String name) {
        this.age = age;
        this.name = name;
    }
    private int age;
    private String name;
}
2、题目二:
  1. 声明函数式接口,接口中声明抽象方法,public String getValue(String str)
  2. 声明类 TestLambda,类中编写方法使用接口作为参数,讲一个字符串转成大写,并作为方法的返回值
  3. 再将一个字符串的第2个和第4个索引位置进行截取子串
public class Lambda03 {
    public static void main(String[] args) {
        String uu=StringMethod("sertishdjscds",(x)->{
           //return x.toUpperCase();
          return x.substring(2,4);
        });
        System.out.println(uu);
    }
    public static String StringMethod(String s,Stringss ss){
        return ss.getValue(s);
    }
}
interface Stringss{
    String getValue(String str);
}
3、题目三
  1. 声明一个带两个泛型的函数式接口,发型类型为<T,R> T为参数,R为返回值。
  2. 接口中声明对应抽象方法。
  3. 在TestLambda类中声明方法,参数三个,两个long类型的参数,接口作为参数,接口实现中计算两个long型参数的和。
  4. 再计算两个long型参数的乘积。
public class Lambda04 {
    public static void main(String[] args) {
        long num=toSum(1000L,500L,(x,y)->{
            return x+y;
        });
        System.out.println(num);
        TestLam<Long,Long> tl=new TestLam<Long, Long>() {
            @Override
            public Long sum(Long x, Long y) {
                return null;
            }
        };

    }
    public static long toSum(long l1,long l2,TestLam<Long,Long> tl){
        return tl.sum(l1,l2);
    }
}
interface TestLam<R,U>{
    U sum(R x,R y);
}
二、JDK提供的四大函数接口

代码演示：

public class Lambda001 {
    public static void main(String[] args) {
        //消费性
        shop(1000,(monery)->{
            System.out.println("冲游戏皮肤花费："+monery);
        });
        //函数型
        System.out.println(Fun(2, num -> num << 2));
        //段言型
        System.out.println(isTrue(10, num -> {
            if (num >= 10) {
                return true;
            }
            return false;
        }));
        //供给型
        System.out.println(get(() -> {
            return (int) (Math.random() * 10 + 1);
        }));
    }
    //消费型
    public static void shop(int x, Consumer<Integer> con){
        con.accept(x);
    }
    //函数xing
    public static int Fun(int num, Function<Integer,Integer> sum){
        return sum.apply(num);
    }
    //段言型
    public static boolean isTrue(int i, Predicate<Integer> pi){
       return pi.test(i);
    }
    //供给型
    public static int get(Supplier<Integer> sup){
        return sup.get();
    }
}
三、方法引用

  • 方法引用就是对Lambda表达式的简化

    要求:1)lambda体的实现,是通过调用|引用另外一个方法实现的
   2)引用的方法的参数列表与返回值要求与要重写的抽象方法的参数列表与返回值保持一致,自动匹配
   3)如果返回值匹配,但是参数列表不完全匹配,可以考虑是否满足第三种情况: 使用 类名::成员方法名 简化
      如果参数列表只有一个,这个参数作为内部调用方法的对象存在
      如果参数列表存在多个,第一个参数作为内部调用方法的对象,第二个参数开始自动匹配内部所引用方法的参数列表

  • 使用方式:

    • 对象::成员方法名 :(对象真实存在)

    • 类名::静态方法名

    • 类名::成员方法名 :( 对象自动匹配,对象是lambda的参数提供的)

① 、对象：：成员方法名

public class Lambda002 {
    public static void main(String[] args) {
        print();
    }
    public static void print(){
        //平时写法
//        Consumer<Integer> con=new Consumer() {
//            @Override
//            public void accept(Object o) {
//
//            }
//        };
        //简化
        Consumer c=x->{
            System.out.println(x);
        };
        //println是PringStream的成员方法
        PrintStream p=System.out;
        Consumer cj=x->{
            p.println(x);
        };
        cj=p::println;
        cj.accept("niubi");
        c.accept("好家伙");
        
        List<Integer> li= Arrays.asList(1,2,3,4,5);
        li.forEach(System.out::print);
    }
}

②、类名：：静态方法名

public class Lambda003 {
    public static void main(String[] args) {
        max();
    }
    public static void max(){
        BiFunction<Integer,Integer,Integer> bi=new BiFunction<>() {
            @Override
            public Integer apply(Integer o1, Integer o2) {
                return Math.max(o1,o2);
            }
        };
        //简化
        bi=(x,y)->{return Math.max(x,y);};
        System.out.println(bi.apply(100,300));
        //再次简化
        bi=Math::max;
        System.out.println(bi.apply(100,500));
    }
}

③、类名：：成员方法

public class Lambda004 {
    public static void main(String[] args) {
        test();
    }
    public static void  test(){
        BiPredicate<String,String> bs=new BiPredicate<String, String>() {
            @Override
            public boolean test(String s, String s2) {
                return s.equals(s2);
            }
        };
        System.out.println(bs.test("abc", "abc"));//true

        //简化
        bs=(x,y)->{
          return x.equals(y) ;
        };
        System.out.println(bs.test("iii", "iii"));//true
        //简化
        bs=String::equals;
        System.out.println(bs.test("1234", "123"));//false
    }
}
四、构造器引用
  • 数据类型::new
  • 要求: lambda参数列表与构造器的参数列表保持一致
public class Lambda005 {
    public static void main(String[] args) {
        //构造器引用
        demo();
    }
    public static void demo(){
        Function<String,String> fs=new Function<String, String>() {
            @Override
            public String apply(String s) {
                return new String(s);
            }
        };
        System.out.println(fs.apply("xiaoxiaoxiao"));
        //简化
        fs=(x)->{return new String(x);};
        fs.apply("abcdefg");
        //简化
        fs=x->new String(x);
        fs.apply("小明");
        //简化
        fs=String::new;
        fs.apply("完！！！！");
    }

}
五、 数组引用
  • 类型::new
 //数组 引用
        Function<Integer,int[]> sup2 = (i)->new int[i];
        sup2 = int[]::new;
        System.out.println(sup2.apply(3));
        System.out.println(Arrays.toString(sup2.apply(3)));
六、JDK8之后提供的Stream API 
Stream :
    数据的渠道,用来操作由数据源(数组,集合)产生元素序列
    数组|集合关注数据的存储,Stream关注的是对数据的计算

特点:
    1.Stream本身不能存储数据
    2.Stream不会修改原对象|数据源中的数据,在每次进行流式操作后会返回一个持有结果的新的流
    3.惰性加载|延迟执行: 在进行stream操作时候不会马上执行,会在获取结果时一起执行
    4.流式一次性的流,流是不能重复使用,因为这个流已经被使用消费了

创建流:
    1. Collection中的成员stream()
    2. Arrays.stream(数组)
    3.Stream.of(数据)

代码演示；

public class Stream001 {
    public static void main(String[] args) {
        // 1. Collection中的成员stream()
        List<Integer> list=List.of(1,2,3,4,5,6);
        Stream<Integer> st=list.stream();
        System.out.println(list.parallelStream());
        //2. Arrays.stream(数组)
        String[] arr={"111","222","333"};
        Stream st1= Arrays.stream(arr);
        System.out.println(st1);
        //3.Stream.of(数据)
        Stream<String> ss=Stream.of("123","234","456");
        System.out.println(ss);
    }
}

在这里插入图片描述

**使用Stream的过程:**
1.获取流
2.一系列流式的中间操作 (返回持有结果的新的流)
3.终止行为(返回真实结果)

中间操作 : 筛选与切片
    filter: 过滤
    limit：限制从流中获得前n个数据
    distinct：去重
    skip：跳过前n个数据

代码演示：

public class Class002_Stream {
    public static void main(String[] args) {
        List<Employee> list = List.of(
                new Employee(1001,"zhangsan",18,20000),
                new Employee(1002,"lisi",25,18000),
                new Employee(1003,"wangwu",30,15000),
                new Employee(1004,"zhaoliu",28,10000),
                new Employee(1004,"zhaoliu2",28,10000),
                new Employee(1004,"zhaoliu",28,10000)
        );
        //1.获取流
        Stream<Employee> stream = list.stream();

        //2.中间操作
        stream = stream.filter(employee ->employee.getAge()>18)
              .distinct()/*要求重写hashCode与equals*/
              .limit(3)
              .skip(1);

        //3.终止行为
        stream.forEach(System.out::println);
    }
}

在这里插入图片描述

每日小新
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java Lambda表达式
永远不会懂
06-13 447
前言 随着函数式编程的流程，Java8中也引入了函数式编程风格（Lambda表达式）。Lambda表达式允许我们将行为传递到函数中，其可以替换匿名内部类实现的繁琐的代码。下面就是一个最经典的例子，用普通的匿名内部类一共用了6行代码，使用Lambda表达式只需要1行代码即可。也就是说，Lambda表达式在经常使用内部类情况下，可以大大的减少代码量，还有就是Lambda表达式经常和Stream AP...
Java Lambda 表达式
千里之行始于足下
05-30 949
– Start 函数式编程需要永达大量的函数，这些函数往往非常简答，如果每个函数都需要定义类去实现函数接口，编程体验会非常糟糕，为此 Java 引入了 Lamda 表达式来定义匿名函数，下面是一些简单的例子。 package shangbo.functional.demo4; import java.util.function.BiFunction; import java.util.funct...
Java Lanmbda表达式练习题
weixin_41712089的博客
11-12 1394
1、Java 8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口（只包含一个抽象方法的接口 ）。 请观察如下代码，并使用Lambda表达式改写，实现相同的效果。 // 使用匿名内部类的方式实现多线程 Runnable runnable1 = new Runnable() { public void run() { ...
Java 8 Lambda 表达式
东子的博客 细节决定成败，点滴铸就辉煌。
03-15 737
1.Lambda 表达式Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用 Lambda 表达式可以使代码变的更加简洁紧凑。2.语法lambda 表达式的语法格式如下：(parameters) -> expression 或 (parameters) ->{ statements; }3
Java Lambda 表达式 (小白看过来,大佬绕道!)
Candyz7的博客
08-08 526
由于我们知道函数式接口只有一个方法，因此在将其作为参数传递时不需要定义该方法的名称。例如，我们有一个数据流（在我们的例子中是一个字符串列表），每个字符串是省市名和地区名的组合。在这篇文章，我们将学习 Lambda 表达式以及 Lambda 表达式与函数式接口的使用，泛型函数式接口，并演示流式传输 API。相反，它用于实现由函数式接口定义的方法。Lambda 表达式是在 Java 8 中首次引入的，它的主要目的是提高编程语言的表达能力，简化冗余代码。到现在为止，我们使用的是只接受一种类型的值的函数式接口。..
【Java8】常用lambda表达式
daohangtaiqian的博客
08-03 940
常用lambda表达式。
Java8之lambda表达式基本语法
08-29
本文通过示例大家给大家介绍了java8之lambda表达式的基本语法，感兴趣的的朋友一起看看吧
Java的lambda表达式实现解析
08-30
主要为大家详细介绍了Java的lamda表达式实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java 8 lambda表达式
06-27
java lambda表达式,lambda 表达式基本上表达了函数式接口的实例（具有单一抽象方法的接口称为函数式接口。一个例子是 java.lang.Runnable）。lambda 表达式实现了唯一的抽象函数，因此实现了函数式接口 lambda ...
Java8新特性练习.zip
07-08
这个文件是关于Java8新特性的文件，里面包含了lambda表达式，代替了匿名内部类，它简化了代码，但不是匿名内部类的代码糖， 其中包含了lambda表达式的无参无返回和有参有返回的标准格式还有lambda表达式的标准写法。
Stream、Lambda表达式练习.doc
01-14
Stream、Lambda表达式练习.doc
Java8新特性Lambda表达式的一些复杂用法总结
08-29
lambda表达式是JAVA8中提供的一种新的特性，它支持Java也能进行简单的“函数式编程”。 下面这篇文章主要给大家介绍了关于Java8新特性Lambda表达式的一些复杂用法的相关资料，需要的朋友可以参考借鉴，下面来一起看...
java中lambda表达式语法说明
09-01
“Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的&lambda;演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包...
Java【代码分享 06】Lamda表达式将List对象中的Map对象的key全部转化为大写或者小写（去除外层循环：可用于Map对象中的key全部转化为大写或者小写）
Java与大数据相关实践内容分享！
07-27 2649
Java【代码分享 06】Lamda表达式将List对象中的Map对象的key全部转化为大写或者小写（去除外层循环：可用于Map对象中的key全部转化为大写或者小写）
java Lambda表达式练习
weixin_43821614的博客
08-26 3828
关于JAVA8新特性，Lambda表达式的练习。 java8更新许久，但从来没有试验整理过。借公司空闲之际，练习一下Lambda表达式！ 练习题目，均为网上寻找题目（原版地址找不到了）。 本文lambda学习主要参考博主葵花下的獾的文章，参考链接https://blog.csdn.net/qq_28410283/article/details/80634725（非常有用，lambda其他知识...
Java：Lambda表达式、方法引用
最新发布
游手好闲
01-06 856
Java：Lambda表达式、方法引用
Java8 lambda表达式
hebeind100的博客
09-15 1149
lambda表达式。 （1）以下是维基百科上对于"Lambda expression"的解释：   afunction (or a subroutine) defined, and possibly called, without being bound toan identifier。   简单点说就是：一个不用被绑定到一个标识符上，并且可能被调用的函数。这个解释还不够通俗，lamb...
Lambda表达式及练习
qq_54875747的博客
01-17 1013
Lambda表达式的标准格式 匿名内部类中重写swim()方法的代码分析 1.方法形式参数为空，说明调用方法时不需要传递参数 2.方法返回值类型为void，说明方法执行没有结果返回 3.方法体中的内容，是我们具体要做的事情 goSwimming(new Swimming() { @Override public void swim() { System.out.println("游泳去吗"); }
java8 lambda表达式
09-13
Java 8引入了Lambda表达式作为这个版本的一个重要特性。Lambda表达式是一种匿名函数，它可以帮助开发者更好地实现接口中的抽象方法。换句话说，Lambda表达式可以被理解为用于实现接口中抽象方法的一种方式。当开发者...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

每日小新

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值