您现在的位置是：首页 > 其他

当前栏目

【java8】java新特性（二）——lambda表达式

集合代码

2023-03-02 10:31:29 时间

## 一，前言 ##

在上一篇博客中，小编向大家抛转引玉，简单说明了\[ Java8 \]（[http://blog.csdn.net/kisscatforever/article/details/79572194][http_blog.csdn.net_kisscatforever_article_details_79572194] ），其实Java 8在2014年3月18日，就发布了。可以说程序员都很激动，而我就不知道，慢慢的接触了，就发现这个东西还真是不错。

## 二，为什么使用Lambda表达式？ ##

第一次接触Lambda表达式的时候，是在学习中.net的lambda表达式，用于写入sql语句。当时自己也是通过看视频接触的，还记得当时自己也是学Linq语句，例如：

1.选择语句：books.Select（p => new {p.Title，p.UnitPrice，p.Author}）; //需用匿名方式
    2. where语句：books.Where（p => p.UnitPrice == 100 && p.Title =” ABC”）;

现在在java8中，汇集了众家的所长，把lambda表达式融合过来了。可以说真是棒。什么是Lambda表达式呢？Lambda表达式就是一个匿名函数（匿名函数就是没有实际名字的函数），我们可以把LAMBDA表达式理解为一段可以传递的代码。可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使得java的的语言表达能力得到了提升。那拉姆达表达式的格式是什么样的呀？

lambda表达式的基础语法：Java8引入一个新的操作符 `- >` 该操作符叫做箭头操作符，箭头把操作符分成两部分。左侧：lambda表达式的参数列表; 右侧：lambda表达式式中所需执行的功能，即lambda体

## 三，10个演示足够你使用Lambda表达式 ##

### 3.1无参数，无返回值6行变1行 ###

@Test
        public void test1(){
    
            //第一种 经典型
           new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("I Love Java！！");
                }
            }).start();
            System.out.println("----------------------------------------------");
           //第二种 lambda型
            new Thread(()->System.out.println("I Love Java！！")).start();
    
        }

结果：

![这里写图片描述][Image 1]

### 3.2一个参数，无返回值 ###

@Test
        public void test2(){
            happy(1000,(x)->System.out.println("你们爱的java喜欢消费，喜欢大保健，平均："+x+"元"));
        }
    
        /** * 调用消费型接口 * @param money * @param con */
        public void happy(double money, Consumer<Double> con){
            con.accept(money);
        }

结果：  
![这里写图片描述][Image 1]

说明：如果只有一个参数，小括号可以省略不写’happy（1000，x - > System.out.println（“你们爱的java喜欢消费，喜欢大保健，平均：”+ x +“元“））; \`如果lambda中只有一条语句，返回和大括号可以省略不写.

### 3.3 有两个以上的参数，有返回值，并且有多条语句 ###

多条语句用\{\}括起来。如果lambda体只有一条一条语句 ，return和大括号都可以省略。

@Test
        public void testCount(){
            Long t1= 5L;
            Long t2=9L;
            long count = count(t1, t2, (l1, l2) -> l1 + l2); System.out.println(count); System.out.println("---------------------------------------"); long count1 = count(t1, t2, (l1, l2) -> l1 * l2); System.out.println(count1); }

结果：  
![这里写图片描述][Image 1]

## 四、实例 ##

### 4.1 lambda表达式实现Runnable接口 ###

java8之前runnable接口实现方法用4行代码，使用lambda表达式只需要一行代码：

// Java 8之前：
    new Thread(new Runnable() {
        @Override
        public void run() {
        System.out.println("Before Java8, too much code for too little to do");
        }
    }).start();
    
    //Java 8方式：
    new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

### 4.2 使用lambda表达式代替增强for循环 ###

做java的，肯定接触过集合类，接触过list。最常见的就是迭代、遍历其中的所有元素。java8之前的所有循环代码是顺序的，可以对其元素进行并行处理。如果想做并行过滤就要自己写代码。通过引入lambda表达式和默认方法，将做什么和怎么做的问题分开了，这意味着Java集合现在知道怎样做迭代，并可以在API层面对集合元素进行并行处理。

// Java 8之前：
    List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
    for (String feature : features) {
        System.out.println(feature);
    }
    
    // Java 8之后：
    List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
    features.forEach(n -> System.out.println(n));
    
    // 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，
    // 看起来像C++的作用域解析运算符
    features.forEach(System.out::println);

### 4.3 lambda表达式使用Map 和Reduce ###

Map 映射，接收Lambda，将元素转换成新的集合。接收一个函数作为参数，该函数会被应用到每一个元素上，并将其映射为一个新的元素。

Reduce可以将流中元素反复结合起来，得到一个值。

List<Employee> emps = Arrays.asList(
                new Employee(101,"张三",18,9999.99),
                new Employee(102,"李四",18,4444.66),
                new Employee(103,"王五",14,3000.99),
                new Employee(104,"赵六",55,20000.99),
                new Employee(105,"田七",66,55555.55),
                new Employee(106,"周八",77,99.99)
        );
    
        @Test
        public void test3(){
    
            //map 取出emps list 中所有名字，并打印出来
            emps.stream().map(Employee::getName).forEach(System.out::println);
            //map 把emps集合中所有人的名字取出来，放到新的list中
            List<String> collect = emps.stream().map(Employee::getName).collect(Collectors.toList());
    
            System.out.println("------------------------------------");
    
            //reduce 求和
            List<Integer> list = Arrays.asList(1, 2, 3, 4, 55, 56, 7, 78, 8, 9);
            Integer sum = list.stream().reduce(0, (x, y) -> x + y);
            System.out.println(sum);
    
            System.out.println("------------------------------------");
    
            //map reduce 计算所有工人的薪资总和
            Optional<Double> optional = emps.stream().map(Employee::getSalary).reduce(Double::sum);
            System.out.println(optional.get());
    
        }

Map和Reduce操作是函数式编程的核心操作，因为其功能，reduce 又被称为折叠操作。另外，reduce 并不是一个新的操作，你有可能已经在使用它。SQL中类似 sum()、avg() 或者 count() 的聚集函数，实际上就是 reduce 操作，因为它们接收多个值并返回一个值。流API定义的 reduceh() 函数可以接受lambda表达式，并对所有值进行合并。IntStream这样的类有类似 average()、count()、sum() 的内建方法来做 reduce 操作，也有mapToLong()、mapToDouble() 方法来做转换。这并不会限制你，你可以用内建方法，也可以自己定义。在这个Java 8的Map Reduce示例里，我们首先对所有价格应用 12% 的VAT，然后用 reduce() 方法计算总和。

// 为每个订单加上12%的税
    // 老方法：
    List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
    double total = 0;
    for (Integer cost : costBeforeTax) {
        double price = cost + .12*cost;
        total = total + price;
    }
    System.out.println("Total : " + total);
    
    // 新方法：
    List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
    double bill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get(); System.out.println("Total : " + bill);

### 4.4 过滤一个String列表 ###

流提供filter方法，过滤。

过滤是Java开发者在大规模集合上的一个常用操作，而现在使用lambda表达式和流API过滤大规模数据集合是惊人的简单。流提供了一个 filter() 方法，接受一个 Predicate 对象，即可以传入一个lambda表达式作为过滤逻辑。下面的例子是用lambda表达式过滤Java集合，将帮助理解。

// 创建一个字符串列表，每个字符串长度大于2
    List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
    System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);

### 4.5 去重 distinct ###

流的 distinct() 方法来对集合进行去重：

// 用所有不同的数字创建一个正方形列表
    List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
    List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
    System.out.printf("Original List : %s, Square Without duplicates : %s %n", numbers, distinct);

输出：

Original List : [9, 10, 3, 4, 7, 3, 4],  Square Without duplicates : [81, 100, 9, 16, 49]

### 4.6 计算集合的最大值、最小值、总和以及平均值 ###

IntStream、LongStream 和 DoubleStream 等流的类中，有个非常有用的方法叫做 summaryStatistics() 。可以返回 IntSummaryStatistics、LongSummaryStatistics 或者 DoubleSummaryStatistic s，描述流中元素的各种摘要数据。在本例中，我们用这个方法来计算列表的最大值和最小值。它也有 getSum() 和 getAverage() 方法来获得列表的所有元素的总和及平均值。

//获取数字的个数、最小值、最大值、总和以及平均值
            List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
            IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics(); System.out.println("Highest prime number in List : " + stats.getMax()); System.out.println("Lowest prime number in List : " + stats.getMin()); System.out.println("Sum of all prime numbers : " + stats.getSum()); System.out.println("Average of all prime numbers : " + stats.getAverage());

输出：

Highest prime number in List : 29
    Lowest prime number in List : 2
    Sum of all prime numbers : 129
    Average of all prime numbers : 12.9

## 五、小结 ##

java 越来越好！

近些年来，java更新的越来越好。通过新特性的学习，以后就可以更加高效率的写代码了。

[http_blog.csdn.net_kisscatforever_article_details_79572194]: http://blog.csdn.net/kisscatforever/article/details/79572194
[Image 1]:

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

【java8】java新特性（二）——lambda表达式

相关文章