java8 函数 lambda表达式

并行流 ：

stream().parallel()

/*fork时会对源数据进行分割，数据源的特性直接影响了fork的性能。 ArrayList、数组或IntStream.range，可分解性最佳，因为他们都支持随机读取，因此可以被任意分割。 HashSet、TreeSet，可分解性一般，其虽然可被分解，但因为其内部数据结构，很难被平均分解。 LinkedList、Streams.iterate、BufferedReader.lines，可分解性极差，因为他们长度未知，无法确定在哪里进行 分割
————————————————
版权声明：本文为CSDN博主「我是七月呀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44655599/article/details/111636732*/

// 并行流   ArrayList、数组或IntStream.range
/**
*  fork时会对源数据进行分割，数据源的特性直接影响了fork的性能
*  ArrayList、数组或IntStream.range，可分解性最佳，因为他们都支持随机读取，因此可以被任意分割
*  HashSet、TreeSet，可分解性一般，其虽然可被分解，但因为其内部数据结构，很难被平均分解
*  LinkedList、Streams.iterate、BufferedReader.lines，可分解性极差，因为他们长度未知，无法确定在哪里进行 分割
* 
* 装箱拆箱 尽量使用基本数据类型，避免装箱拆箱。
* CPU核数 fork的产生数量是与可用CPU核数相关，可用的核数越多，获取的性能提升就会越大。
* 
* 单元处理开销 花在流中每个元素的时间越长，并行操作带来的性能提升就会越明显。
* 
* 
*/
stream().parallel().collect(Collections.toList());

1）基本类型

性能消耗： Stream串行>for循环>Stream并行

2）对象

性能消耗：Stream串行>for循环>Stream并行

3）复杂对象

性能消耗：for循环>Stream串行>Stream并行

forEach 循环

// forEach
// forEach是单线程方法，拒绝给
List<String> list = new ArrayList<>();
list.forEach(n -> System.out.println(n));
 
// 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，
list.forEach(System.out::println);

filter 去重

List<String> names = Arrays.asList("小三", "小四", "小五", "原配", "老公公");
// 将集合中开头是“小”的整合成一个list返回;
names.stream().filter(n -> n.startsWith("小")).collect(Collectors.toList());

Bean- filter 去重

Map<String, ResourceBo> map = new ConcurrentHashMap<>();
// 去重
List<ResourceBo> resourceBoList = claimApplicationBo.getResourceList().stream().filter(n -> map.put(n.getResourceTypeCode(),n) == null).collect(Collectors.toList());

filter + Predicate 去重

/**
* String 方法  startsWith 开头   contains 包含   endsWith 结尾
*/
// 开头是包含“小”的
Predicate<String> xiao = (n) -> n.startsWith("小");

// 开头是“小”的，返回
names.stream().filter(xiao).collect(Collectors.toList());
names.stream().filter(xiao).forEach(n -> System.out.println(n));

/**
*  Predicate 的方法 ： and()并且   or()或者   negate()不是
* 
*/
// 开头是“小”  and 和 结尾是 “三”
names.stream().filter(xiao.and(n.startsWith("三"))).collect(Collectors.toList());
names.stream().filter(xiao.and(n -> n.endsWith("三"))).forEach(n -> System.out.println(n));

Collectors 转集合

/**
  * Collectors.joining(", ")
  * Collectors.toList()
  * Collectors.toSet() ，生成set集合
  */
// 将字符串换成大写并用逗号链接起来
List<String> list = Arrays.asList("Aa", "Bb", "Cc", "Dd", "Ee", "Ff","Gg");
String Collectors = list.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(": "));
System.out.println(Collectors);

flatMap 连接多个Stream

将多个Stream连接成一个Stream

我认为，他就是把list都串联在一起了

        List<Integer> listInt = new ArrayList<>();
        listInt.add(1);
        listInt.add(2);

        List<Integer> listInt3 = new ArrayList<>();
        listInt3.add(4);
        listInt3.add(5);
        List<Integer> result = Stream.of(listInt,listInt3,listInt3).flatMap(
                a -> a.stream()).collect(Collectors.toList()
        );
        for(int ins : result){
            System.out.println(ins);
        }
        // 输出：124545

distinct 去重

		name n = new name();
        n.setId(1);
        name a = new name();
        a.setId(2);
        name b = new name();
        b.setId(1);
        List<name> list=new ArrayList<name>();
        list.add(n);
        list.add(a);
        list.add(b);
        List<Integer> likeList = list.stream().map(x -> x.getId()).distinct().collect(Collectors.toList());
        List<Integer> likeLists = list.stream().map(name :: getId).distinct().collect(Collectors.toList());
        for (Integer integer : likeList){
            System.out.print(integer);
        }
        System.out.println("");
        for (Integer l : likeLists){

            System.out.print(l);
        }

count 计数

        name n = new name();
        n.setId(1);
        name a = new name();
        a.setId(50);
        name b = new name();
        b.setId(19);
        List<name> list=new ArrayList<name>();
        list.add(n);
        list.add(a);
        list.add(b);
        List<Integer> likeList = list.stream().map(x -> x.getId()).distinct().collect(Collectors.toList());

        int countOfAdult= (int) list.stream()
                .filter(p -> p.getId() > 18)
                //.map()
                //.collect(Collectors.toList())
                .count();
        System.out.println(countOfAdult);

allMatch、anyMatch、noneMatch

  //  allMatch：Stream中全部元素符合传入的predicate返回 true
　//　anyMatch：Stream中只要有一个元素符合传入的predicate返回 true
　//　noneMatch：Stream中没有一个元素符合传入的predicate返回 true
    List<String> list = new ArrayList<String>();
      list.add("one");
      list.add("two");
      list.add("three");
      list.add("four");
      list.add("five");

      Boolean bl = list.stream()
              .anyMatch(x->x.length()==3);
      System.out.println(bl);
// 输出：true

peek 调试方法

/* 可以使用peek方法，peek方法可只包含一个空的方法体，只要能设置断点即可，
但有些IDE不允许空，可以如下文示例，简单写一个打印逻辑。
注意，调试完后要删掉。*/

sorted 排序

排序介绍的网址

/**
     * lambda
     * sorted排序
     */
    @Test
    public void test19() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(11);
        list.add(111);
        list.add(9);
        List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
        collect.forEach(System.out::println);
        System.out.println("********");
 
        List<Integer> reverseOrder = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        reverseOrder.forEach(System.out::println);
    }
    
  		List<User> user = new ArrayList<>();
        user.add(new User(1L, 18, "小明"));
        user.add(new User(2L, 20, "小王"));
        user.add(new User(3L, 28, "小刚"));
        
 		//先按照age排序，age相同时按照id排序
        List<User> collect3 = user.stream().sorted(Comparator.comparing(User::getAge)
        .thenComparing(User::getId))
        .collect(Collectors.toList());
        collect3.forEach(e -> {
            System.out.println(JSON.toJSONString(e));
        });

min,max,summaryStatistics 最小值，最大值，合

0.0