园龄：10年7个月粉丝：73 关注：0

Lambda表达式常见用法

Lambda介绍

Lambda，别名函数式编程

函数式编程是一种编程范式。它把计算当成是数学函数的求值，从而避免改变状态和使用可变数据。它是一种声明式的编程范式，通过表达式和声明而不是语句来编程。

Lambda表达式的优缺点

优点：

代码简洁，开发迅速，方便函数式编程
非常容易进行并行计算，尤其适用于遍历结果，循环计算数值或者赋值时
结合 hashmap 的 computeIfAbsent 方法，递归运算非常快。java有针对递归的专门优化。
减少匿名内部类的创建，节省资源（匿名内部类会产生一个class文件，而Lambda不会产生class文件，所以在类加载时，Lambda表达式的效率更高。）

缺点：

代码可读性变差，不容易进行调试
不易于后期维护，必须熟悉lambda表达式和抽象函数中参数的类型
不能再foreach中修改forEach外面的值，强制类型转换不方便(一定要搞清楚到底是 map 还是 mapToDouble 还是 mapToInt)
性能方面，如果不并行计算，很多计算未必有传统的for性能要高（并行计算有时需要预热才显示出效率优势）

使用场景：

集合操作：Lambda表达式可以方便地对集合进行筛选、转换和聚合等操作。
接口的实现：当需要实现一个只有一个抽象方法的接口时，可以使用lambda表达式代替匿名内部类。
并行处理：使用Stream API和lambda表达式可以方便地进行并行处理，提高性能。

符号表示

lambda是一个匿名函数

() 里的表示参数
// 括号中的参数只有一个，（）可以省略
// 括号中的参数列表的数据类型，可以省略不写（编译器自己会根据上下文语境推断出类型的）

{} 里的表示方法体
// Lambda体只有一句语句（{ 只有一句语句 }），无论是否有返回值，都可以省略（{ }， return , 分号 ）
// 注意：在省略{ }的同时要（return）和分号一起省略

-> 表示lambda运算符

并行处理

什么是并行流？

就是利用多核 CPU 的计算能力来加速流式处理。当一个流进行并行处理时，数据会被分成多个部分，这些部分会同时在多个线程上处理，最后将部分结果合并起来得到最终结果。

我们可以通过调用 Collection 的 parallelStream() 或 Stream 的 parallel() 方法来获取一个并行流。

代码示例

public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
        Stream<Integer> parallelStream = list.parallelStream();

        // forEach – 并行执行
        list.parallelStream().forEach(e -> doSomething(e));
        // filter – 并行过滤
        list.parallelStream().filter(e -> e > 2).forEach(e -> doSomething(e));
        // map – 并行映射
        list.parallelStream().map(e -> e * 2).forEach(e -> doSomething(e));
        // reduce – 并行归约
        Integer sum = list.parallelStream().reduce(0, (a, b) -> a + b);
        // sorted – 并行排序
        list.parallelStream().sorted().forEach(e -> doSomething(e));
    }
}

通过并行流可以让许多常见的流操作利用多核 CPU 进行并行计算，从而获得更高的性能。但是，并不意味着所有的流操作都适合并行化，如果流处理的程序本身不是 CPU 密集型的，那么并行化可能得不到太大的性能提升，甚至有所下降。

简单运用示例

匿名内部类调用

函数式接口：只有一个方法的接口。只要是函数式接口，都可以通过匿名函数来实现。

public class Test {
    interface Demo{
        int method(String s);
    }
    public static void main(String[] args) {

        // 匿名内部类调用
        Demo demo = new Demo() {
            @Override
            public int method(String s) {
                return Integer.parseInt(s);
            }
        };
        int v = demo.method("111");

        // lambda表达式
        Demo demo2 = (s) -> {
            return Integer.parseInt(s);
        };
        int v2 = demo2.method("222");

        // 单行简写
        Demo demo3 = s -> Integer.parseInt(s);
        int v3 = demo3.method("333");
    }
}

并行计算求和

public class Demo {
    public static void main(String[] args) {
        List<String> values = Arrays.asList("1","2","3","4");
        System.out.println(sum(values));
    }
    public static int sum(List<String> values){
       // mapToInt方法返回的是一个int的Stream，再次调用stream.sum()得到和
       return values.parallelStream().mapToInt(i -> Integer.parseInt(i)).sum();
    }
}

ArryList排序

public class Test1 {

    public static void main(String[] args) {
        /**
         * 需求：
         * 已知在ArryList中有若干个Person类对象，将这些Person对象按照年龄来降序排序
         */
        List<Person> list = new ArrayList<>();
        list.add(new Person("小蓝",10));
        list.add(new Person("小红",11));
        list.add(new Person("小紫",18));
        list.add(new Person("小橙",20));

        //在sort方法中，o1是最后面的元素，o2是倒数第二个元素，以此类推，流是处理元素是从后面开始取值。
        list.sort((o1,o2) -> o2.age - o1.age);

        //对List<String>进行排序
        List<String> list = new ArrayList<String>();
        Collections.sort(list);
        Collections.sort(list, Collections.reverseOrder());

        //对List<Map<String, String>>进行降序
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        Collections.sort(list, (o1, o2) -> {
            String str1 = o1.get("countScore").toString();
            String str2 = o2.get("countScore").toString();
            //str2在前，str1在后，默认降序
            return str2.compareTo(str1);
        });
    }
}

TreeSet排序

public class Test2 {
    public static void main(String[] args) {
        // 使用Lambda表达式来实现Comparator接口，并实例化一个TreeSet对象
        TreeSet<Person> set = new TreeSet<>((o1,o2) -> {
            if(o1.age >= o2.age){
                return -1;
            }else {
                return 1;
            }
        });
        set.add(new Person("小蓝",10));
        set.add(new Person("小红",11));
        set.add(new Person("小紫",18));
        set.add(new Person("小橙",20));
        System.out.println(set);
    }
}

forEach遍历输出

public class Test3 {
    public static void main(String[] args) {
        //集合的遍历
        ArrayList<Integer> list = new ArrayList<>();
        //添加元素
        Collections.addAll(list,1,2,3,4,5,6,7,8,9);
        for (Integer integer : list) {
            System.out.println(integer);
        }
        //将集合中的每一个元素带入到方法accept中
        list.forEach(System.out::println);

        //还可以用forEach方法输出集合中的偶数
        list.forEach(elm -> {
            if(elm %2 == 0){
                System.out.println(elm);
            }
        });
    }
}

removeIf删除方法

public class Test4 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("小蓝",10));
        list.add(new Person("小红",11));
        list.add(new Person("小紫",10));
        list.add(new Person("小橙",20));

        //之前删除年龄大于10岁的元素  使用迭代器删除
        ListIterator<Person> it = list.listIterator();
        while (it.hasNext()){
            Person person = it.next();
            if (person.age > 10){
                it.remove();
            }
        }
        //使用lambda实现
        //将集合中的每一个元素都带入到test方法中，如果返回值是true将删除
        list.removeIf(t -> {
            if (t.age > 10){
                return true;
            }else {
                return false;
            }
        });
        //简化
        list.removeIf(t -> t.age>10);
        System.out.println(list);
    }
}

开辟线程

public class Test5 {
    public static void main(String[] args) {
        //使用lambda表达式开辟一个线程,做一个数字的输出
        Thread t = new Thread(() -> {
            for (int i =0; i<10; i++){
                System.out.println(i);
            }
        });
        t.start();
    }
}

Stream的使用

Stream流的filter使用

List<String> list = Arrays.asList("张三", "李四", "王五", "小六");

List<String> result = list.stream().filter(str -> !"李四".equals(str)).collect(Collectors.toList());
System.out.println("stream 过滤之后:" + result);

String result2 = list.stream().filter(str -> "李四".equals(str)).findAny().orElse("找不到!");
System.out.println("stream 过滤之后 2:" + result2);

Stream流的map使用

// 示例一：转换大写
List<String> list1 = Arrays.asList("zhangSan", "liSi", "wangWu");

List<String> list11 = list1.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println("转换之后的数据:" + list11);

// 示例二：转换数据类型
List<String> list2 = Arrays.asList("1", "2", "3");

List<Integer> list22 = list2.stream().map(Integer::valueOf).collect(Collectors.toList());
System.out.println("转换之后的数据:" + list22);

// 示例三：获取平方
List<Integer> list3 = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
List<Integer> list33 = list3.stream().map(n -> n * n).collect(Collectors.toList());
System.out.println("平方的数据:" + list33);

// 示例四：list对象转list对象
// 将List<User>对象中的name属性转换为List<String>对象
List<String> listStr= user.stream().map(x -> x.getName()).collect(Collectors.toList());

// 将List<String>对象转换为List<User>对象
List<User> userList = listStr.stream().map(name-> {
    User user= new User();
    user.setName(name);
    user.setPassword(null);
    user.setAge(null);
    return user;
}).collect(Collectors.toList());
// 简写
List<User> userList = listStr.stream().map(name-> new User(name)).collect(Collectors.toList());

// 将List<User>对象转换为List<UserInfo>对象
List<UserInfo> collect = userList.stream().map(l -> new UserInfo(l.getName(), l.getPassword())).collect(Collectors.toList());

Stream流的sort使用

List<String> list = Arrays.asList("张三", "李四", "王五", "小六");
list.stream().limit(3).sorted().forEach(System.out::println);

// 先排序后比较效率更高
List<User> listUser = new ArrayList<User>();
listUser.stream().limit(3).sorted((u1, u2) -> u1.getName().compareTo(u2.getName())).collect(Collectors.toList());

Stream流的max/min/distinct使用

// 示例一：取最大/最小值
List<String> list13 = Arrays.asList("zhangsan","lisi","wangwu","xuwujing");
int maxLines = list13.stream().mapToInt(String::length).max().getAsInt();
int minLines = list13.stream().mapToInt(String::length).min().getAsInt();
System.out.println("最长字符的长度:" + maxLines+",最短字符的长度:"+minLines);

// 示例二：得到去重之后的数据
String lines = "good good study day day up";
List<String> list14 = new ArrayList<String>();
list14.add(lines);
List<String> words = list14.stream().flatMap(line -> Stream.of(line.split(" "))).filter(word -> word.length() > 0).map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());
System.out.println("去重复之后:" + words);

Stream流的reduce使用

reduce 主要作用是把 Stream 元素组合起来进行操作。

// 示例一：字符串连接
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
System.out.println("字符串拼接:" + concat);

// 示例二：得到最小值
double minValue = Stream.of(-4.0, 1.0, 3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
System.out.println("最小值:" + minValue);

// 示例三：求和
// 求和, 无起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
System.out.println("有无起始值求和:" + sumValue);

// 求和, 有起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(1, Integer::sum);
System.out.println("有起始值求和:" + sumValue);

// 示例四：过滤拼接
concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);
System.out.println("过滤和字符串连接:" + concat);

Stream流的Match使用

allMatch：Stream 中全部元素符合则返回 true ;
anyMatch：Stream 中只要有一个元素符合则返回 true;
noneMatch：Stream 中没有一个元素符合则返回 true。

// 检查数据是否符合
boolean all = lists.stream().allMatch(u -> u.getId() > 3);
System.out.println("是否都大于3:" + all);

boolean any = lists.stream().anyMatch(u -> u.getId() > 3);
System.out.println("是否有一个大于3:" + any);

boolean none = lists.stream().noneMatch(u -> u.getId() > 3);
System.out.println("是否没有一个大于3的:" + none);

双冒号之方法引用

Integer::parseInt;    // 方法引用
Integer::new;         // 引入构造方法

interface Demo{
    int method(String s);
}
public class TestTwo {

    public static void main(String[] args) {

        // 匿名内部类调用
        Demo demo1 = new Demo() {
            @Override
            public int method(String s) {
                return Integer.parseInt(s);
            }
        };
        int v1 = demo1.method("111");
        System.out.println(v1);

        // Lambda表达式
        Demo demo2 = s -> {
            return Integer.parseInt(s);
        };
        int v2 = demo2.method("222");
        System.out.println(v2);

        // Lambda表达式 单行简写
        Demo demo3 = s -> Integer.parseInt(s);
        int v3 = demo3.method("333");
        System.out.println(v3);

        // 方法引用 双冒号::
        Demo demo4 = Integer::parseInt;
        int v4 = demo4.method("444");
        System.out.println(v4);

        // 引入构造方法
        Demo demo5 = Integer::new;
        int v5 = demo5.method("555");
        System.out.println(v5);

         // 排序示例
        List<Integer> list = Arrays.asList(20, 53, 16, 95, 100);
        // 方式一：匿名内部类
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        });
        // 方式二：Lambda表达式
        list.sort((x,y) -> Integer.compare(x,y));

        // 方式三：静态方法引用
        list.sort(Integer::compare);

        // 打印
        list.forEach(System.out::println);
    }
}

上一篇Java -jar 启动程序参数说明

下一篇微服务架构核心概念

本文作者：盗梦笔记

本文链接：https://www.cnblogs.com/zhaojinhui/p/16697039.html

posted @ 2022-09-15 16:35 盗梦笔记阅读(238) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

zhaojh

痴于道，专于道，勤于道，再不济，也是大器晚成。