精华内容
下载资源
问答
  • lambda

    2018-05-13 12:14:00
    一、引入lambda 定义:lambda就是简化了匿名内部类 使用前提:安装JDK 8 ...筛选出集合内大于50的数 普通Java代码实现 public static void main(String[] args) { List<Integer> lis...
        

    一、引入lambda

    定义:lambda就是简化了匿名内部类

    使用前提:安装JDK 8

    通过一个Example一步一步来达到lambda表达式的相关 :

    筛选出集合内大于50的数
    • 普通Java代码实现
      public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                Random random = new Random();
                int nextInt = random.nextInt(100) + 1;
                list.add(nextInt);
            }
            System.out.println("原:" + list);
            System.out.println("筛选出大于50的数");
            filter(list);
        }
        
        public static void filter(List<Integer> list) {
            for (Integer integer : list) {
                if (integer > 50) {
                    System.out.println(integer);
                }
            }
        }
    
    • 匿名类部类实现
      public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                Random random = new Random();
                int nextInt = random.nextInt(100) + 1;
                list.add(nextInt);
            }
            System.out.println("原:" + list);
            
            Checker checker = new Checker() {
                @Override
                public boolean check(Integer i) {
                    return i > 50;
                }
            };
            filter(list, checker);
        }
        public static void filter(List<Integer> list, Checker checker) {
            for (Integer integer : list) {
                if (checker.check(integer)) {
                    System.out.println(integer);
                }
            }
        }
    
        // Checker接口
        public interface Checker {
            public boolean check(Integer i);
        }
    
    
    • 一步一步演变成lambda表达式
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                Random random = new Random();
                int nextInt = random.nextInt(100) + 1;
                list.add(nextInt);
            }
            Checker c1 = new Checker() {
                @Override
                public boolean check(Integer i) {
                    return i > 50;
                }
            };
            System.out.println("筛选出大于50的数--->1");
            filter(list, c1);
            
            Checker c2 = (Integer i) -> { return i > 50; };
            System.out.println("筛选出大于50的数--->2");
            filter(list, c2);
            
            Checker c3 = (Integer i) -> i > 50;
            System.out.println("筛选出大于50的数--->3");
            filter(list, c3);
            
            Checker c4 = i -> i > 50;
            System.out.println("筛选出大于50的数--->4");
            filter(list, c4);
            
            System.out.println("筛选出大于50的数--->5");
            filter(list, i -> i > 50);
            
            List<Integer> is = list.stream().filter(i -> i > 50).collect(Collectors.toList());
            System.out.println(is);
        }
        
        public static void filter(List<Integer> list, Checker checker) {
            for (Integer integer : list) {
                if (checker.check(integer)) {
                    System.out.println(integer);
                }
            }
        }
    
    总结
    1.匿名类的正常写法
        Checker checker = new Checker() {
            @Override
            public boolean check(Integer i) {
                return i > 50;
            }
        };
    
    2. 把外面的壳子去掉,只保留方法参数和方法体,参数和方法体之间加上符号 ->
        Checker c2 = (Integer i) -> { return i > 50; };
    
    3. 把return和{}去掉
        Checker c3 = (Integer i) -> i > 50;
    
    4. 去掉参数小括号,得到Lambda表达式
        Checker c4 = i -> i > 50;
    

    排序例子

        //TODO 匿名类部类
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        
        // TODO lambda表达式
        Collections.sort(list, (o1, o2) -> o1.compareTo(o2));
    

    二、聚合操作

    遍历: 传统方式与聚合操作遍历数据

        List<Integer> list = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            int nextInt = random.nextInt(100) + 1;
            list.add(nextInt);
        }
        
        // TODO 传统方式for循环遍历数据
        for (Integer itg : list) {
            if (itg > 50) {
                System.out.println(itg);
            }
        }
        
        // TODO 聚合操作遍历数据
        list.stream().filter(itg -> itg > 50).forEach(itg -> System.out.println(itg));
        
        // TODO lambda的方法引用(简介: 静态方法、对象方法等等的引入)
        list.stream().filter(itg -> itg > 50).forEach(System.out::println);
    

    Stream和管道的概念

    1. Stream: Stream是一系列元素, 象生产线上的罐头, 一罐一罐的生产出来
    2. 管道: 是指一系列聚合操作, 分为:管道源、中间操作、结束操作。

    管道源:在前面的例子里面,管道源是list集合

    • 将Collection切换到管道源只需要调用stream()方法即可:
        list.stream();
    
    • 数组却没有stream()方法,需要使用:
        int[] arr = {1, 2, 3, 4};
        Arrays.stream(arr).forEach(System.out::println);
    

    中间操作:也叫‘懒’操作,并不会进行变量,每一步中间操作都会返回一个Stream对象

    • 对元素进行筛选

      • filter 匹配
      • distinct 去除重复(根据equals判断)
      • sorted 自然排序
      • sorted(Comparator<T>) 指定排序
      • limit 保留
      • skip 忽略
    • 转换为其他形式的流

      • mapToDouble 转换为double的流
      • map 转换为任意类型的流
        //TODO 去重排序打印
        list.stream().distinct().sorted().forEach(System.out::println);
        
        //TODO 保留前三个元素并打印
        list.stream().limit(3).forEach(System.out::println);
        
        //TODO 忽略前三个
        list.stream().skip(3).forEach( System.out::println);
        
        //TODO 转换任意类型的Stream
        list.stream().map(itg -> itg + "-hello").forEach( System.out::println);
    

    结束操作: 结束操作不会返回Stream,但是会返回int、float、String、 Collection或者像forEach或者什么都不返回

    • forEach() 遍历每个元素
    • toArray() 转换为数组
    • min(Comparator<T>) 取最小的元素
    • max(Comparator<T>) 取最大的元素
    • count() 总数
    • findFirst() 第一个元素
      // 遍历集合中的每个数据
      list.stream().forEach(h->System.out.print(h));
    
      // 返回一个数组
      Object[] array= list.stream().toArray();
    
      // 返回最小值
      Integer integer = list.stream().min((a1, a2) -> a1.compareTo(a2)).get();
    
      // 返回最大值
      Integer integer = list.stream().max((a1, a2) -> a1.compareTo(a2)).get();  
    
      // 数据的总数
      long count = list.stream().count();
    
      // 第一个元素
      Integer integer = list.stream().findFirst().get();
    
    展开全文
  • Lambda

    2020-04-15 13:23:27
    为什么会有这个lambda表达式这个新特性? 这里有2个比较兴起的概念:面向函数编程、行为参数化。我说一下行为参数化这个概念,其实网上有很多案例了,毕竟经典的就是筛选重量150G、颜色为绿色的苹果,其实这里面最...

    起因

    为什么会有这个lambda表达式这个新特性?

    这里有2个比较兴起的概念:面向函数编程、行为参数化。我说一下行为参数化这个概念,其实网上有很多案例了,毕竟经典的就是筛选重量150G、颜色为绿色的苹果,其实这里面最重要的业务逻辑就是重量是否大于150G,颜色是否为绿色,其他代码都是多余的代码,例如嵌套在外面的for循环。

    行为参数化就是把这套业务逻辑判断作为一个参数,来传递到其他方法里面,这跟之前相差很大的,因为之前必须先定义方法,然后再把方法结果传递到其他参数,相当于只能传递某个函数的结果,而行为参数化则是把方法的逻辑传递过去,这样代码更加简洁。

    因此,这才是lambda受关注的原因。

    函数式接口

    函数式接口也叫做功能性接口,其特点就是接口只包含一个方法。只要接口符合函数式接口的标准,虚拟机会自动判断为函数式接口, 但最好在接口上使用注解@FunctionalInterface进行声明来避免其他开发人员新增其他方法。Lambda表达式允许你直接以内联的形式作为函数式接口的抽象方法的实现,并把整个表达式作为函数式接口的实例(具体说来,是函数式接口一个具体实现的实例)。

    lambda表达式

    lambda表达式无法单独出现,其必须要一个函数式接口来盛放, lambda表达式方法体其实就是函数接口的实现。

    Lambda语法包含3个部分:

    ①一个括号内用逗号分隔的形式参数,参数是函数式接口里面方法的参数。②一个箭头符号:->。③方法体,可以是表达式和代码块, 方法体是函数式接口里面方法的实现,如果是代码块则必须用{}来包裹起来且需要一个return返回值,但函数式接口里面方法返回值是void则无需{}。

    总结起来就是:(parameters) -> expression 或者 (parameters) -> { statements; }

    类型检查

    其实说白了,现在是面向接口编程,这就导致了接口与lambda是捆绑出现的,那JAVA是如何根据lambda来确定其代表哪个函数式接口呢?

    答案就是函数描述符,函数式接口中其方法的参数类型、参数顺序、参数数量、返回值形成该函数式接口方法的函数描述符,只要lambda对应的参数类型、参数顺序、参数数量、返回值与函数式接口保持一致,则就可以认为该lambda就是该接口的某个实例,总结为一句话:Lambda表达式的签名要和函数式接口的抽象方法一样。

    如果一个Lambda的主体是一个语句表达式,它就和一个返回void的函数描述符兼容。

    类型推断

    既然JAVA编译器能通过函数描述符知道该lambda所对应的函数式接口,那么JAVA编译器也能知道当前lambda表达式的函数签名,进而知道lambda表达式的参数类型等信息,进一步简化lambda表达式:

    (int a1, int a2) -> a1>a2;

    (a1, a2) -> a1>a2;

    虽然这2种方式都支持,至于哪个方式更好,看个人选择吧,我还是更喜欢第一种。

    使用局部变量

    Lambda表达式也可以像匿名类一样使用外部变量,被使用的变量又被叫做捕获Lambda。Lambda可以没有限制地捕获实例变量和静态变量,但局部变量必须显式声明为final或事实上是final。

    至于原因,假如在一个thread中使用lambda表达式去访问某个局部变量,可能存在该局部变量所对应的线程被回收之后,这个lambda再去访问该局部变量,这种情况下lambda访问的是该局部变量的副本,如果局部变量仅仅赋值一次那就没有什么区别了,因此就有了这个限制。

    另外就是JAVA官方不鼓励开发者使用改变外部变量的典型命令式编程模式,因为局部变量保存在栈中,一个线程都有自己的栈,且不允许其他人来访问。

    方法引用

    Lambda表达式其实还可以继续简化代码,这种方式叫做:方法引用。方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法。它的基本思想是:如果一个Lambda代表的只是“直接调用这个方法”,那最好还是用名称来调用它,而不是去描述如何调用它。而事实上,方法引用就是让你根据已有的方法实现来创建Lambda表达式。

    这里的方法特指的就是lambda表达式的方法体实现,语法格式为:类名/实例名::方法名。

    除去函数式接口的方法,还可以引用一般方法,其引用格式如下:

    ①静态方法则是ClassName::methodName。

    例如:(args)->ClassName.staticMethod(args),其方法引用为:ClassName::staticMethod。

    ②实例方法则是Instance::methodName。这里又可以分为2种情况:指向任意类型实例方法的方法引用、指向现有对象的实例方法的方法引用。

    指向任意类型实例方法的方法引用:可以理解为引用一个对象的实例方法且这个对象本身是Lambda的一个参数,这种情况下方法引用为:ClassName::methodName。

    例如:(arg1,arg2)->arg1.instanceMethod(arg2),其方法引用为:arg1对应的ClassName::instanceMethod。

    指向现有对象的实例方法的方法引用:在Lambda中调用一个已经存在的外部对象中的方法,这种情况下方法引用为:Instance::methodName。

    例如:(args)->expr.instanceMethod(args),其方法引用为:expr::instanceMethod。

    ③构造函数则是ClassName::new。

    针对有参构造函数可以这么写:

    Function<Integer, Apple> c2 = Apple::new;

    Apple a2 = c2.apply(110);

    等价于

    Function<Integer, Apple> c2 = (weight) -> new Apple(weight);

    Apple a2 = c2.apply(110);

    展开全文
  • {'sid': 30, 'et': 8}] 我想用以下条件筛选表:(sid=22 & et>=10) and (sid=30 & et>=8) 但目前它的做法是平等的(sid=22 & et=10) and (sid=30 & et=8) 对于每组(sid,et)的et值,如何在lambda表达式中使用大于?...

    我在reinstdb表中有下面的json记录。在[{

    "pid": 12,

    "sk": [

    {

    "sid": 30,

    "et": 3

    },

    {

    "sid": 22,

    "et": 10

    },

    {

    "sid": 30,

    "et": 8

    }

    ],

    "wc": [

    {

    "wid": 7,

    "et": 8

    },

    {

    "wid": 3,

    "et": 6

    },

    {

    "wid": 9,

    "et": 7

    }

    ]

    }]

    像这个,我在表中有数百万行。

    我们试图实现的是根据{sid,et}的输入集过滤这个json

    我在python中使用以下代码(skObj是输入):

    ^{pr2}$

    上面的查询根据sk的输入集正确地过滤了reinstdb中的cube7表。

    skObj最多可以包含10个集合。在

    我希望看到的是每个输入集skObj=[{'sid': 22, 'et': 10},{'sid': 30, 'et': 8}]

    我想用以下条件筛选表:(sid=22 & et>=10) and (sid=30 & et>=8)

    但目前它的做法是平等的(sid=22 & et=10) and (sid=30 & et=8)

    对于每组(sid,et)的et值,如何在lambda表达式中使用大于?在

    如何从下面创建泛型表达式-这适用于原始数据lambda x: (x['sid'] == 22) & (x['et'] >= 10)

    展开全文
  • ProPercentNum.append(int(np.sum(list(map(lambda x: x >= j and x < i, MsProduct))))) 其中MsProduct是列表数据 所以python lambda表达式怎么用 例子: 比如一个python求平方的函数 def f(x): ...
    ProPercentNum.append(int(np.sum(list(map(lambda x: x >= j and x < i, MsProduct)))))

    其中MsProduct是列表数据 

    所以python lambda表达式怎么用

    例子:

    比如一个python求平方的函数

    def f(x):
        return x * x
    
    print(f(5))

    使用lambda表达式怎么写?

    f = lambda x: x* x
    
    print(f(5))

    输入两个数可以吗:

    例如:

    def g(x,y):
        return x + y 

    其实也是可以的

    使用lambda表达式写成

    g = lambda x,y : x + y

    所以,lambda表达式格式 名称= lambda 变量0,变量1: 操作变量 要必须有的是lambda和冒号。

    lambda的符合函数

    例子:

    def quadratic(a,b,c):
        return lambda x: a*x*x + b*x + c
    f = quadratic(1,-1,2)
    print(f(5))

    这个就是符合函数的用法,当然也可以不用f

    def quadratic(a,b,c):
        return lambda x: a*x*x + b*x + c
    
    print(quadratic(1,-1,2)(5))

    这样也是可以的

    字典中嵌入lambda表达式

    Msdic2 = {(lambda k: k-1 if (k > 0) else k) :[v[0], v[1]-blogmin] for k,v in Msdic.items()}

     

    展开全文
  • lambda表达式

    2020-06-21 18:49:17
    lambda表达式是java8的新特性,lambda表达式支持将代码块...)必须通过英文中划线和大于符号组成。 3代码块。如果代码块只包含一条语句,lambda表达式允许省略代码块的花括号,那么这条语句就不要用花括号表示语句结
  • Lambda表达式

    2019-04-28 16:07:29
    ”,等于号右边连着大于号。运算符“=>”具有和赋值运算符(=)相同的优先级,并且是右结合运算符。Lambda表达式最常用的便是用于替换Linq查询语句,相当于是Linq查询的简写形式,虽然写法大相径庭,但它们查询出的...
  • 在使用boost::lambda时,编译器找不到_4、_5、_6、_7、_8、_9,即在lambda命名空间内只能找到编号不大于3的placeholder。而boost::bind库却可以使用9个placeholder。 我试过清空重新编译、建立其他工程编译,都不行...
  • Lambda笔记

    2020-11-21 22:31:03
    :由英文中画线和大于符号组成,固定写法。代表指向动作 代码块:是具体要做的事情,也就是方法体内容 3.Lambda表达式练习 Lambda表达式使用前提: 有一个接口 接口中有且仅有一个抽象方法 练习1: 定义一个...
  • 本身对lambda没有涉及,这个小技巧简单记录下,方便以后用。 int[] scores = { 90, 71, 82, 93, 75, 82 }; // The call to Count forces iteration of the source int highScoreCount = scores.Where(n => n &...
  • Lambda 表达式

    2019-07-27 15:24:27
    Lambda 表达式简化了函数式接口匿名内部类的语法。 其表达式语法如下:([参数1], [参数2], [参数3],.... [参数n])->{代码块} //注意那是减号和大于号 例如: //匿名内部类 public interface IComputer { ...
  • Lambda表达式总结

    2019-09-06 19:13:22
    Lambda表达式总结 (一)Lambda表达式 ...输入参数的数量大于或者等于2时,Lambda表达式左边的一对小括弧中的多个参数质检使用逗号(,)分割。 例1、用lambda表达式实现Runnable 我开始使用Java 8时,首...
  • Lambda表达式详细总结

    千次阅读 2016-06-01 22:20:31
    (一)输入参数 ...输入参数的数量大于或者等于2时,Lambda表达式左边的一对小括弧中的多个参数质检使用逗号(,)分割。 示例1 下面创建一个Lambda表达式,它的输入参数的数量为0.该表达式将显示“This i
  • Lambda拉姆达表达式

    万次阅读 2018-04-03 16:36:35
    输入参数的数量大于或者等于2时,Lambda表达式左边的一对小括弧中的多个参数质检使用逗号(,)分割。示例1下面创建一个Lambda表达式,它的输入参数的数量为0.该表达式将显示“This is a Lambda e...
  • 让你介绍lambda表达式:介绍+语法+举例(后面不需要介绍)lambda表达式介绍lambda表达式重写了函数式接口中的唯一抽象方法。函数内部实现中以接口.方法的形式调用,只是外部传入时可以无需理会对象约束,直接传入...
  • Lambda表达式入门

    2019-06-09 15:28:46
    一点睛 Lambda表达式支持将代码块作为方法参数,Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口(函数式接口)的实例。 Lambda表达式主要作用就是代替...),必须通过英文等号和大于符号组成。 ...

空空如也

空空如也

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

lambda大于