lambda表达式常用例子

爱被打了一巴掌 2023-02-25 02:30 5阅读 0赞

*  比较

// 省略参数表的类型
            Collections.sort(list, (s1, s2) -> {
                System.out.println("s1=" + s1);
                System.out.println("s2=" + s2);
                if (s1 == null) {
                    return -1;
                }
                if (s2 == null) {
                    return 1;
                }
                return s1.length() - s2.length();
            });
    
    
    //lambda 排序
    
        public static void main(String[] args) {
            HashMap<String, Object> map1 = new HashMap<>();
            map1.put("money",1);
            HashMap<String, Object> map2 = new HashMap<>();
            map2.put("money",2333);
    
            HashMap<String, Object> map3 = new HashMap<>();
            map3.put("money",null);
            HashMap<String, Object> map4 = new HashMap<>();
            map4.put("money",4);
    
            ArrayList<Map<String, Object>> maps = new ArrayList<Map<String, Object>>();
            maps.add(map4);
            maps.add(map1);
            maps.add(map3);
            maps.add(map2);
    
    
    
            List<Map<String, Object>> collect = maps.stream().sorted(Comparator.comparing(DemoApplicationTests::comparingByMapKey)).collect(Collectors.toList());
            System.out.println(collect);
    
    
        }
    
       
        private  static  int  comparingByMapKey(Map<String, Object> map){
            if (Optional.ofNullable(map).map(strMap -> strMap.get("money")).isPresent()) {
                return  (Integer)map.get("money")  ;
            }else {
                return  0;
            }
        }

*   多线程

new Thread(
                    () -> {
                        System.out.print("1");
                        System.out.println(" 2");
                    }
            ).start();
    
    
     
    
    
        Runnable r1 = () -> {
            System.out.println(1);
        };
        Runnable r2 = () -> {
            System.out.println(2);
        };

*  循环

list.forEach(str -> {
                System.out.println(str.length());
                System.out.println(str);
            });
    
    //移出空的元素
    oldList.removeAll(Collections.singleton(null));

*  常用方法

//Predicate接口是输入一个参数，返回布尔值。我们通过and方法组合两个Predicate条件，判断是否值大于0并且是偶数
            Predicate<Integer> positiveNumber = i -> i > 0;
            Predicate<Integer> evenNumber = i -> i % 2 == 0;
            assertTrue(positiveNumber.and(evenNumber).test(2));
    
            //Consumer接口是消费一个数据。我们通过andThen方法组合调用两个Consumer，输出两行abcdefg
            Consumer<String> println = System.out::println;
            println.andThen(println).accept("abcdefg");
    
            //Function接口是输入一个数据，计算后输出一个数据。我们先把字符串转换为大写，然后通过andThen组合另一个Function实现字符串拼接
            Function<String, String> upperCase = String::toUpperCase;
            Function<String, String> duplicate = s -> s.concat(s);
            // assertThat(upperCase.andThen(duplicate).apply("test"), is("TESTTEST"));
    
            //Supplier是提供一个数据的接口。这里我们实现获取一个随机数
            Supplier<Integer> random = ()-> ThreadLocalRandom.current().nextInt();
            System.out.println(random.get());
    
            //BinaryOperator是输入两个同类型参数，输出一个同类型参数的接口。这里我们通过方法引用获得一个整数加法操作，通过Lambda表达式定义一个减法操作，然后依次调用
            BinaryOperator<Integer> add = Integer::sum;
            BinaryOperator<Integer> subtraction = (a, b) -> a - b;
            assertThat(subtraction.apply(add.apply(1, 2), 3), is(0));

*  list

//移出满足条件的  
    list.removeIf(str -> str.length() > 3);
    
    //替换满足条件的
     list.replaceAll(str -> {
                if (str.length() > 3) {
                    return str.toUpperCase();
                }
                return str;
            });
    
    //指定规则排序
     list.sort((str1, str2) -> str1.length() - str2.length());

*   map

//遍历
    map.forEach((k, v) -> System.out.println(k + "=" + v));
    
    //如果获取如果key不存在,返回指定值
       map.getOrDefault(4, "NoValue") ;
    
    //插入不存在的key或者key对应的value为null时候
            map.putIfAbsent(3,"Kong");
    
    //替换指定的value
    
             map.replaceAll((k,v) -> {
    
    
                if (k > 1) {
                    return v.toUpperCase();
    
                }else {
                    return k.toString();
                }
            });
    
    
    //字符串想加
                 "a".concat("b"); =  "a"+ "b";

stream(只能用一次)

> *stream*并不是某种数据结构，它只是数据源的一种视图。这里的数据源可以是一个数组，Java容器或I/O channel等。正因如此要得到一个*stream*通常不会手动创建，而是调用对应的工具方法，比如：
> 
>  *  调用`Collection.stream()`或者`Collection.parallelStream()`方法
>  *  调用`Arrays.stream(T[] array)`方法
> 
> ### *stream特性* ###
> 
>  *  **无存储**。*stream*不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
>  *  **为函数式编程而生**。对*stream*的任何修改都不会修改背后的数据源，比如对*stream*执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新*stream*。
>  *  **惰式执行**。*stream*上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
>  *  **可消费性**。*stream*只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTUzMDY5NQ_size_16_color_FFFFFF_t_70][]

区分中间操作和结束操作最简单的方法，就是看方法的返回值，返回值为*stream*的大都是中间操作，否则是结束操作。

//结束操作
     Stream<String> stream = Stream.of("1", "2", "3", "4");
            stream.forEach(str -> System.out.println(str));
    
    //只能这么写
     stream.filter(str -> str=="3").forEach(str -> System.out.println(str));
    
    //这种方式会发生错误:由于filter()是个中间操作，如果只调用filter()不会有实际计算，因此也不会输出任何信息。
    stream.filter(str -> str=="3") ;
            stream.forEach(s -> {
                System.out.println("s=" + s);
            });
    
    
    //去重
    
     stream.distinct().forEach(s -> {
                System.out.println(s);
            });
    
    //自然排序
     stream.sorted().forEach(s -> System.out.println(s));
    
    //自定义排序
            stream.sorted((s1,s2)-> Integer.valueOf(s2)-Integer.valueOf(s1)).forEach(s -> System.out.println(s)); ;
    
    //批量操作:就是对每个元素按照某种操作进行转换，转换前后Stream中元素的个数不会改变，但元素的类型取决于转换之后的类型。
     stream.map(str -> Integer.valueOf(str) + 1)
                    .forEach(str -> System.out.println(str));
    
    
    //合并多个集合为一个
    Stream<List<Integer>> stream = Stream.of(Arrays.asList(1,2), Arrays.asList(3, 4, 5), Arrays.asList(7, 4, 5));
            stream.flatMap(list -> list.stream())
                    .forEach(i -> System.out.println(i));
    
    // 获取最大值或者最小值   max()、min()、count()
      Stream<Integer> stream = Stream.of(1, 22, 2, 3);
    
    //自定义获取最大值
    //     Optional<Integer> longest = stream.reduce((s1, s2) -> s1>s2  ? s1 : s2);
    
            //获取最大值
            Optional<Integer> longest = stream.max((s1, s2) -> s1  -s2);
            System.out.println(longest.get());
    
    //
    // Optional<Integer> longest = stream.reduce((s1, s2) -> s1+s2);
    //统计数量
     long count = stream.count();
    
    
     
    
    //collect
        Stream<Integer> stream = Stream.of(1, 22, 2, 3,2);
    // 将Stream转换成容器 
    //        List<Integer> list = stream.collect(Collectors.toList());
    
    
    
             Set<Integer> set = stream.collect(Collectors.toSet()); // (2)
            set.forEach(str -> System.out.println(str));
    
    
    
     //转map
     Stream<Student> studentStream = Stream.of(
                    new Student("张三", 52, 0),
                    new Student("赵本山", 56, 1),
                    new Student("李四", 56, 0),
                    new Student("王五", 52, 0)
            );
    
    //分组
     Map<Integer, List<Student>> map2 =  studentStream.collect(Collectors.groupingBy((s -> s.getSex())));
    //        Map<String, Student> map2 =  studentStream.collect(Collectors.toMap(Student::getName,Function.identity()));
    
    //:: 是引入类中的方法  把对象转成map
    Map<String, Integer> map2 =  studentStream.collect(Collectors.toMap(Student::getName,Student::getAge));
            map2.forEach((key,value)->{
                System.out.println(key + "---->"+value);
            });
    
    //stream 生成指定容器
     ArrayList<Integer> arrayList = stream.collect(Collectors.toCollection(ArrayList::new)); 
            HashSet<Integer> hashSet = stream.collect(Collectors.toCollection(HashSet::new)); 
          
    
    
    //拼接字符串
    
    // 使用Collectors.joining()拼接字符串
    Stream<String> stream = Stream.of("我", "是", "谁");
    //String joined = stream.collect(Collectors.joining());// "我是谁"
    //String joined = stream.collect(Collectors.joining(","));// "我,是,谁"
    String joined = stream.collect(Collectors.joining(",", "{", "}"));// "{我,是,谁}"
    
    
    
    // anyMatch表示，判断的条件里，任意一个元素成功，返回true
    //allMatch表示，判断条件里的元素，所有的都是，返回true
    //noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true
    List<Map<String,Object>> objects = new ArrayList<>();
    
            HashMap<String, Object> map = new HashMap<>();
            HashMap<String, Object> map2 = null;  //有这个结果为false
            map.put("1",null); //有这个也为false
            map.put("2","b");
            objects.add(map);
            objects.add(map2);
            boolean b = objects.stream().allMatch(e -> e!=null &&  !e.containsValue(null));
    
            System.out.println(b);
    
    //

方法引用

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTUzMDY5NQ_size_16_color_FFFFFF_t_70 1][]

> Stream上的所有操作分为两类：中间操作和结束操作，中间操作只是一种标记，只有结束操作才会触发实际计算。中间操作又可以分为无状态的(*Stateless*)和有状态的(*Stateful*)，无状态中间操作是指元素的处理不受前面元素的影响，而有状态的中间操作必须等到所有元素处理之后才知道最终结果，比如排序是有状态操作，在读取所有元素之前并不能确定排序结果；结束操作又可以分为短路操作和非短路操作，短路操作是指不用处理全部元素就可以返回结果，比如*找到第一个满足条件的元素*。之所以要进行如此精细的划分，是因为底层对每一种情况的处理方式不同。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTUzMDY5NQ_size_16_color_FFFFFF_t_70]: /images/20230209/ae63a89b284346d298f1a35453541afb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTUzMDY5NQ_size_16_color_FFFFFF_t_70 1]: /images/20230209/7356a6d8ad1a4a518e9f35b99370402b.png