目录
Filter 根据指定值 寻找stream里面符合条件的 条数✨
取出 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流操作_语文课-CSDN博客_java stream流操作
扫一扫
6067
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
