精华内容
下载资源
问答
  • lambda表达式是jdk8中新增的特性,用于取代大部分的匿名内部类,使代码更加简洁。jdk8之前常使用匿名类: new Thread(new Runnable() { @Override public void run() { System.out.println("线程:"+Thread.current...

    lambda表达式是jdk8中新增的特性,用于取代大部分的匿名内部类,使代码更加简洁。

    jdk8之前常使用匿名类:

     new Thread(new Runnable() { @Override public void run() { System.out.println("线程:"+Thread.currentThread().getName()); } });

    jdk8新增的lambda表达式:

     //使用lambda表达式代替匿名类new Thread(()->System.out.println("线程:"+Thread.currentThread().getName()));
    7955c38c4a34b929193c323f835cd4c5.png

    IDEA自动提示使用Lambda表达式

    Lambda表达式语法:

    lambda表达式是函数式编程,所谓函数式编程就是将函数(一段操作)作为一个基本单位进行传递。以前的Java中参数只能是具体的变量,函数式编程打破这一规范,可以将整个方法作为一个参数传递。

    () -> {}();(参数类型 参数名称) -> { 代码语句 };//小括号里无参数则留空(),有一个参数括号可以省略,多个参数用逗号隔开

    lambda表达式的类型必须是函数式接口。

    函数式接口:

    有且仅有一个抽象方法的接口。(详情见上文:java知识总结(三):函数式接口)

    方法引用:

    方法引用:使用操作符 “ ::” 将方法名和对象或类的名字分隔开来。主要有:对象::实例方法 类::静态方法 类::实例方法
    c5b8258ed4147b2c0eff205c5d1268be.png

    对象::实例方法

    03e41c194065b2d1bbaedb29b4579ddf.png

    类::静态方法 、类::实例方法

    Lambda实例:

    //1.遍历list输出对象的值 public static void main(String[] args){ List list = Arrays.asList("test1", "test2", "test3", "test4", "test5"); list.forEach(s-> System.out.print(s+",")); }//输出结果:test1,test2,test3,test4,test5,
    public class GoodsInfo { private String sku; private Long price; GoodsInfo(String sku ,Long price){this.sku = sku;this.price = price;} public String getSku() {return sku;} public void setSku(String sku) {this.sku = sku; } public Long getPrice() {return price;} public void setPrice(Long price) {this.price = price;}//2.遍历获取List的sku列表   List goodsInfos = Arrays.asList(new GoodsInfo("001",100L),new GoodsInfo("002",200L),new GoodsInfo("003",300L)); List skuList = goodsInfos.stream().map(GoodsInfo::getSku).collect(Collectors.toList());

    总结:

    1. lambda表达式是函数式编程
    2. lambda的语法是() -> {}();
    3. lambda表达式的类型必须是函数式接口
    354140d91f9472b2189dc28ea5345b0d.png

    采菊东篱下,悠然见南山

    饮酒(其五) 陶渊明

    结庐在人境,而无车马喧。

    问君何能尔,心远地自偏。

    采菊东篱下,悠然见南山。

    山气日夕佳,飞鸟相与还。

    此中有真意,欲辨已忘言。

    写作的过程其实是一个剖析自己内心的过程,它会一点点把你掌握的知识揉碎并挤入到你的脑海里去,消化吸收。一点一滴,汇聚成江河,梳理清楚大地的脉络。

    展开全文
  • Lambda表达式

    2021-01-22 00:21:09
    Lambda表达式 在之前的多线程学习中我们使用到了lambda表达式来简化代码,现在我们来具体讲一讲它的用法。(我们以往都是通过创建 Thread 对象,然后通过匿名内部类重写 run() 方法,一提到匿名内部类我们就应该想到...

    Lambda表达式

    在之前的多线程学习中我们使用到了lambda表达式来简化代码,现在我们来具体讲一讲它的用法。(我们以往都是通过创建 Thread 对象,然后通过匿名内部类重写 run() 方法,一提到匿名内部类我们就应该想到可以使用 lambda 表达式来简化线程的创建过程。)

    Lambda简介

    Lambda 表达式是 JDK8 的一个新特性,可以取代大部分的匿名内部类,写出更优雅的 Java 代码,尤其在集合的遍历和其他集合操作中,可以极大地优化代码结构。

    JDK 也提供了大量的内置函数式接口供我们使用,使得 Lambda 表达式的运用更加方便、高效。

    对接口的要求:虽然使用 Lambda 表达式可以对某些接口进行简单的实现,但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法,不是规定接口中只能有一个方法。(jdk 8 中有另一个新特性:default, 被 default 修饰的方法会有默认实现,不是必须被实现的方法,所以不影响 Lambda 表达式的使用。)

    @FunctionalInterface

    修饰函数式接口的,要求接口中的抽象方法只有一个。 这个注解往往会和 lambda 表达式一起出现。

    语法形式

    为 () -> {},其中 () 用来描述参数列表,{} 用来描述方法体,-> 为 lambda运算符 ,读作(goes to)。

    下面这段代码可以跟着序号逐步观察推导过程,代码的简化(工资按代码量计算真的不合理)

    定义一个接口,定义实现类实现接口、静态内部类实现接口、局部内部类实现接口、匿名内部类实现接口、Lambda表达式实现接口,这些方法一步步让代码变简单。

    package TreadTest.Lambda;
    
    /*
    推导lambda表达式
     */
    public class TestLambda {
        //3.静态内部类
        static class Like2 implements ILike
        {
            @Override
            public void lambda() {
                System.out.println("i like lambda2");
            }
        }
    
        public static void main(String[] args) {
            ILike iLike = new Like();
            iLike.lambda();
    
            iLike = new Like2();
            iLike.lambda();
    
            //4.局部内部类
            class Like3 implements ILike
            {
                @Override
                public void lambda() {
                    System.out.println("i like lambda3");
                }
            }
            iLike = new Like3();
            iLike.lambda();
    
            //5.匿名内部类
            iLike = new ILike() {
                @Override
                public void lambda() {
                    System.out.println("i like lambda4");
                }
            };
            iLike.lambda();
    
            //6.lambda简化
            iLike = ()->{
                System.out.println("i like lambda5");
            };
            iLike.lambda();
        }
    }
    
    //1。定义一个接口
    interface ILike{
        void lambda();
    }
    
    //2.实现类
    class Like implements ILike
    {
        @Override
        public void lambda() {
            System.out.println("i like lambda");
        }
    }
    
    
    

    下面这段代码展示了Lambda表达式的进一步简化规则

    package TreadTest.Lambda;
    
    public class TestLambda2 {
        public static void main(String[] args) {
    
            //1.lambda表示简化
            ILove love = (int a)->{
                System.out.println("I love lambda"+a);
            };
            //简化1.参数类型
             love = (a)->{
                System.out.println("I love lambda"+a);
            };
            //简化2.简化括号
            love = a->{
                System.out.println("I love lambda"+a);
            };
            //简化3.去掉花括号(只有一行代码时才能简化)
            love = a-> System.out.println("I love lambda"+a);
    
            love.lambda(520);
            //总结:
            //   1.接口是函数式接口,接口里面只有一个方法(runnable接口符合这一点)
            //   2.多个参数也可以去掉参数类型,但要去掉就全去掉,必须加括号
        }
    }
    
    //1。定义一个接口
    interface ILove{
        void lambda(int a);
    }
    

    lambda表达式是代替匿名类简化代码的神器,它也有跟多功能值得我们了解比如引用方法、引用构造方法、在Stream流式编程中的用法等等。下面这篇博客有兴趣可以看看。

    学习参考:

    https://www.cnblogs.com/haixiang/p/11029639.html

    这篇博客讲的更多更详细,值得学习

    展开全文
  • Lambda 表达式

    2020-11-23 14:31:45
    Lambda 表达式 - 什么是 Lambda 表达式:实质属于函数式编程的概念 (params) -> expression [表达式] (params) -> statement [语句] (params) -> {statement} 举例:new Thread(() -> System....

    Lambda 表达式

    - 什么是 Lambda 表达式:实质属于函数式编程的概念
    	(params) -> expression [表达式]
    		(params) -> statement [语句]
    			(params) -> {statement}
    	 举例:new Thread(() -> System.out.printlin("多线程学习....")).start();
    - 为什么需要使用 Lambda 表达式
    - 好处:
    	1. 避免匿名内部类定义过多
    	2. 可以让你的代码看起来很简洁
    	3. 去掉了一堆没有意义的代码,只留下核心的逻辑。  
    - 使用条件:必须是函数式接口才可以使用 Lambda
    	什么是函数式接口:
    		任何接口,如果只包含了唯一一个抽象方法,那么它就是一个函数式接口。
    		public interface Runnable{
    			public abstract void run();
    		}
    
    package com.baiyi.lambda;
    
    /**
     * @author 白衣
     * @Description: lambda 表达式的推导
     * @Date 2020/11/22
     */
    public class Lambda {
        // 3. 静态内部类
        static class Like2 implements ILike{
            @Override
            public void lambda() {
                System.out.println("i like lambda2");
            }
        }
    
        public static void main(String[] args) {
            ILike like = new Like();
            like.lambda();
    
            like = new Like2();
            like.lambda();
    
            // 4. 局部内部类
            class Like3 implements ILike{
                @Override
                public void lambda() {
                    System.out.println("i like lambda3");
                }
            }
    
            like = new Like3();
            like.lambda();
    
            // 5. 匿名内部类
            like = new ILike() {
                @Override
                public void lambda() {
                    System.out.println("i like lambda4");
                }
            };
            like.lambda();
    
            // 6. jdk 1.8 lambda 表达式
            like = () -> {
                System.out.println("i like lambda5");
            };
            like.lambda();
        }
    }
    
    // 1. 定义一个 函数式接口
    interface ILike{
        void lambda();
    }
    
    //2. 实现类
    class Like implements ILike{
        @Override
        public void lambda() {
            System.out.println("i like lambda");
        }
    }
    
    展开全文
  • 例1 用Lambda表达式实现Runnable接口Java代码//BeforeJava8:newThread(newRunnable(){@Overridepublicvoidrun(){System.out.println("BeforeJava8,toomuchcodefortoolittletodo");}}).start();//Java8way:ne...

    例1 用Lambda表达式实现Runnable接口

    Java代码

    //Before 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 way:

    new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();

    输出:

    too much code, for too little to do

    Lambda expression rocks !!

    这个例子使我们学到了java8中Lambda表达式的书写方式:

    (参数) -> 表达式

    (参数) -> 语句

    (参数) -> { 语句 }

    例如,如果你的方法只是在控制台打印信息,则可以这么写:

    Java代码

    () -> System.out.println("Hello Lambda Expressions");

    如果你的方法接收两个参数,那么:

    Java代码

    (int even, int odd) -> even + odd

    顺带提一句,一般来说在Lambda表达式中要尽量保持变量的简洁性。这会使你的代码简短而能保持在一行之内。所以像上面的代码可以选择变量名类似a,b或者x,y之类的,比起even和odd来会更好。

    例2 用Lambda表达式写事件监听程序

    要是你用过Swing API,那就少不了事件监听代码,这是使用匿名类的经典例子。现在我们可以用Lambda表达式来抒写更好的事件处理代码。

    Java代码

    // Before Java 8:

    JButton show = new JButton("Show");

    show.addActionListener(new ActionListener() {

    @Override

    public void actionPerformed(ActionEvent e) {

    System.out.println("Event handling without lambda expression is boring");

    }

    });

    // Java 8 way:

    show.addActionListener((e) -> {

    System.out.println("Light, Camera, Action !! Lambda expressions Rocks");

    });

    另外一个常用匿名类的地方是给Collections.sort()方法提供自定义的Comparator接口实现。这个地方也可以用Lambda表达式。

    例3 用Lambda表达式进行List迭代

    Java代码

    //Prior Java 8 :

    List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");

    for (String feature : features) {

    System.out.println(feature);

    }

    //In Java 8:

    List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");

    features.forEach(n -> System.out.println(n));

    // 用java8的方法引用更好,方法引用由::(双冒号)操作符来完成,看起来像c++中的作用域操作符

    Java代码

    features.forEach(System.out::println);

    输出:

    Lambdas

    Default Method

    Stream API

    Date and Time API

    例4 使用Lambda表达式和函数式接口Predicate

    除了提供函数式编程语言级别的支持外,java8同时也新增了一个新的包java.util.function。其中包含了许多类来支持java函数式编程。其中之一是Predicate接口,使用这个接口和lamb表达式就可以以更少的代码为API方法添加更多的动态行为。

    以下是Predicate的使用范例,展示了过滤集合数据的许多共性。

    Java代码

    public static void main(args[]){

    List languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");

    System.out.println("Languages which starts with J :");

    filter(languages, (str)->str.startsWith("J"));

    System.out.println("Languages which ends with a ");

    filter(languages, (str)->str.endsWith("a"));

    System.out.println("Print all languages :");

    filter(languages, (str)->true);

    System.out.println("Print no language : ");

    filter(languages, (str)->false);

    System.out.println("Print language whose length greater than 4:");

    filter(languages, (str)->str.length() > 4);

    }

    public static void filter(List names, Predicate condition) {

    for(String name: names) {

    if(condition.test(name)) {

    System.out.println(name + " ");

    }

    }

    }

    输出:

    Languages which starts with J :

    Java

    Languages which ends with a

    Java

    Scala

    Print all languages :

    Java

    Scala

    C++

    Haskell

    Lisp

    Print no language :

    Print language whose length greater than 4:

    Scala

    Haskell

    Java代码

    //更佳的方式

    public static void filter(List names, Predicate condition) {

    names.stream().filter((name) -> (condition.test(name))).forEach((name) -> {

    System.out.println(name + " ");

    });

    }

    可以看到Stream API的filter方法也接受一个Predicate,意味着可以用内联代码直接替换我们自定义的filter()方法。这就是Lambda表达式的威力所在。除此之外Predicate接口也可以测试多个条件,将会在下面的例子中加以说明。

    例5: Lambda表达式结合Predicate

    就像上个例子所说,Predicate允许组合两个以上的条件,它提供了类似于逻辑与和或的操作and(),or()和xor(),这些方法可以用来组合传递到filter方法中的多个条件。例如为了获取所有以J开头并有四个字符长度的语言,可以定义两个单独的Predicate实例覆盖每个条件然后用and方法将他们组合在一起。看例子:

    Java代码

    Predicate startsWithJ = (n) -> n.startsWith("J");

    Predicate fourLetterLong = (n) -> n.length() == 4;

    names.stream().filter(startsWithJ.and(fourLetterLong)).forEach((n) -> System.out.print("\nName, which starts with 'J' and four letter long is : " + n));

    类似可以用or或者xor。这个例子也强调了单独用或者按需组合用Predicate的重要性。简而言之用Predicate和Lambda表达式的优势你可以写的更少做得更多。

    例6 Map和Reduce的例子

    6.1 Map

    在这个例子中,我们要将costBeforeTax的每个元素以加上他们的增值税。传递一个Lambda表达式给map方法使之应用于每个元素,之后在用forEach打印结果。

    Java代码

    // Without lambda expressions:

    List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);

    for (Integer cost : costBeforeTax) {

    double price = cost + .12*cost;

    System.out.println(price);

    }

    // With Lambda expression:

    List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);

    costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);

    输出

    112.0

    224.0

    336.0

    448.0

    560.0

    112.0

    224.0

    336.0

    448.0

    560.0

    6.2 Reduce

    还有另外一个函数reduce可以将所有值转换为一个值。map跟reduce操作是函数式编程的核心,reduce也被称作折叠操作。reduce并不是一种新的操作,在SQL中我们用的一些聚集函数比如sum,avg,count等他们实际上也是reduce操作,因为他们也是将多个值进行操作然后返回一个值。Stream API定义了reduce函数,可以接受一个Lambda表达式然后组合所有值。Stream类中像IntStream都有内置的方法像average(), count(), sum(), mapToLong(), mapToDouble()等转换方法。我们可以用内置的方法也可以自定义。

    Java代码

    // Old way:

    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);

    // New way:

    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);

    输出

    Total : 1680.0

    Total : 1680.0

    例7 用filter创建一个字符串List

    在java开发中对大的集合进行过滤是常用的操作。用Lambda表达式和Stream API会让操作变得简单易懂。

    Stream提供了一个filter()方法,接受一个Predicate对象。这意味着可以传递一个Lambda表达式作为过滤逻辑,看例子:

    Java代码

    //创建一个长度大于两个字符的字符串List

    List filtered = strList.stream().filter(x -> x.length()>

    2).collect(Collectors.toList());

    System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);

    输出 :

    Original List : [abc, , bcd, , defg, jk], filtered list : [abc, bcd, defg]

    例8给每个List元素应用函数

    在工作中我们经常会碰到这样的情况:给List中每个元素加以一定的操作例如乘以或者除以某个值等。这些操作用map方法再好不过了,我们可以将转换逻辑以Lambda表达式传给map方法来应用于每个元素:

    //将字符串转为大写然后用逗号连起来

    Java代码

    List G7 = Arrays.asList("USA", "Japan", "France", "Germany", "Italy","U.K.","Canada");

    String G7Countries = G7.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));

    System.out.println(G7Countries);

    输出:

    USA, JAPAN, FRANCE, GERMANY, ITALY, U.K., CANADA

    例9 复制不同值到子列表

    本例演示如何利用Stream类的distinct方法过滤重复值到集合中。

    Java代码

    List numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);

    List 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]

    例10计算List中元素的最大,最小,和以及平均值

    在Stream类中像IntStream, LongStream and DoubleStream有一个非常有用的方法summaryStattics(),返回IntSummaryStatistics, LongSummaryStatistics or DoubleSummaryStatistics其描述了这个流中元素的统计数据。下面的例子中我们用这个方法来计算一个List中的最大最小值总和以及均值:

    Java代码

    List 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

    展开全文
  • 使用 lambda 表达式

    2014-02-24 20:14:38
     1.1 使用 lambda 表达式  Thread t = new Thread(()=>Print("Hello from t"));  t.Start();  使用这种方式可以响新线程传递任意个参数,甚至可以把方法到实现都放到 lambda 表达式中。  new ...
  • public static void main(String[] args) { /* * java 1.8之前我们定义的匿名类方式 */ new Thread(new Runnable() { @Override public void run() { ... * 使用lambda表达式替.
  • lambda表达式

    2018-10-19 19:41:55
    lambda表达式是java8中新加入的一个特性,可以在创建匿名内部类时使用,我们可以用lambda表达式完成匿名内部类时创建,例如开启新的线程以及实现一个监听器,下面将对比匿名内部类和lambda的写法。 我们可以通过...
  • Lambda表达式推导

    2019-07-26 09:31:00
    Lambda表达式由匿名内部类简化而来 在线程的简化中很常见 下面以实现runnable方法为例逐步由各种内部类推导转化为lambda表达式 1 package cn.ftf.thread; 2 /** 3 * Lambda表达式简化线程的使用Lamnda...
  • java——lambda表达式

    2020-06-25 09:40:57
    Lambda表达式的介绍 Lambda表达式是Java8中最重要的新功能之一.使用Lambda表达式可以代替只有一个抽象函数的接口实现,告别匿名内部类,代码看起来更简洁易懂.Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 930
精华内容 372
关键字:

lambda表达式thread