目录

前言:  

引用:

获取对应数据的平方数,distinct 去重，也可以不去重

Collectors.toSet使用

Collectors.toList使用

map-->toUpperCase的使用

  Filter 根据指定值 寻找stream里面符合条件的 条数

FlapMap 合并二个集合流为一个集合流

取出 Stream 中最长的字符串 max 、min 终止操作

reduce的加减使用--上述的max、min、count 实际上都是 reduce 操作，求出 Stream 元素数值的总和，

---

前言:  

    悄悄学习一篇stream流，细水长流，愁更愁

引用:

   

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

java8里面集合接口有二种方法生成流:

• stream() − 为集合创建串行流。

• parallelStream() − 为集合创建并行流。

输出不为空集合里面的字符串,

 以下二个实例我们使用 stream  和 parallelStream  

 @Test
    public void reduceSumTest() {
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
        List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
        System.out.println(filtered);
    }

parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

获取对应数据的平方数,distinct 去重，也可以不去重

@Test
    public void reduceSumTest() {
        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5,1);
// 获取对应的平方数
        List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
        System.out.println(squaresList);
    }

Collectors.toSet使用

  @Test
    public void collectToSet() {
        //注意 set集合是不能重复的
        String[] testStrings = {"java", "react", "angular", "vue","java"};
        Set<String> list = Stream.of(testStrings).collect(Collectors.toSet());
        System.out.println("把sream里面的字符放入 set集合:"+list);
    }

Collectors.toList使用

   @Test
    public void collectToList() {
        String[] testStrings = {"java", "react", "angular", "vue"};

        List<String> list = Stream.of(testStrings).collect(Collectors.toList());

        for (int i = 0, length = list.size(); i < length; i++) {
            System.out.println("Stream 中每个字符串并放入一个新的列表:" + list.get(i));
        }
    }

map-->toUpperCase的使用

 Stream 中每个字符串都转换为大写的形式

 @Test
    public void toUpperCase() {
        String[] testStrings = {"java", "react", "angular", "vue"};
//     Stream 中每个字符串都转换为大写的形式
        List<String> list = Stream.of(testStrings).map(aa -> aa.toUpperCase()).collect(Collectors.toList());

        list.forEach(aa -> System.out.println(aa));
    }

  Filter 根据指定值 寻找stream里面符合条件的 条数

filter 根据指定值  寻找stream里面符合条件的 条数

筛选出以 j 字母开头的元素个数，此例中的count方法也是终止操作，计算count条数

 @Test
    public void filter_Count() {
        List<String> list = Arrays.asList("java", "react", "angular", "javascript", "vue");
//filter 根据指定值  寻找stream里面符合条件的 条数
        long count = list.stream().filter(p -> p.startsWith("j")).count();
        System.out.println(count);

    }

        

FlapMap 合并二个集合流为一个集合流

Arrays.asList的作用是将数组转化为list，一般是用于在初始化的时候，设置几个值进去

@Test
    public void flapMapTest() {
        List<Integer> list = (List<Integer>) Stream.of(Arrays.asList(1, 2, 3, 4, 5, 6), Arrays.asList(8, 9, 10,7))
                .flatMap(test -> test.stream()).collect(Collectors.toList());
        for (int i = 0, length = list.size(); i < length; i++) {
            System.out.println(list.get(i));
        }
    }

flatMap()操作能把原始流中的元素进行一对多的转换，并且将新生成的元素全都合并到它返回的流里面。假如现每个班的学生都学了不同的课程，现在需要统计班里所有学生所学的课程列表，该如何实现呢?

  flatMap() 中返回的是一个一个的 String 类型的 Stream 流，它们会被合并到最终返回的 Stream 流（String 类型）中。而后面的 distinct() 则是一个去重的操作，collect() 是收集操作。
public static void useFlatMap() {
  List<Student> students = initData();
  List<String> course = students.stream().flatMap(one -> one.getCourse().stream()).distinct()
                .collect(Collectors.toList());
  System.out.println(course);
}

 使收集操作将 List 转 Map

public static void list2Map() {
  List<Student> students = initData();
  Map<String, Double> collect = students.stream()
         .collect(Collectors.toMap(one -> one.getName(),
one -> one.getScore()));
  System.out.println(collect);
}
可以看到通过 Stream API 可以很方便地将一个 List 转成了 Map，但是这里有一个地方需要注意。那就是在通过 Stream API 将 List 转成 Map 的时候我们需要确保 key 不会重复，否则转换的过程将会直接抛出异常。

取出 Stream 中最长的字符串 max 、min 终止操作

  这里的:     Opitonal是java8引入的一个新类，目的是为了解决空指针异常问题。本质上，这是一个包含有可选值的包装类，这意味着 Optional 类既可以含有对象也可以为空。

    从 Optional 实例中取回实际值对象的方法之一是使用 get() 方法：

max取最大字符串,min取最小字符串

 @Test
    public void maxTest() {
        String[] testStrings = {"java", "react", "angular", "javascript", "vue"};

        Optional<String> max = Stream.of(testStrings).max((p1, p2) -> Integer.compare(p1.length(), p2.length()));

        System.out.println(max.get());

    }

reduce的加减使用--上述的max、min、count 实际上都是 reduce 操作，求出 Stream 元素数值的总和，

 

reduce方法的第一个参数值 0 是初始值，第二个lambda表达式参数 (accumulator, element) -> accumulator + element 是执行求和操作，其中 accumulator 是累加器，element 是每次迭代的当前元素数值。

@Test
    public void reduceSumTest() {
        int sum = Stream.of(5, 6, 7, 8).reduce(0, (accumulator, element) -> accumulator + element);

        System.out.println(sum);

    }

public static void reduceFirstSign() {
  List<Integer> list = Arrays.asList(1,2,3,4,5,6);
  ptional<Integer> count = list.stream().reduce((a, b) -> (a + b));
  System.out.println(count.get()); // 21
}

public static void reduceSecondSign() {
  List<Integer> list = Arrays.asList(1,2,3,4,5,6);
  Integer count = list.stream().reduce(2, (a, b) -> (a * b));
  System.out.println(count);  // 1440
}
与第一种签名不同的是多接收了一个参数 identity，在首次执行 accumulator 表达式的时候它的第一个参数并不是 Stream 流的第一个元素，而是 identity。比如下面的例子最终输出的结果是 Stream 流中所有元素乘积的 2 倍。

public static void reduceThirdSign() {
  List<Integer> list = Arrays.asList(Integer.MAX_VALUE, Integer.MAX_VALUE);
  long count = list.stream().reduce(0L, (a, b) -> (a + b), (a,b) -> 0L);
  System.out.println(count);
}

前面两种前面的一个缺点在于返回的数据都只能和 Stream 流中元素类型一致，但这在某些情况下是无法满足我们的需求的，比如 Stream 流中元素都是 Integer 类型，但是求和之后数值超过了 Integer 能够表示的范围，需要使用 Long 类型接受，这就用到了我们第三种签名的 reduce() 方法。

map的使用

map() 方法可以将一个流转换成另外一种对象的流，其中的 T 是原始流中元素的类型，而 R 则是转换之后的流中元素的类型。通过下面的代码我们将一个学生对象的 Stream 流转换成一个 Double 类型（学生的分数）的 Stream 流并求和后输出。

public static void useMap() {
  List<Student> students = initData();
  double scoreCount = students.stream()
            .map(Student::getScore)
            .reduce(0.0, (a,b) -> (a + b));
  System.out.println(scoreCount);
}

double scoreCount = students.stream()
                .mapToDouble(Student::getScore)
                .sum();

 

数字平方排序（倒叙）输出。

字符串转 map 输出。

import java.util.List;
import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;
import java.util.stream.Collectors;
class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        // 获取对应的平方数
//        List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
        List<Integer> squaresList = numbers.stream()
                .map(i -> i * i)
                .sorted((x, y) -> y - x)
                .collect(Collectors.toList());
//        squaresList.forEach(System.out::println);
        squaresList.forEach(num -> {
            num++;
            System.out.println(num);
        });

        List<String> strList = Arrays.asList("a", "ba", "bb", "abc", "cbb", "bba", "cab");
        Map<Integer, String> strMap = new HashMap<Integer, String>();

        strMap = strList.stream()
                .collect( Collectors.toMap( str -> strList.indexOf(str), str -> str ) );
        
        strMap.forEach((key, value) -> {
            System.out.println(key+"::"+value);
        });

    }
}

https://www.runoob.com/java/java8-streams.html

Java8 常用的Stream流操作_语文课-程序员宅基地_java stream流操作

Stream API 文档 - zyg_Fatty - 博客园

由浅入深体验 Stream 流（附带教程） - 知乎