java8 Lambda表达式用法全集精简你的代码吧！

最新推荐文章于 2024-04-19 19:03:52 发布

云y

最新推荐文章于 2024-04-19 19:03:52 发布

阅读量330

点赞数

分类专栏： java笔记文章标签： java lambda java8

本文链接：https://blog.csdn.net/qq_35031177/article/details/90598881

版权

java笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

4.用lambda表达式实现map与reduce

什么是函数式编程

函数式编程（英语：functional programming）又称函数程序设计和泛函编程，是一种编程范型，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）。

函数式风格优点

1、代码简洁

通常情况下，函数式编程更加简明扼要，精简的代码更易于维护。而Java代码的冗余性也是出了名的，大部分对于Java语言的攻击都会直接针对Java繁琐，而且死板的语法（不过这也不是缺点），然而，引入函数式编程范式后，这种情况发生了改变。我们可以让Java用更少的代码完成更多的工作。

代码块

    static int[] arr = {1,3,4,5,6,7,8,9,10};      
    //传统的处理方式：        
    for(int i=0;i<arr.length;i++){               
      if(arr[i]%2 != 0){                  
        arr[i]++;               
      }               
      System.out.println(arr[i]);      
    }  
    //函数式处理方式：  
    arr.stream().map(x->(x%2==0?x:x+1)).foreach(System.out::println);

2、易于多线程

由于对象都处于不变的状态，因此函数式编程更加易于并行。实际上，你甚至完全不用担心线程安全的问题。我们之所以要关注线程安全，一个很大的原因是当多个线程对同一个对象进行写操作时，容易“使得对象状态不一致”。但是，由于不变模式的存在，对象自创建以来，就不可能发生改变，因此，在多线程环境下，也就没有必要进行任何同步操作。这样不仅有利于并行化，同时，在并行化后，由于没有同步和锁机制，其性能也会比较好。例如java.lang.String对象。很显然，String对象可以在多线程中很好的工作，但是，得益于不变模式，它的每一个方法都没有进行同步处理。

3、可读性更高

函数式编程风格只需要声明计算机需要干什么事，而不是像命令式风格一样将计算机的操作具体到每一步，所以可读性会更高。

常用Lambda表达式

1.替代匿名内部类

毫无疑问，lambda表达式用得最多的场合就是替代匿名内部类，而实现Runnable接口是匿名内部类的经典例子。lambda表达式的功能相当强大，用()->就可以代替整个匿名内部类！请看代码：

如果使用匿名内部类：

代码块

    @Test
    public void oldRunable() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("The old runable now is using!");
            }
        }).start();
    }
//而如果使用lambda表达式：

//代码块

    @Test
    public void runable() {
        new Thread(() -> System.out.println("It's a lambda function!")).start();
    }

2.使用lambda表达式对集合进行迭代

Java的集合类是日常开发中经常用到的，甚至说没有哪个java代码中没有使用到集合类。。。而对集合类最常见的操作就是进行迭代遍历了。请看对比：

代码块

    @Test
    public void iterTest() {
        List<String> languages = Arrays.asList("java","scala","python");
        //before java8
        for(String each:languages) {
            System.out.println(each);
        }
        //after java8
        languages.forEach(x -> System.out.println(x));
        languages.forEach(System.out::println);
    }

3.用lambda表达式实现map

一提到函数式编程，一提到lambda表达式，怎么能不提map。。。没错，java8肯定也是支持的。请看示例代码：

代码块

    @Test
    public void mapTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        cost.stream().map(x -> x + x*0.05).forEach(x -> System.out.println(x));
    }

map函数可以说是函数式编程里最重要的一个方法了。map的作用是将一个对象变换为另外一个。在我们的例子中，就是通过map方法将cost增加了0,05倍的大小然后输出。

上面是使用map将一个对象变换为另外一个，那么要变换一个list，map呢，这就要用到flatMap了

    @Test
    public void flatMapTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        cost.stream().map(x -> new ArrayList()).flatMap(Collection::stream).collect(Collectors.toList());
    }

4.用lambda表达式实现map与reduce

既然提到了map，又怎能不提到reduce。reduce与map一样，也是函数式编程里最重要的几个方法之一。。map的作用是将一个对象变为另外一个，而reduce实现的则是将所有值合并为一个，reduce方法允许我们用自己的方式去计算元素或者将一个Stream中的元素以某种规律关联

代码块

    @Test
    public void mapReduceTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        double allCost = cost.stream().map(x -> x+x*0.05).reduce((sum,x) -> sum + 
        x).get();
        System.out.println(allCost);
    }

最终的结果为：63.00

5.filter操作

filter也是我们经常使用的一个操作。在操作集合的时候，经常需要从原始的集合中过滤掉一部分元素。

代码块

    @Test
    public void filterTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0,40.0);
        List<Double> filteredCost = cost.stream().filter(x -> x > 
        25.0).collect(Collectors.toList());
        filteredCost.forEach(x -> System.out.println(x));
    }

最终结果：30 40

6.与函数式接口Predicate配合

除了在语言层面支持函数式编程风格，Java 8也添加了一个包，叫做 java.util.function。它包含了很多类，用来支持Java的函数式编程。其中一个便是Predicate，使用 java.util.function.Predicate 函数式接口以及lambda表达式，可以向API方法添加逻辑，用更少的代码支持更多的动态行为。Predicate接口非常适用于做过滤。

代码块

public static void filterTest(List<String> languages, Predicate<String> condition) {
        languages.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + " "));
    }
    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java","Python","scala","Shell","R");
        System.out.println("Language starts with J: ");
        filterTest(languages,x -> x.startsWith("J"));
        System.out.println("\nLanguage ends with a: ");
        filterTest(languages,x -> x.endsWith("a"));
        System.out.println("\nAll languages: ");
        filterTest(languages,x -> true);
        System.out.println("\nNo languages: ");
        filterTest(languages,x -> false);
        System.out.println("\nLanguage length bigger three: ");
        filterTest(languages,x -> x.length() > 4);
    }

可以看到，Stream API的过滤方法也接受一个Predicate，这意味着可以将我们定制的 filter() 方法替换成写在里面的内联代码。

7.Match（匹配）

用来判断某个predicate是否和流对象相匹配，最终返回Boolean类型结果，例如

代码块

    List<String> list = new ArrayList<String>();
    list.add("a1");
    list.add("b1");

 
    // 流对象中只要有一个元素匹配就返回true
    boolean anyStartWithA = list.stream().anyMatch((s -> s.startsWith("a")));
    System.out.println(anyStartWithA);
    // 流对象中每个元素都匹配就返回true
    boolean allStartWithA = list.stream().allMatch((s -> s.startsWith("a")));
    System.out.println(allStartWithA);

8.Limit（限制）

imit 方法用于获取指定数量的流。以下代码片段使用 limit 方法打印出 10 条数据：

代码块

@Test
public void streamSortedTest() {
    Random random = new Random();
    random.ints().limit(10).sorted().forEach(System.out::println);
}

9.compare（排序）

代码块

list.compare((a,b)->a-b); 升序

10.进阶（parallelStream并发流处理）

云y

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java8 Lambda表达式用法全集精简你的代码吧！

目录什么是函数式编程函数式风格优点1、代码简洁2、易于多线程3、可读性更高常用Lambda表达式1.替代匿名内部类3.用lambda表达式实现map4.用lambda表达式实现map与reduce5.filter操作6.与函数式接口Predicate配合7.Match（匹配）8.Limit（限制）9.compare（排序）什么是函数式编程...
复制链接

扫一扫