Lambda表达式

最新推荐文章于 2024-05-05 13:57:09 发布
最新推荐文章于 2024-05-05 13:57:09 发布
阅读量284 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XXYYWJC/article/details/121524155
版权

Lambda表达式

题一:

调用Collections.sort()方法,通过定值排序比较两个Employee(先按年龄比,年龄相同按姓名比),使用Lambda作为参数传递

分析: 1.定制排序:指自定义比较器|定制排序

​ 自然排序:内部比较器|自然排序

​ 2.先比较年龄,年龄相同才比较姓名

总结: 想要参数实参为lambda表达式,形参就必须为一个函数式接口作为形参 ， lambda-> 行为当做参数传递

public class TestLambda001 {
    public static void main(String[] args) {
        List<Employee>list=new ArrayList<>();
        list.add(new Employee("zhangsan",25,8000));
        list.add(new Employee("lisi",25,26000));
        list.add(new Employee("wangwu",24,20000));
        System.out.println(list);
        //根据年龄做升序排序,如果年龄相同根据姓名做升序排序
        Collections.sort(list,(x,y)-> {
            if (x.getAge() == y.getAge()) {
                return x.getName().compareTo(y.getName());
            }
            return Integer.compare(x.getAge(), y.getAge());
        });
        System.out.println(list);
    }
}
题二：

1)声明函数式接口,接口中声明抽象方法,public String getValue(String str)

2)声明类 TestLambda,类中编写方法使用接口作为参数,讲一个字符串转成大写,并作为方法的返回值

3)再将一个字符串的第2个和第4个索引位置进行截取子串

Handler处理器，处理者

public class TestLambda002 {
    public static void main(String[] args) {
        System.out.println(strHandler("sadasdavewfasdq",s->s.substring(2,7)));
        System.out.println(strHandler("sadasdavewfasdq",s->s.toUpperCase()));
        System.out.println(strHandler("   dqwdsvsd    ",s->s.trim()));
    }
    //能对一个字符串进行进一步加工处理,返回结果
    public static String strHandler(String str,MyFunction my){
        return my.getValue(str);
    }
}
@FunctionalInterface
interface MyFunction{
    public String getValue(String str);
}
题三：

1)声明一个带两个泛型的函数式接口,发型类型为<T,R> T为参数,R为返回值

2)接口中声明对应抽象方法

3)在TestLambda类中声明方法,参数三个,两个long类型的参数,接口作为参数,接口实现中计算两个long型参数的和

4)再计算两个long型参数的乘积

public class TestLambda003 {
    public static void main(String[] args) {
        System.out.println(testLong(100L,200L,(l1,l2)->l1+l2));
        System.out.println(testLong(100L,200L,(l1,l2)->l1*l2));
    }
    public static Long testLong(Long l1,Long l2,MyFunction2<Long,Long> my){
        return my.test(l1,l2);
    }
}
interface MyFunction2<T,R>{
    public R test(T t1,T t2);
}

Functional

四大内置函数式接口: java.util.function
1.Consumer 消费型接口
void accept(T t) ，对给定参数执行此操作，没有返回值

​ default Consumer < T > andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然 后执行after操作

​ 2.Function<T,R> 函数型接口
​ R apply(T t)，将此函数应用于给定的参数
​ 3.Supplier 供给型接口
​ T get()，不需要参数，返回一个由Lambda表达式实现的一个值
​ 4.Predicate 段言型接口
​ boolean test(T t)，对给定的参数进行判断，返回一个bool值

public class Class001_Functional {
    public static void main(String[] args) {
        testComsumer(2000,m-> System.out.println("每天固定给女主播刷超级火箭"+m));
        testComsumer(500,m-> System.out.println("每天做脸消费"+m));

        System.out.println(strHandler("nihaoa   ",s-> s.trim()));
        System.out.println(strHandler("nihaoa   ",s-> s.toUpperCase()));

        System.out.println(testSupplier(5,()->(int)(Math.random()*(5-1+1)+1)));
        System.out.println(testSupplier(46,()->(int)(Math.random()*(20-10+1)+10)));

        System.out.println(testPredicate(List.of("abc","abcd","abcde"),s->s.length()>3));
    }
    //对集合中的多个字符串进行某种规则的过滤,返回满足条件的字符串
    public static List<String> testPredicate(List<String> list, Predicate<String> pre){
        List<String> newList = new ArrayList<>(); //存放满足条件的字符串
        for(String str:list){
            if(pre.test(str)){
                newList.add(str);
            }
        }
        return newList;
    }

    //生成指定个数的不同规则的整数
    public static List<Integer> testSupplier(int num, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<>(); //存放生成的所有整数
        for(int i=1;i<=num;i++){
            list.add(sup.get());
        }
        return list;
    }
    //对字符串进行某种行为处理,返回结果
    public static String strHandler(String str, Function<String,String> fun){
        return fun.apply(str);
    }
    //每天固定消费某些金额做某些行为
    public static void testComsumer(double money, Consumer<Double> com){
        com.accept(money);
    }
}

方法引用

  1. 方法引用::
    简化lambda表达式
    是lambda表达式的另外一种表现形式

  2. 使用前提:
    当lambda表达式的lambda体中的实现已经存在另外一个方法实现了,只需要在lambda体中调用另一个方法—> 可以通过方法引用的写法直接引用那个方法
    lambda表达式重写的抽象方法的参数列表与返回值对应内部所引用方法的参数列表与返回值
    lambda返回值与内部所调用方法的方法直接对应,lambda的参数列表的第一个参数作为内部调用成员方法的对象存在,lambda的第二到多个参数直接匹配内部所调用方法的参数列表存在

  3. 分类
    对象::成员方法
    要求: lambda表达式重写的抽象方法的参数列表与返回值对应内部所引用方法的参数列表与返回值
    类名::静态方法
    lambda表达式重写的抽象方法的参数列表与返回值对应内部所引用方法的参数列表与返回值
    类名::成员方法
    lambda返回值与内部所调用方法的方法直接对应,lambda的参数列表的第一个参数作为内部调用成 员方法的对象存在,lambda的第二到多个参数直接匹配内部所调用方法的参数列表存在

  4. //quite，相当的

考虑是否能通过方法引用简化：

1.Lambda体的实现是否通过调用另一个方法实现的

2.考虑函数接口的参数列表与返回值是否对应内部引用Println方法的参数列表与返回值

public class Class002_Quite {
    public static void main(String[] args) {
        //对象::成员方法
        PrintStream ps =  System.out;
        Consumer<Integer> com = i-> ps.println(i);
        //考虑是否可以通过方法引用简化 : 1)lambda体的实现是否是通过调用另外一个方法实现的--> √ println  2)考虑Consumer中的抽象方法的参数列表与返回值是否对应内部引用println方法的参数列表与返回值--> √
        com = ps::println;
        com = System.out::println;
        //List.of(1,2,3,4,5).forEach(com);
        List.of(1,2,3,4,5).forEach(System.out::println);

        //类名::静态方法
        //求两个小数中的最大值
        BiFunction<Double,Double,Double> fun = (x,y)->Math.max(x,y);
        //分析是否可以通过方法引用简化: 1)lambda体的实现是否是通过调用另外一个方法实现的--> √ max  2)apply方法的参数列表与返回值是否直接匹配内部所调用方法的参数列表与返回值 -> √
        fun = Math::max;
        System.out.println(fun.apply(2.1,1.8));;

        BiPredicate<String,String> pre = (x,y)->x.equals(y);
        //分析是否可以通过方法引用简化:  1)lambda体的实现是否是通过调用另外一个方法实现的-->√  equals
        // 2)lambda返回值与内部所调用方法的方法直接对应,lambda的参数列表的第一个参数作为内部调用成员方法的对象存在,lambda的第二到多个参数直接匹配内部所调用方法的参数列表存在 --> √  可以使用类名::成员方法名简化
        pre = String::equals;
        System.out.println(pre.test("nihao","nihao"));;
    }
}

Stream

Stream :
关注流式运算,不是传输与存储
io流关注数据的传输
集合与数组关注数据的存储

注意😗*
1.Stream是一次性的流,一旦使用过就不能重复使用
2.Stream的操作不会影响数据源中的数据
3.延迟执行|惰性加载: 当获取终止行为时候才会执行中间操作

使用步骤:
1.获取Stream流
2.中间行为 : 一系列的流式操作
3.终止行为

创建Stream的方式:
1.Collection Stream stream()
2.Arrays stream()
3.Stream.of(值列表)

public class Class001_Stream {
    public static void main(String[] args) {
    
        //1..Collection  Stream<E> stream()
        List<Integer> list = List.of(1,2,3,4,5);
        Stream<Integer> stream = list.stream();
        stream.forEach(System.out::println);

        //2.Arrays  stream()
        String[] arr = {"abc","bbb","ccc"};
        Stream<String> stream1 = Arrays.stream(arr);
        stream1.forEach(System.out::println);

        //3.Stream.of(值列表)
        Stream<Integer> stream2 = Stream.of(3,2,1);
        stream2.forEach(System.out::println);
    }
}

流式中间操作

流式中间操作
1.过滤 Stream filter(Predicate<? super T> predicate);
2.去重 Stream distinct()
3.截取 Stream limit(long maxSize)
4.跳过 Stream skip(long)
5.排序 sorted() | sorted(Comparator<? super T> comparator)
6.映射 map(Function) ：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元 素。

注意: 中间操作都会返回一个持有结果的新的流

流操作是每一条从头到尾单独操作，并不是所有数据统一进入操作

public class Class002_Stream {
    static List<Employee> list = Arrays.asList(
            new Employee("lisi",19,5000),
            new Employee("wangwu",18,4000),
            new Employee("tianqi",17,4000),
            new Employee("zhaoliu",20,3000),
            new Employee("zhangsan",20,6000),
            new Employee("zhangsan",20,6000)
    );
    public static void main(String[] args) {
        //1.获取一个stream
        Stream<Employee> stream = list.stream();
        //2.中间操作 延迟执行
        /*stream = stream.filter(e->{
            System.out.println("--------------过滤-----------");
            return e.getAge()>=18;
        }).distinct()
        .limit(3)
        .skip(1)
        .filter(e->{
            System.out.println("-----------最终过滤------------"+e);
            return true;
        });*/

        //排序
        //stream = list.stream().sorted();
        // stream = list.stream().sorted((x,y)-														>Double.compare(y.getSalary(),x.getSalary()));

        //映射
        //Stream<Double> stream2 = list.stream().map(e->e.getSalary());
        Stream<Double> stream2 = list.stream().map(Employee::getSalary);

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

public class Class003_Stream {
    static List<Employee> list = Arrays.asList(
            new Employee("lisi",19,5000),
            new Employee("wangwu",18,4000),
            new Employee("tianqi",17,4000),
            new Employee("zhaoliu",20,3000),
            new Employee("zhangsan",20,6000),
            new Employee("zhangsan",20,6000)
    );
    public static void main(String[] args) {
        //1.获取一个stream
        Stream<Employee> stream = list.stream();
        //2.中间操作,终止行为
        //anyMatch-检查是否至少匹配一个元素
        System.out.println( stream.allMatch(e->e.getAge()>=18));;
        //需求：按工资排序，获取第一个员工信息
        // findFirst-返回第一个元素
        //1)降序排序  2)找到第一个元素
        Optional<Employee> op1=  list.stream().sorted((x, y)->Double.compare(y.getSalary(),x.getSalary()))
                .findFirst();
        if(op1.isPresent()){
            System.out.println(op1.get());
        }
        //并行流
        op1 = list.parallelStream().findAny();
        System.out.println(op1.get());

        //薪资>5000的员工个数
        // count-返回流中元素的总个数
        System.out.println(list.stream().filter(e->e.getSalary()>5000).count());

         max-返回流中最大值
         min-返回流中最小值
        System.out.println(list.stream().max((x,y)->Double.compare(x.getSalary(),y.getSalary())).get());

        //规约 map-reduce  先加工->后处理汇总结果
        System.out.println(list.stream().map(Employee::getSalary).reduce((x,y)->x+y).get());;

        System.out.println(Stream.of(1,2,3,4,5).reduce((x,y)->{
            System.out.println("========>x = "+ x + " , y ="+y );
            return x+y;
        }).get());;

        System.out.println(Stream.of(1,2,3,4,5).reduce(100,(x,y)->{
            System.out.println("========>x = "+ x + " , y ="+y );
            return x+y;
        }));

        // 收集(collect)
        //collect 主要依赖 java.util.stream.Collectors 类内置的静态方法。
        //Collectors.toList()
        List<String> names = list.stream().distinct().map(Employee::getName).collect(Collectors.toList());
        System.out.println(names);

        Set<String> names2 = list.stream().map(Employee::getName).collect(Collectors.toSet());
        System.out.println();

        Map<String,Double> map = list.stream().distinct().collect(Collectors.toMap(Employee::getName,Employee::getSalary));
        System.out.println(map);
    }
}

多线程

**线程：**执行的顺序流

**多线程：**多条执行路径，多任务执行，如果没有多任务，多线程没有意义

**线程与进程：**进程：一个操作系统中的多个程序

​ 进程包括1~n个线程

​ 每个进程都有自己的代码和数据空间

​ 资源分配的最小单位

​ 进程间的切换会有比较大的开销

**线程：**一个程序中的多个顺序流

​ 多个线程之间共享进程的代码和数据空间

​ 每个线程存在自己的运行栈和程序计数器

​ 调度和执行的最小单位

​ 线程切换的开销小

**优点：**资源利用率更好，程序设计在某些情况下更简单，程序响应更快

**线程三高：**1.高可用

​ 2.高性能

​ 3.高并发

**线程的创建：**1.继承Thread类，重写run方法，在run方法中定义线程体 +start（）

​ 2.实现Runnable接口，重写run方法+start（）–>简单，接口 可以多实现，实现资源共享

​ 3.juc包下Callable接口，重写call（），在call方法中定义线程 体+线程池

public class Class001_thread extends Thread{
     /*
        线程体
     */
    public void run(){
        for(int i=1;i<20;i++){
            System.out.println("1");
            try {
                Thread.sleep(5);
            }catch (InterruptedException e){
                e.printStackTrace();
                //printStackTrace 在命令行打印异常信息在程序中出错的位置及原因
            }
        }
    }
    public static void main(String[] args) {
        //创建线程
        Class001_thread td=new Class001_thread();
        //开启线程 void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法。
        td.start();
        for (int i=1;i<20;i++){
            System.out.println("0");
            try {
                Thread.sleep(5);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
吃我一平A
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 中lambda表达式的编译器实现原理
08-31
C++ 11加入了一个非常重要的特性——Lambda表达式。这篇文章主要介绍了C++ 中lambda表达式的编译器实现原理,需要的朋友可以参考下
Lambda表达式超详细总结
热门推荐
huangjhai的博客
07-07 8万+
在2014年Oracle发布了Java 8,在里面增加了Lambda模块。于是Java程序员们又多了一种新的编程方式：函数式编程。
Lambda表达式详解
唯有努力，方可自信！
06-14 6661
本篇文章将介绍Java中的Lambda表达式，它是Java 8中引入的一项新特性，也是函数式编程的一种风格。我们将深入研究Lambda表达式的语法和用法，讲解如何使用Lambda表达式来写出更加简洁、易读的代码，并介绍Lambda表达式在Java中的应用场景及其优缺点。无论您是初学者还是有一定经验的程序员，本文都将为您提供宝贵的参考和帮助。
Lambda 表达式
小鲁蛋的博客
08-21 4322
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为Lambda 操作符或箭头操作符。左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
C++11：lambda表达式
Man9o
03-09 8355
通常lambda表达式用于封装一些传递给算法或异步函数的代码。C++11中引入了λ表达式，它可以用来定义一个**内联 (inline)**的函数，作为一个本地的对象或者一个参数。内联函数是一种编译器优化技术，它可以避免函数调用的开销，提高执行效率。λ表达式可以被编译器自动内联展开，从而减少函数调用的次数。但是，并不是所有的λ表达式都会被内联，这取决于编译器的实现和优化策略。
Java中Lambda表达式使用及详解
qq_45263520的博客
03-27 7万+
Java中Lambda表达式使用及详解 前言 一、Lambda表达式的简介 Lambda表达式（闭包）：java8的新特性，lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中。使用lambda表达式可以让代码更加简洁。 Lambda表达式的使用场景：用以简化接口实现。 关于接⼝实现，可以有很多种⽅式来实现。例如：设计接⼝的实现类、使⽤匿名内部类。 但是lamb
C ++ Lambda表达式详解
白云之道
12-19 4万+
C ++ Lambda表达式详解 1.Lambda表达式概述 ​ Lambda表达式是现代C++在C ++ 11和更高版本中的一个新的语法糖 ，在C++11、C++14、C++17和C++20中Lambda表达的内容还在不断更新。 lambda表达式（也称为lambda函数）是在调用或作为函数参数传递的位置处定义匿名函数对象的便捷方法。通常，lambda用于封装传递给算法或异步方法的几行代码 。本文主要介绍Lambda的工作原理以及使用方法。 2.Lambda表达式定义 2.1 Lambda表达式示例 ​
Java Lambda 表达式
Yeats_Liao的博客
04-15 3万+
Java Lambda 表达式
【Java系列】深入解析 Lambda表达式
颜淡慕潇
06-23 4万+
Lambda表达式是Java 8中最强大和灵活的新特性之一，它可以用于各种不同的编程任务，使代码更加简单、灵活和易于读写。 Lambda表达式的语法非常简洁，通常由一个参数列表、一个箭头符号和一个表达式主体组成。
C++11 lambda表达式
12-22
C++11引入了lambda表达式，使得程序员可以定义匿名函数，该函数是一次性执行的，既方便了编程，又能防止别人的访问。 　Lambda表达式的语法通过下图来介绍： 　这里假设我们定义了一个如上图的lambda表达式。...
python lambda表达式
01-20
lambda 表达式的语法格式为： lambda [parameter_list] ： 表达式 根据其语法格式可以得到lambda 表达式的两个要点： 1、lambda 表达式必须使用 lambda 关键字定义。 2、在 lambda 关键字之后、冒号左边为参数列表，...
Stream、Lambda表达式练习.doc
01-14
Stream、Lambda表达式练习.doc
lambda表达式详解及实际运用
12-21
lambda表达式并不可以对所有的接口进行简单实现，只有函数式接口可以使用lambda表达式 什么是函数式接口？ 语法 （）参数列表，{}方法体，-> lambda运算符（goes to） lambda 表达式的语法格式如下： (参数列表) -> ...
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1203
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1076
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1118
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
lambda 表达式
05-28
Lambda 表达式是 C++11 引入的一个新特性，它允许我们在代码中定义匿名函数。Lambda 表达式可以看作是一个可调用的对象，可以像函数一样被调用，但是它不需要像函数一样显式地声明或定义，而是直接在代码中定义。 Lambda 表达式的基本语法如下： ``` [capture list] (params list) mutable exception-> return type { function body } ``` 其中，方括号内的部分是可选的，包含了 lambda 表达式的捕获列表，用于定义 lambda 表达式所需的外部变量。params list 是函数的参数列表，可以为空。mutable 关键字用于控制是否可以修改捕获的变量。exception 是异常说明符，可以为空。return type 是函数的返回类型，可以为空。function body 是函数体。 Lambda 表达式可以作为函数参数传递，可以存储在变量中，也可以作为返回值返回。它可以直接使用当前作用域内的变量，或者通过捕获列表捕获外部变量。Lambda 表达式还支持函数重载、模板参数等高级特性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值