JDK8-Stream总结2

wyh106115

已于 2024-09-27 22:11:25 修改

阅读量304

点赞数 3

分类专栏： jdk8新特性文章标签： java

于 2024-09-25 17:22:12 首次发布

本文链接：https://blog.csdn.net/wyh106115/article/details/142528825

版权

jdk8新特性专栏收录该内容

8 篇文章 0 订阅

订阅专栏

lambda表达式是stream的基础，初学者建议先学习lambda表达式: JDK8-lambda表达式。及其JDK8-Optional类

JDK8-Stream总结1
JDK8-Stream总结3

3 对流的操作

1）最常使用

1 map – 转换流，将一种类型的流转换为另外一种流

/**
 * map把一种类型的流转换为另外一种类型的流
 * 将String数组中字母转换为大写
 */
@Test
public void testMap() {
    String[] arr = new String[]{"yes", "YES", "no", "NO"};
    Arrays.stream(arr).map(x -> x.toLowerCase()).forEach(System.out::println);
}

2 filter – 过滤流，过滤流中的元素

@Test
public void testFilter(){
    Integer[] arr = new Integer[]{1,2,3,4,5,6,7,8,9,10};
    Arrays.stream(arr).filter(x->x>3&&x<8).forEach(System.out::println);
}

3 flapMap – 拆解流，将流中每一个元素拆解成一个流

/**
 * flapMap：拆解流
 */
@Test
public void testFlapMap1() {
    String[] arr1 = {"a", "b", "c", "d"};
    String[] arr2 = {"e", "f", "c", "d"};
    String[] arr3 = {"h", "j", "c", "d"};
    List<String> collect = Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).collect(Collectors.toList());
   // Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
    Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);
}

4 sorted – 对流进行排序

String[] arr1 = {"abc","a","bc","abcd"};
/**
 * Comparator.comparing是一个键提取的功能
 * 以下两个语句表示相同意义
 */
@Test
public void testSorted1_(){
    /**
     * 按照字符长度排序
     */
    Arrays.stream(arr1).sorted((x,y)->{
        if (x.length()>y.length())
            return 1;
        else if (x.length()<y.length())
            return -1;
        else
            return 0;
    }).forEach(System.out::println);
    
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
}
 
/**
 * 倒序
 * reversed(),java8泛型推导的问题，所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
 * Comparator.reverseOrder():也是用于翻转顺序，用于比较对象（Stream里面的类型必须是可比较的）
 * Comparator. naturalOrder()：返回一个自然排序比较器，用于比较对象（Stream里面的类型必须是可比较的）
 */
@Test
public void testSorted2_(){
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
    Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);
    Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);
}
 
/**
 * thenComparing
 * 先按照首字母排序
 * 之后按照String的长度排序
 */
@Test
public void testSorted3_(){
    Arrays.stream(arr1).sorted(Comparator.comparing(this::com1).thenComparing(String::length)).forEach(System.out::println);
}
public char com1(String x){
    return x.charAt(0);
}

2）提取流和组合流

public void init(){
    arr1 = new String[]{"a","b","c","d"};
    arr2 = new String[]{"d","e","f","g"};
    arr3 = new String[]{"i","j","k","l"};
}

1 limit – 限制从流中获得前n个数据

/**
 * limit，限制从流中获得前n个数据
 */
@Test
public void testLimit(){
    Stream.iterate(1,x->x+2).limit(10).forEach(System.out::println);
}

2 skip – 跳过前n个数据

/**
 * skip，跳过前n个数据
 */
@Test
public void testSkip(){
    Stream.iterate(1,x->x+2).skip(1).limit(5).forEach(System.out::println);
}

3 concat – 合并流

/**
 * 可以把两个stream合并成一个stream（合并的stream类型必须相同）
 * 只能两两合并
 */
@Test
public void testConcat(){
    Stream<String> stream1 = Stream.of(arr1);
    Stream<String> stream2 = Stream.of(arr2);
    Stream.concat(stream1,stream2).distinct().forEach(System.out::println);
 }

3）聚合操作

@Before
public void init(){
    arr = new String[]{"b","ab","abc","abcd","abcde"};
}

1 max、min – 最大最小值

/**
 * max、min
 * 最大最小值
 */
@Test
public void testMaxAndMin(){
    Stream.of(arr).max(Comparator.comparing(String::length)).ifPresent(System.out::println);
    Stream.of(arr).min(Comparator.comparing(String::length)).ifPresent(System.out::println);
}

2 count – 计算数量

/**
 * count
 * 计算数量
 */
@Test
public void testCount(){
    long count = Stream.of(arr).count();
    System.out.println(count);
}

3 findFirst – 查找第一个

/**
 * findFirst
 * 查找第一个
 */
@Test
public void testFindFirst(){
    String str =  Stream.of(arr).parallel().filter(x->x.length()>3).findFirst().orElse("noghing");
    System.out.println(str);
}

4 findAny – 找到所有匹配的元素

/**
 * findAny
 * 找到所有匹配的元素
 * 对并行流十分有效
 * 只要在任何片段发现了第一个匹配元素就会结束整个运算
 */
@Test
public void testFindAny(){
    Optional<String> optional = Stream.of(arr).parallel().filter(x->x.length()>3).findAny();
    optional.ifPresent(System.out::println);
}

5 anyMatch – 是否含有匹配元素

/**
 * anyMatch
 * 是否含有匹配元素
 */
@Test
public void testAnyMatch(){
    Boolean aBoolean = Stream.of(arr).anyMatch(x->x.startsWith("a"));
    System.out.println(aBoolean);
}

4）收集结果

Student[] students;
@Before
public void init(){
    students = new Student[100];
    for (int i=0;i<30;i++){
        Student student = new Student("user",i);
        students[i] = student;
    }
    for (int i=30;i<60;i++){
        Student student = new Student("user"+i,i);
        students[i] = student;
    }
    for (int i=60;i<100;i++){
        Student student = new Student("user"+i,i);
        students[i] = student;
    }
 
}

1 生成list、set、map

@Test
public void testCollect1(){
    /**
     * 生成List
     */
    List<Student> list = Arrays.stream(students).collect(toList());
    list.forEach((x)-> System.out.println(x));
    /**
     * 生成Set
     */
    Set<Student> set = Arrays.stream(students).collect(toSet());
    set.forEach((x)-> System.out.println(x));
    /**
     * 如果包含相同的key，则需要提供第三个参数，否则报错
     */
    Map<String,Integer> map = Arrays.stream(students).collect(toMap(Student::getName,Student::getScore,(s,a)->s+a));
    map.forEach((x,y)-> System.out.println(x+"->"+y));
}

在这里插入图片描述

2 生成数组

/**
 * 生成数组
 */
@Test
public void testCollect2(){
    Student[] s = Arrays.stream(students).toArray(Student[]::new);
    for (int i=0;i<s.length;i++)
        System.out.println(s[i]);
}

3 指定生成的类型

/**
 * 指定生成的类型
 */
@Test
public void testCollect3(){
    HashSet<Student> s = Arrays.stream(students).collect(toCollection(HashSet::new));
    s.forEach(System.out::println);
}

4 统计

/**
 * 统计
 */
@Test
public void testCollect4(){
    IntSummaryStatistics summaryStatistics = Arrays.stream(students).collect(Collectors.summarizingInt(Student::getScore));
    System.out.println("getAverage->"+summaryStatistics.getAverage());
    System.out.println("getMax->"+summaryStatistics.getMax());
    System.out.println("getMin->"+summaryStatistics.getMin());
    System.out.println("getCount->"+summaryStatistics.getCount());
    System.out.println("getSum->"+summaryStatistics.getSum());
}

5）分组和分片

分组和分片的意义是，将collect的结果集展示位Map<key,val>的形式：

Student[] students;
@Before
public void init(){
    students = new Student[100];
    for (int i=0;i<30;i++){
        Student student = new Student("user1",i);
        students[i] = student;
    }
    for (int i=30;i<60;i++){
        Student student = new Student("user2",i);
        students[i] = student;
    }
    for (int i=60;i<100;i++){
        Student student = new Student("user3",i);
        students[i] = student;
    }
}

1 groupingBy – 分组

@Test
public void testGroupBy1(){
    Map<String,List<Student>> map = Arrays.stream(students).collect(groupingBy(Student::getName));
    map.forEach((x,y)-> System.out.println(x+"->"+y));
}

2 partitioningBy – 分成两组

/**
 * 如果只有两类，使用partitioningBy会比groupingBy更有效率
 */
@Test
public void testPartitioningBy(){
    Map<Boolean,List<Student>> map = Arrays.stream(students).collect(partitioningBy(x->x.getScore()>50));
    map.forEach((x,y)-> System.out.println(x+"->"+y));
}

3 downstream – 指定类型类分组

/**
 * downstream指定类型
 */
@Test
public void testGroupBy2(){
    Map<String,Set<Student>> map = Arrays.stream(students).collect(groupingBy(Student::getName,toSet()));
    map.forEach((x,y)-> System.out.println(x+"->"+y));
}

4 downstream --分组时进行聚合操作

/**
 * downstream 聚合操作
 */
@Test
public void testGroupBy3(){
    /**
     * counting
     */
    Map<String,Long> map1 = Arrays.stream(students).collect(groupingBy(Student::getName,counting()));
    map1.forEach((x,y)-> System.out.println(x+"->"+y));
    /**
     * summingInt
     */
    Map<String,Integer> map2 = Arrays.stream(students).collect(groupingBy(Student::getName,summingInt(Student::getScore)));
    map2.forEach((x,y)-> System.out.println(x+"->"+y));
    /**
     * maxBy
     */
    Map<String,Optional<Student>> map3 = Arrays.stream(students).collect(groupingBy(Student::getName,maxBy(Comparator.comparing(Student::getScore))));
    map3.forEach((x,y)-> System.out.println(x+"->"+y));
    /**
     * mapping
     */
    Map<String,Set<Integer>> map4 = Arrays.stream(students).collect(groupingBy(Student::getName,mapping(Student::getScore,toSet())));
    map4.forEach((x,y)-> System.out.println(x+"->"+y));
}