拉姆达表达式是什么_拉姆达

拉姆达表达式是什么_拉姆达Q:最近接触到Stream流式编程遇到了一些错误,故做一次总结复习用。一、λ表达式通常我们会用一个类实现接口,然后构造对象作为参数传入,也可以使用匿名类,用λ表达式可以简化匿名类的编写,用例如下。classWorkerimplementsRunnable{@Overridepublicvoidrun(){…

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

Q:最近接触到Stream流式编程遇到了一些错误,故做一次总结复习用。

一、λ表达式

通常我们会用一个类实现接口,然后构造对象作为参数传入,也可以使用匿名类,用λ表达式可以简化匿名类的编写,用例如下。

        class Worker implements Runnable {
        @Override
            public void run() {
            // TODO: 2019/6/2
            }
       }
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO: 2019/6/2
            }
        });
        Thread t1 = new Thread(new Worker());
        
        Thread t2 = new Thread(()->{
            // TODO: 2019/6/2
        });
λ表达式语法:
(String str,...)->{      }
 ()->{}
 ()-> System.out.println();
 表达式中引用的外部的变量,必须是   最终变量  final
 List<Integer> list = new LinkedList<>();
 list.forEach(System.out::println);//这里是类的静态方法,也可以是Object::instanceMethod,也可以是Class::instanceMethod
                                                                                        //  System.out::println== x->sout(x)      Math::pow == Math.pow(x,y)
也可以是  Class::new
        List<String> list = Arrays.asList("zhangsan","lisi");
        List<Person> res=  list.stream().map(Person::new).collect(Collectors.toList());
        System.out.println(res);
          //   [zhangsan, lisi]
 list.forEach(e-> System.out.println(e)); //只有一行可以省略花括号
Comparator<String> c =(f,fs)->f.length-fs.length;    //可推导出f  fs 必然是字符串等价于(String f, String  fs)则可以省略方法参数的类型
其中Comparator如下:
public interface Comparator<T> {
    int compare(T o1, T o2);
}




函数式接口
public static <T> void sort(T[] a, Comparator<? super T> c)
Integer[] array = new Integer[]{3,2,1};
Arrays.sort(array,(o1, o2) -> o1-o2);
//sout   1,2,3

@FunctionalInterface
public interface BiFunction<T, U, R>{ 
    R apply(T t, U u)   //输入T、U  返回  R类型
    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);                   //输入T、U  返回  R类型 
        return (T t, U u) -> after.apply(apply(t, u)); //然后将R传入作为参数传入Function<? super R, ? extends V> after
    };                                                                    //对于Function而言,传入值为V的子类,返回值是R的一种父类
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { 
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

常见函数式接口:
在这里插入图片描述
在这里插入图片描述

Stream 解析

stream of elements -----> filter ->sorted->  map ->  collect

其中  Stream<T> filter(Predicate<? super T> predicate);       返回值为Stream
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t) ;             //校验是否满足条件
    default Predicate<T> and(Predicate<? super T> other) { //且
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    default Predicate<T> negate() {//校验是否不满足条件
        return (t) -> !test(t);
    }
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

//sorted
Stream<T> sorted();   //元素自身需要实现  Comparable
Stream<T> sorted(Comparator<? super T> comparator);

// map  将集合中的元素转换为另外一种类型 ,同时返回的为  Stream
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}


----------------------------------------------------#### //reduce
   Optional<T> reduce(BinaryOperator<T> accumulator);//流的第一个元素与第二个进行操作返回相同类型作为第一个参数再次传入
                               //如(x,y)->x+u  流为:1,2,3,...    则(1,2)->3     (3,3)->6   .......
    public interface BinaryOperator<T> extends BiFunction<T,T,T> {  //BiFunction<T,T,T>      T apply(T t, T u);
        public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
        }
        public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
        }
    }
//用法 
        List<Integer> list = Arrays.asList(3, 2, 4, 1, 5, 6, 7); ///10
        System.out.println(list.stream().reduce((a, b) -> a+ b).get()); //求和     T apply(T t, T u);
        
        List<String> list = Arrays.asList("zhangsan","lisi","wangwu");  //拼接 
        System.out.println(list.stream().filter(e->e.length()>1)
                .reduce((s, s2) -> s+","+s2).get());
 BinaryOperator<Integer> bi = BinaryOperator.minBy(Comparator.naturalOrder());
      System.out.println(bi.apply(2, 3));  //sout    2
--------------------------------------------------
      T reduce(T identity, BinaryOperator<T> accumulator);//这里同上,只是给出了一个初始值 
 



      <U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);  //BiFunction<T, U, R>
      //这里U可以是不同类型,例如 是一个容器,可以存放流中处理的值
//第二个表达式中 输入为 T,U返回值为U 即该方法第一个参数会作为参数传入,第三个参数只有在并行的时候才有用,合并结果集
        list.stream().reduce(new ArrayList<Integer>(), new BiFunction<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
            @Override
            public ArrayList<Integer> apply(ArrayList<Integer> integers, Integer integer) {
                integers.add(integer);
                return integers;
            }
        }, new BinaryOperator<ArrayList<Integer>>() {
            @Override
            public ArrayList<Integer> apply(ArrayList<Integer> strings, ArrayList<Integer> strings2) {
                return strings;
            }
        });


----------------------------------------------------------
collect
    <R, A> R collect(Collector<? super T, A, R> collector);



    <R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);











版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/191829.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 大数据开发常见面试问题总结「建议收藏」

    大数据开发常见面试问题总结「建议收藏」1、简述对大数据组件的理解?Yarn:大数据组件运行的job的管理器 Spark:分布式的利用内存进行分布式运算的大数据组件 Hbase:基于Hadoop的大数据常用数据库 Hive:基于Hadoop的大数据数据仓库,操作和关系型数据库(MySQL)类似2、hdfs文件系统中NameNode和DataNode的区别和联系?NameNode存储了元数据,并且调度,协调整个集群Da…

  • 计算机网络体系结构综述(上)[通俗易懂]

    计算机网络体系结构综述(上)[通俗易懂]计算机网络体系结构标准的制定使得两台计算机能够像两个知心朋友那样能够互相准确理解对方的意思并做出优雅的回应。本文首先概述了计算机网络体系结构的提出动机,并结合日常生活中的邮政系统介绍了设计的理念,并给出了相关的基本概念和标准。进一步地,我们着重概述了计算机网络体系结构的分层原理及其最重要的组成部分——协议,使得读者能够对计算网路体系结构有一个全新的、系统的认识。

  • 用bat批量重命名图片_快速批量修改图片名称

    用bat批量重命名图片_快速批量修改图片名称问题描述:业务中遇到需要批量修改大量图片的名字。如下图,需要修改为图片名字“u=”之后和“,”之前的那一串解决思路1:bat批处理,网上查找相关代码如下:1@echooff2SetL

  • autocad二次开发资料总结

    autocad二次开发资料总结autocad二次开发AutoCAD(AutoComputerAidedDesign)是美国Autodesk公司研制开发的一款计算机辅助设计软件,它不是一款简单的绘图工具,而是一个复杂的计算机辅助设计系统。我们可以根据他灵活的开放性对其进行二次开发定制,让它更加适用于某一具体的设计领域。中文名AutoCAD二次开发外文名AutoCADDevelopmentSyst

    2022年10月23日
  • 502 Bad Gateway 常见解决思路

    502 Bad Gateway 常见解决思路一般在访问某些网站或者我们在做本地测试的时候,服务器突然返回502BadGatewayNginx,这种问题相信大家也遇到不少了,这里我再总结下几种处理方式,有缺少或者错误的希望有大神能指出。一般的思维:502,说明服务器没有响应,也就是我们的web服务器没有接到有效的信息导致的。产生错误的原因主要是:连接超时,我们向服务器发送请求由于服务器当前链接太多,导致服务器方面无…

  • 数据分析决策树算法_大数据决策树算法

    数据分析决策树算法_大数据决策树算法在2006年12月召开的IEEE数据挖掘国际会议上,与会的各位专家选出了当时的十大数据挖掘算法(top10dataminingalgorithms)。本博客的十大数据挖掘算法系列已经介绍过其中的5个。本文主要介绍决策树中的C4.5,这也是当年位列十大数据挖掘算法之首的经典算法,最后,我们还将演示在Weka(怀卡托智能环境)中进行数据挖掘的实际操作方法

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号