在具体的介绍之前，先总结一波常用的写法，有基础的可以直接拿来用，没有基础的可以先跳过，看完下面的基础再回来看
List<User> userList = new ArrayList<>(); userList.addAll(Arrays.asList( new User(1, 11, "张三"), new User(1, 11, "张三"), new User(2, 22, "李四"), new User(1, 33, "王五"), new User(2, 44, "赵六"), new User(2, 44, "赵六"))); //----------------------------------------------中间操作---------------------------------------------- //【filter】从列表中筛选出性别为女的数据 List<User> filterUsage = userList.stream().filter(s->s.getSex() == 2).collect(Collectors.toList()); //结果：[User(sex=2, age=22, name=李四), User(sex=2, age=44, name=赵六), User(sex=2, age=44, name=赵六)] System.out.println(filterUsage); //【distinct】从列表中去重 List<User> distinctUsage = userList.stream().distinct().collect(Collectors.toList()); //结果：[User(sex=1, age=11, name=张三), User(sex=2, age=22, name=李四), User(sex=1, age=33, name=王五), User(sex=2, age=44, name=赵六)] System.out.println(distinctUsage); //【sorted】按照年龄字段从大到小重新排序 (从小到大就是s1.getAge()-s2.getAge()) List<User> sortedUsage = userList.stream().sorted((s1,s2)->s2.getAge()-s1.getAge()).collect(Collectors.toList()); //结果：[User(sex=2, age=44, name=赵六), User(sex=2, age=44, name=赵六), User(sex=1, age=33, name=王五), User(sex=2, age=22, name=李四), User(sex=1, age=11, name=张三), User(sex=1, age=11, name=张三)] System.out.println(sortedUsage); //【limit】获取前两条数据 List<User> limitUsage = userList.stream().limit(2).collect(Collectors.toList()); //结果：[User(sex=1, age=11, name=张三), User(sex=1, age=11, name=张三)] System.out.println(limitUsage); //【skip】跳过前两条,之后获取前三条数据 List<User> skipUsage = userList.stream().skip(2).limit(3).collect(Collectors.toList()); //结果：[User(sex=2, age=22, name=李四), User(sex=1, age=33, name=王五), User(sex=2, age=44, name=赵六)] System.out.println(skipUsage); //【map】获取所有人的姓名 List<String> mapUsage = userList.stream().map(User::getName).collect(Collectors.toList()); //结果：[张三, 张三, 李四, 王五, 赵六, 赵六] System.out.println(mapUsage); //【flatMap】 //【Collectors工具类一些常用方法】 //【groupingBy】分组 // 将集合中的数据按照姓名分组 Map<String, List<User>> groupingByUsage = userList.stream().collect(Collectors.groupingBy(s -> s.getName())); //结果：{李四=[User(sex=2, age=22, name=李四)], 张三=[User(sex=1, age=11, name=张三), User(sex=1, age=11, name=张三)], // 王五=[User(sex=1, age=33, name=王五)], 赵六=[User(sex=2, age=44, name=赵六), User(sex=2, age=44, name=赵六)]} System.out.println(groupingByUsage); // 将集合中的数据按照姓名+性别分组 Map<String, List<User>> groupingByUsage2 = userList.stream().collect(Collectors.groupingBy(s -> s.getName() + "#" + s.getSex())); //结果：{张三#1=[User(sex=1, age=11, name=张三), User(sex=1, age=11, name=张三)], 李四#2=[User(sex=2, age=22, name=李四)], // 赵六#2=[User(sex=2, age=44, name=赵六), User(sex=2, age=44, name=赵六)], 王五#1=[User(sex=1, age=33, name=王五)]} System.out.println(groupingByUsage2); //【maxBy】获取集合中年龄最大的对象信息 User maxByUsage = userList.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge())).get(); //结果：User(sex=2, age=44, name=赵六) System.out.println(maxByUsage); //【minBy】获取集合中年龄最小的对象信息 User minByUsage = userList.stream().collect(Collectors.minBy((s1, s2) -> s1.getAge() - s2.getAge())).get(); //结果：User(sex=1, age=11, name=张三) System.out.println(minByUsage); //【joining】拼接集合中所有的用户名称---直接拼接 String joiningUsage = userList.stream().map(User::getName).collect(Collectors.joining()); //结果：张三张三李四王五赵六赵六 System.out.println(joiningUsage); //拼接中间加上逗号 String joiningUsage2 = userList.stream().map(User::getName).collect(Collectors.joining(",")); //结果：张三,张三,李四,王五,赵六,赵六 System.out.println(joiningUsage2); //拼接中间加上逗号,两边加上前后缀 String joiningUsage3 = userList.stream().map(User::getName).collect(Collectors.joining(",","[","]")); //结果：[张三,张三,李四,王五,赵六,赵六] System.out.println(joiningUsage3); //【counting】获取集合中对象的数量 Long countingUsage = userList.stream().collect(Collectors.counting()); //结果：6 System.out.println(countingUsage); //【summingInt】获取集合中所有对象年龄的和 int summingIntUsage = userList.stream().collect(Collectors.summingInt(User::getAge)); //结果：165 System.out.println(summingIntUsage); //【averagingInt】获取集合中所有对象年龄的平均值 Double averagingIntUsage = userList.stream().collect(Collectors.averagingInt(User::getAge)); //结果：27.5 System.out.println(averagingIntUsage); //【summarizingInt】获取集合中所有对象的数量/和/最大值/最小值/平均值等信息 IntSummaryStatistics summarizingIntUsage = userList.stream().collect(Collectors.summarizingInt(User::getAge)); //结果：IntSummaryStatistics{count=6, sum=165, min=11, average=27.500000, max=44} System.out.println(summarizingIntUsage); //----------------------------------------------最终操作---------------------------------------------- //【collect】 //这里不做演示，上面的所有例子中都有用到 //【reduce】将集合中的所有性别字段的值按照相加的规则求乘积 Integer reduceUsage = userList.stream().map(User::getSex).reduce((s1, s2) -> s1 * s2).get(); //结果：8 System.out.println(reduceUsage); //【count】求集合中对象的数量 long countUsage = userList.stream().count(); //结果：6 System.out.println(countUsage); //【forEach】遍历出所有的对象的名称 Consumer<String> action = System.out::println; //结果：张三 张三 李四 王五 赵六 赵六 userList.stream().map(User::getName).forEach(action); //【max&min】获取集合中所有对象中年龄的最大值和最小值 Integer maxUsage = userList.stream().map(User::getAge).max(Integer::compareTo).get(); //结果：44 System.out.println(maxUsage); Integer minUsage = userList.stream().map(User::getAge).min(Integer::compareTo).get(); //结果：11 System.out.println(minUsage); //【Matching -> allMatch、anyMatch、noneMatch】 //allMatch：只有当流中所有的元素，都匹配指定的规则，才会返回true boolean allMatchUsage = userList.stream().map(User::getAge).allMatch(e -> e >= 44); //结果：false System.out.println(allMatchUsage); //anyMatch：只要流中有任意的数据，满足指定的规则，都会返回true boolean anyMatchUsage = userList.stream().map(User::getAge).anyMatch(e -> e <= 11); //结果：true System.out.println(anyMatchUsage); //noneMatch：只有当流中所有的元素，都不满足指定的规则，才会返回true boolean noneMatchUsage = userList.stream().map(User::getAge).noneMatch(e -> e < 11); //结果：true System.out.println(noneMatchUsage); //【find--> findFirst、findAny】【parallelStream并行流、stream串行流】 //findFirst:从流中获取开头第一个元素 User user = userList.stream().findFirst().get(); //结果：User(sex=1, age=11, name=张三) System.out.println(user); User user2 = userList.parallelStream().findFirst().get(); //结果：User(sex=1, age=11, name=张三) System.out.println(user2); //findAny:单线程是获取第一个元素,多线程可能不一样 User user3 = userList.stream().findAny().get(); //结果：User(sex=1, age=11, name=张三) System.out.println(user3); User user4 = userList.parallelStream().findAny().get(); //结果：User(sex=1, age=33, name=王五) System.out.println(user4); //【IntStream+summaryStatistics】获取int数组中的最大值 //1.准备一个int数组作为数据源 int[] array = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; //2.读取数据到流中，获取IntStream对象 IntStream intStream = Arrays.stream(array); //两种方法：（不能一起用,因为是中间操作） //1. 直接通过IntStream来获取 //System.out.println(intStream.max().getAsInt()); //2. 通过IntSummaryStatistics,里面包括最大/最小/平均/数量等方法 IntSummaryStatistics intSummaryStatistics = intStream.summaryStatistics(); //结果：9 System.out.println(intSummaryStatistics.getMax()); //----------------------------------------------其它操作---------------------------------------------- //【list转数组1】 Integer[] ints = userList.stream().map(User::getAge).toArray(Integer[]::new); //【list转数组2】 List<String> list = new ArrayList(); list.add("1"); list.add("2"); list.add("3"); String[] strings = list.toArray(new String[list.size()]); //【数组转list】 String[] arrays = {"1", "2", "3"}; List<String> listStrings = Stream.of(arrays).collect(Collectors.toList()); //结果：[1, 2, 3] System.out.println(listStrings); //【修改集合中的对象属性的值】 //原值：[User(sex=1, age=11, name=张三), User(sex=1, age=11, name=张三), User(sex=2, age=22, name=李四), // User(sex=1, age=33, name=王五), User(sex=2, age=44, name=赵六), User(sex=2, age=44, name=赵六)] System.out.println(userList); userList.forEach(s->{ s.setAge(100); s.setSex(100); }); //新值：[User(sex=100, age=100, name=张三), User(sex=100, age=100, name=张三),User(sex=100, age=100, name=李四), // User(sex=100, age=100, name=王五), User(sex=100, age=100, name=赵六), User(sex=100, age=100, name=赵六)] System.out.println(userList);
一、集合流的简介
1. 集合的流式编程的简介
Stream是JDK1.8之后出现的新特性，也是JDK1.8新特性中最值得学习的两种新特性之一（另一个是lambda表达式）Stream是对集合操作的增强，流不是集合的元素，不是一种数据结构，不负责数据的存储的。流更像是一个迭代器，可以单向的遍历一个集合中的每一个元素，并且不可循环。
2. 为什么要使用集合的流式编程
有些时候，对集合中的元素进行操作的时候，需要使用到其他操作的结果。在这个过程中，集合的流式编程可以大幅度的简化代码的数量。将数据源中的数据，读取到一个流中，可以对这个流中的数据进行操作（删除、过滤、映射...）。每次的操作结果也是一个流对象，可以对这个流再进行其它的操作。
3. 使用流式编程的步骤
通常情况下，对集合中的数据使用流式编程，需要经过以下三步：
（1）获取数据源，将数据源中的数据读取到流中
（2）对流中的数据进行各种各样的处理
（3）对流中的数据进行整合处理
在上述三个过程：
（1）过程2中，有若干方法，可以对流中的数据进行各种各样的操作，并且返回流对象本身，这样的操作，被称为中间操作
（2）过程3中，有若干方法，可以对流中的数据进行各种处理，并关闭流，这样的操作，被称为最终操作
在中间操作和最终操作中，基本上所有的方法参数都是函数式接口，可以使用lambda表达式来实现。使用集合的流式编程，来简化代码量。
二、数据源的获取
1. 数据源的简介
数据源，顾名思义，就是流中的数据的来源，是集合的流式编程的第一步，将数据源中的数据读取到流中，进行处理。注意：将数据读取到流中进行处理的时候，与数据源中的数据没有关系。也就是说，中间操作对流中的数据进行处理、过滤、映射、排序...是不会影响到数据源中的数据的。
2. 数据源的获取
这个过程，其实是将一个容器中的数据，读取到一个流中，因此无论什么容器作为数据源，读取到流中的方法返回值一定是一个Stream。
public static void main(String[] args) throws Exception{ //将集合作为数据源，读取集合中的数据到一个流中 collectionDataSource(); //将数组作为数据源，读取数组中的数据到一个流中（使用引用数据类型） arrayDataSource(); //将数组作为数据源，读取数组中的数据到一个流中（使用基本数据类型） } //将集合作为数据源，读取集合中的数据到一个流中 public static void collectionDataSource(){ //1.实例化一个集合 List<Integer> list = new ArrayList<>(); //2.填充元素 Collections.addAll(list,0,1,2,3,4,5,6,7,8,9); //3.读取集合中的数据，将其读取到流中 //Stream<Integer> stream = list.stream();//同步流 Stream<Integer> integerStream = list.parallelStream();//并发流 //4.输出stream System.out.println(integerStream);//java.util.stream.ReferencePipeline$Head@4554617c } //将数组作为数据源，读取数组中的数据到一个流中 public static void arrayDataSource(){ //1.实例化一个数组 Integer[] array = new Integer[]{0,1,2,3,4,5,6,7,8,9}; //2.读取数组中的数据到流中，得到一个流对象 Stream<Integer> stream = Arrays.stream(array); //3.输出Stream System.out.println(stream); } //将数组作为数据源，读取数组中的数据到一个流中 //集合中只能存引用数据类型,但是数组中不用 public static void arrayDataSource2(){ //1.实例化一个数组 int[] array = new int[]{0,1,2,3,4,5,6,7,8,9}; //2.读取数组中的数据到流中，得到一个流对象 IntStream stream = Arrays.stream(array); //3.输出Stream System.out.println(stream); }
三、最终操作
将流中的数据整合到一起，可以存入一个集合，也可以直接对流中的数据进行遍历，数据统计...通过最终操作，需要掌握如何从流中提取出来我们想要的信息。
注意事项：最终操作，在执行结束之后，会关闭这个流，流中的所有数据都会被销毁，如果使用一个已经关闭了的流，会出现异常。
最终操作包括：collect、reduce、count、forEach、max&min、Matching、find、IntStream等。
1. collect
将流中的数据收集到一起，对这些数据进行一些处理。最常见的处理，就是将流中的数据存入一个集合。collect方法的参数，是一个collector接口，而且这个接口并不是一个函数式接口，实现这个接口，可以自定义收集的规则。但是，绝大部分情况下，不需要自定义。
直接使用Collectors工具类提供的方法即可。
public class FinalOperation { public static void main(String[] args) { collectUsage(); } //最终操作：collect将流中的数据整合起来，最常见的处理是：读取流中的数据，整合到一个容器中，得到一个集合。 public static void collectUsage(){ //1.读取数据源 Stream<Integer> dataSource = getDataSource(); //2.流中的数据的聚合 //List<Integer> list = dataSource.collect(Collectors.toList()); //System.out.println(list);//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] //Set<Integer> set = dataSource.collect(Collectors.toSet()); //System.out.println(set);//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] //Map<String, Integer> map = dataSource.collect(Collectors.toMap(i -> i.toString(), i -> i));//i.toString作为键 i作为值 Map<String, Integer> map = dataSource.collect(Collectors.toMap(Object::toString, i -> i));//i.toString作为键 i作为值 System.out.println(map);//{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9} } //数据源的获取，从一个容器中获取数据源中的数据（得到一个Stream对象） public static Stream<Integer> getDataSource(){ //1.准备一个容器 List<Integer> dataSource = new ArrayList<>(); //2.向数据源中添加数据 Collections.addAll(dataSource, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); //3.读取数据源中的数据，得到Stream对象 return dataSource.stream(); } }
2. reduce
将流中的数据按照一定的规则聚合起来。将流的元素，逐一带入这个方法中，进行运算。最终的运算结果，得到的其实是一个Optional类型，需要使用get()获取到里面的数据
public class FinalOperation { public static void main(String[] args) { reduceUsage(); } public static void reduceUsage(){ //1.读取数据源，得到流对象 Stream<Integer> dataSource = getDataSource(); //2.最终操作 (这里有两个参数,实现了从0到9的和的求值 即p1=0 p2=1 和的结果为1作为p1 再跟p2=2相加,以此类推) Integer num = dataSource.reduce((p1, p2) -> p1 + p2).get(); //Integer num = dataSource.reduce(Integer::sum).get(); //3.输出 System.out.println(num);//45 } //数据源的获取，从一个容器中获取数据源中的数据（得到一个Stream对象） public static Stream<Integer> getDataSource(){ //1.准备一个容器 List<Integer> dataSource = new ArrayList<>(); //2.向数据源中添加数据 Collections.addAll(dataSource, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); //3.读取数据源中的数据，得到Stream对象 return dataSource.stream(); } }
3. count
统计流中的元素数量
public class FinalOperation { public static void main(String[] args) { countUsage(); } public static void countUsage(){ //1.读取数据源，得到流对象 Stream<Integer> dataSource = getDataSource(); //2.最终操作 获取元素数量 Long num = dataSource.count(); //3.输出 System.out.println(num);//10 } //数据源的获取，从一个容器中获取数据源中的数据（得到一个Stream对象） public static Stream<Integer> getDataSource(){ //1.准备一个容器 List<Integer> dataSource = new ArrayList<>(); //2.向数据源中添加数据 Collections.addAll(dataSource, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); //3.读取数据源中的数据，得到Stream对象 return dataSource.stream(); } }
4. forEach
迭代、遍历流中的数据
public class FinalOperation { public static void main(String[] args) { forEachUsage(); } public static void forEachUsage(){ //1.读取数据源，得到流对象 Stream<Integer> dataSource = getDataSource(); //2.最终操作 遍历流中的数据 输出 dataSource.forEach(System.out::print);//0123456789 } //数据源的获取，从一个容器中获取数据源中的数据（得到一个Stream对象） public static Stream<Integer> getDataSource(){ //1.准备一个容器 List<Integer> dataSource = new ArrayList<>(); //2.向数据源中添加数据 Collections.addAll(dataSource, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); //3.读取数据源中的数据，得到Stream对象 return dataSource.stream(); } }
5. max&min
获取流中的最大/最小元素
public class FinalOperation { public static void main(String[] args) { maxAndMinUsage(); } //按照执行的对象比较的规则去进行大小的比较，然后得出流中最大、最小的数据 public static void maxAndMinUsage(){ //1.读取数据源，得到流对象 Stream<Integer> dataSource = getDataSource(); //2.最终操作 获取流中的最大、最小值 //Integer max = dataSource.max(Integer::compareTo).get(); //System.out.println(max);//9 Integer min = dataSource.min(Integer::compareTo).get(); System.out.println(min);//0 } //数据源的获取，从一个容器中获取数据源中的数据（得到一个Stream对象） public static Stream<Integer> getDataSource(){ //1.准备一个容器 List<Integer> dataSource = new ArrayList<>(); //2.向数据源中添加数据 Collections.addAll(dataSource, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); //3.读取数据源中的数据，得到Stream对象 return dataSource.stream(); } }
6. Matching
allMatch：只有当流中所有的元素，都匹配指定的规则，才会返回true
anyMatch：只要流中有任意的数据，满足指定的规则，都会返回true
noneMatch：只有当流中所有的元素，都不满足指定的规则，才会返回true
public static void main(String[] args) { matchingUsage(); } public static void matchingUsage(){ //1.读取数据源,获取Stream对象 Stream<Integer> dataSource = getDataSource(); //2.匹配的操作 //boolean b = dataSource.allMatch(e -> e>0); //System.out.println(b);//false 因为不是集合中所有的元素都大于0 还有一个等于0 //boolean b = dataSource.anyMatch(e -> e >= 9); //System.out.println(b);//true boolean b = dataSource.noneMatch(e -> e > 9); System.out.println(b);//true } //数据源的获取，从一个容器中获取数据源中的数据（得到一个Stream对象） public static Stream<Integer> getDataSource(){ //1.准备一个容器 List<Integer> dataSource = new ArrayList<>(); //2.向数据源中添加数据 Collections.addAll(dataSource, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); //3.读取数据源中的数据，得到Stream对象 return dataSource.stream(); }
7. find
findFirst：从流中获取一个元素（是获取的开头元素）
findAny：从流中获取一个元素（一般情况下，是获取的开头的元素）
这两个方法，绝大部分情况下，是完全相同的，但是在多线程环境下，返回结果可能不一样
public static void main(String[] args) { findUsage(); } public static void findUsage(){ //1.实例化一个集合 ArrayList<Integer> dataSource = new ArrayList<>(); Collections.addAll(dataSource, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9); //2.findFirst演示 //Integer integer = dataSource.stream().findFirst().get();//串行流 //Integer integer = dataSource.parallelStream().findFirst().get();//并行流 //System.out.println(integer);//串行流或者是并行流结果都是0 //3.findAny演示 //Integer integer = dataSource.stream().findAny().get();//串行流 Integer integer = dataSource.parallelStream().findAny().get();//并行流 System.out.println(integer);//串行流是0、并行流结果为6 即不一定是0 }
8. IntStream
主要可以实现获取流中int类型数据的最大值、最小值、平均值、和、数量
还可以获取到一个对流中数据的分析结果（即一次获取所有类型的值）
public static void main(String[] args) { intStreamUsage(); } public static void intStreamUsage(){ //1.准备一个int数组作为数据源 int[] array = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; //2.读取数据到流中，获取IntStream对象 IntStream stream = Arrays.stream(array); //3.输出 //System.out.println(stream.max().getAsInt());//获取最大值 9 //System.out.println(stream.min().getAsInt());//获取最小值 0 //System.out.println(stream.sum());//获取和 45 //System.out.println(stream.count());//获取流中数据个数 10 //System.out.println(stream.average().getAsDouble());//获取流中数据的平均值 4.5 //4.获取到一个对流中数据的分析结果（即一次获取所有类型的值） IntSummaryStatistics intSummaryStatistics = stream.summaryStatistics(); System.out.println("最大值："+intSummaryStatistics.getMax()+" 最小值："+intSummaryStatistics.getMin());//最大值：9 最小值：0 System.out.println("平均值："+intSummaryStatistics.getAverage()+" 和："+intSummaryStatistics.getSum());//平均值：4.5 和：45 System.out.println("数量："+intSummaryStatistics.getCount());//数量：10 }
四、中间操作
将数据从数据源中读取到流中，就是对流中的数据进行各种各样的操作、处理。中间操作可以连续操作，每一个操作的返回值都是一个Stream对象，可以继续进行其他的操作，直到最终操作。
中间操作主要分为：filter、distinct、sorted、limit&skip、map&flatMap、Collections工具类
1. filter
条件过滤，仅保留流中满足指定条件的数据，其他不满足的数据都会被删除。
//学生类：存储于集合中的数据类型 private static class Student{ private String name; private int age; private int score; public Student(String name, int age, int score) { this.name = name; this.age = age; this.score = score; } //这里省略getter、setter、toString方法 } public static void main(String[] args) { filterUsage(); } public static void filterUsage(){ //1. 获取数据源 Stream<Student> dataSource = getDataSource(); //2. 过滤掉集合中成绩不合格的学生信息 dataSource.filter(s -> s.getScore()>=60).forEach(System.out::println); //Student{name='xiaoming', age=18, score=100} //Student{name='xiaoming', age=19, score=90} //Student{name='xiaoming', age=20, score=80} //Student{name='xiaoming', age=21, score=70} //Student{name='xiaoming', age=22, score=60} } //读取数据源，将集合中存储的数据，读取到数据源中 public static Stream<Student> getDataSource(){ //1.实例化一个集合，存Student对象 ArrayList<Student> arrayList = new ArrayList<>(); //2.添加若干数据 Collections.addAll(arrayList, new Student("xiaoming",18,100), new Student("xiaoming",19,90), new Student("xiaoming",20,80), new Student("xiaoming",21,70), new Student("xiaoming",22,60), new Student("xiaoming",23,50), new Student("xiaoming",24,40) ); //3.读取数据源，得到Stream对象 return arrayList.stream(); }
2. distinct
去除集合中重复的元素，这个方法没有参数，去重的规则与HashSet相同。
（1）比较两个对象的hashcode
（2）使用equals再来对比一下
这里要注意：实体类中需要重写hashcode和equals方法，否则去重可能不会生效
//学生类：存储于集合中的数据类型 private static class Student{ private String name; private int age; private int score; public Student(String name, int age, int score) { this.name = name; this.age = age; this.score = score; } //这里省略getter、setter、toString、hashcode、equals方法 } public static void main(String[] args) { distinctUsage(); } public static void distinctUsage(){ //1. 获取数据源 Stream<Student> dataSource = getDataSource(); //2. 去重 要注意实体类Student中需要重写equals和hashCode方法，否则去重不会生效 dataSource.distinct().forEach(System.out::println); //Student{name='xiaoming1', age=18, score=100} //Student{name='xiaoming2', age=20, score=80} //Student{name='xiaoming3', age=21, score=70} //Student{name='xiaoming4', age=22, score=60} //Student{name='xiaoming5', age=23, score=50} //Student{name='xiaoming6', age=24, score=40} } //读取数据源，将集合中存储的数据，读取到数据源中 public static Stream<Student> getDataSource(){ //1.实例化一个集合，存Student对象 ArrayList<Student> arrayList = new ArrayList<>(); //2.添加若干数据 Collections.addAll(arrayList, new Student("xiaoming1",18,100), new Student("xiaoming1",18,100), new Student("xiaoming2",20,80), new Student("xiaoming3",21,70), new Student("xiaoming4",22,60), new Student("xiaoming5",23,50), new Student("xiaoming6",24,40) ); //3.读取数据源，得到Stream对象 return arrayList.stream(); }
3. sorted
对流中的数据进行排序
（1）无参：sorted():将流中的数据,按照其对应的类实现的Comparable接口提供的比较规则进行排序
（2）有参：sorted(Comparator<T> comparator):将流中的数据，按照参数接口提供的比较规则进行排序
private static class Student implements Comparable<Student>{ private String name; private int age; private int score; public Student(String name, int age, int score) { this.name = name; this.age = age; this.score = score; } @Override public int compareTo(Student o) { return score-o.score; } //这里省略getter、setter、toString、hashcode、equals方法 } public static void main(String[] args) { sortedUsage(); } public static void sortedUsage(){ //1. 获取数据源 Stream<Student> dataSource = getDataSource(); //2. 将流中的数据进行排序 (注意实体类要注意实现Comparable接口并重写compareTo方法，否则会报错) //dataSource.sorted().forEach(System.out::println); //Student{name='xiaoming6', age=24, score=40} //Student{name='xiaoming5', age=23, score=50} //Student{name='xiaoming4', age=22, score=60} //Student{name='xiaoming3', age=21, score=70} //Student{name='xiaoming2', age=20, score=80} //Student{name='xiaoming1', age=18, score=100} //Student{name='xiaoming1', age=18, score=100} //3. 对流中的数据按照自定义的规则进行排序 (按照年龄升序排列) dataSource.sorted((s1,s2)->s1.getAge()-s2.getAge()).forEach(System.out::println); //Student{name='xiaoming1', age=18, score=100} //Student{name='xiaoming1', age=18, score=100} //Student{name='xiaoming2', age=20, score=80} //Student{name='xiaoming3', age=21, score=70} //Student{name='xiaoming4', age=22, score=60} //Student{name='xiaoming5', age=23, score=50} //Student{name='xiaoming6', age=24, score=40} } //读取数据源，将集合中存储的数据，读取到数据源中 public static Stream<Student> getDataSource(){ //1.实例化一个集合，存Student对象 ArrayList<Student> arrayList = new ArrayList<>(); //2.添加若干数据 Collections.addAll(arrayList, new Student("xiaoming1",18,100), new Student("xiaoming1",18,100), new Student("xiaoming2",20,80), new Student("xiaoming3",21,70), new Student("xiaoming4",22,60), new Student("xiaoming5",23,50), new Student("xiaoming6",24,40) ); //3.读取数据源，得到Stream对象 return arrayList.stream(); }
4. limit&skip
limit:限制，截取流中指定数量的元素 skip：跳过流中的指定数量的元素 经常放在一起用
//实体类省略，参考上面即可 public static void main(String[] args) { limitAndSkipUsage(); } public static void limitAndSkipUsage(){ //1. 获取数据源 Stream<Student> dataSource = getDataSource(); //2. 获取成绩的前5名 // dataSource.distinct() // .sorted((s1,s2)->s2.getScore()-s1.getScore()) // .limit(5) // .forEach(System.out::println); //3. 获取成绩为3-5名的 dataSource.distinct() .sorted((s1,s2)->s2.getScore()-s1.getScore()) .limit(5) .skip(2) .forEach(System.out::println); } //读取数据源，将集合中存储的数据，读取到数据源中 public static Stream<Student> getDataSource(){ //1.实例化一个集合，存Student对象 ArrayList<Student> arrayList = new ArrayList<>(); //2.添加若干数据 Collections.addAll(arrayList, new Student("xiaoming1",18,100), new Student("xiaoming1",18,100), new Student("xiaoming2",20,80), new Student("xiaoming3",21,70), new Student("xiaoming4",22,60), new Student("xiaoming5",23,50), new Student("xiaoming6",24,40) ); //3.读取数据源，得到Stream对象 return arrayList.stream(); }
5. map&flatMap
对流中的数据进行映射，用新的数据替换旧的数据
map最主要，就是来做元素的替换，其实map是一个元素的映射（将流中每一个元素替换成指定的元素）
flatMap也是元素的映射，flatMap是扁平化映射
扁平化映射:一般用在map映射完成后，流中的数据是一个容器，而我们需要对容器中的数据进行处理 此时使用扁平化映射，可以将流中的容器中的数据，直接读取到流中
案例1：
public static void main(String[] args) { mapUsage(); } public static void mapUsage(){ //1. 获取数据源 Stream<Student> dataSource = getDataSource(); //2. 实际需求：获取所有学生的名字 //dataSource.map(Student::getName).forEach(System.out::println); //dataSource.map(s->s.getName()).forEach(System.out::println); //3. 实际需求：获取所有学生的成绩 注意：泛型中不能是基本数据类型，只能是包装类 即下面的返回值应该为Stream<Integer> //dataSource.map(Student::getScore).forEach(System.out::println); //4. 实际需求：获取所有学生的成绩 IntSummaryStatistics intSummaryStatistics = dataSource.mapToInt(Student::getScore).summaryStatistics(); System.out.println(intSummaryStatistics.getMax()); } //读取数据源，将集合中存储的数据，读取到数据源中 public static Stream<Student> getDataSource(){ //1.实例化一个集合，存Student对象 ArrayList<Student> arrayList = new ArrayList<>(); //2.添加若干数据 Collections.addAll(arrayList, new Student("xiaoming1",18,100), new Student("xiaoming1",18,100), new Student("xiaoming2",20,80), new Student("xiaoming3",21,70), new Student("xiaoming4",22,60), new Student("xiaoming5",23,50), new Student("xiaoming6",24,40) ); //3.读取数据源，得到Stream对象 return arrayList.stream(); }
案例2：
public static void main(String[] args) { mapUsage(); } public static void mapUsage(){ //1.实例化一个字符串数组 String[] array = {"hello","world"}; //2.将字符串数组中的数据读取到流中 Stream<String> stream = Arrays.stream(array); //3.需求:统计字符串数组中所有出现的字符 //stream.map(String::toCharArray).forEach(e->System.out.println(Arrays.toString(e))); //结果为 [h, e, l, l, o] [w, o, r, l, d] 两个数组 不符合我们的要求 stream.map(s->s.split("")) .flatMap(Arrays::stream) .distinct() .forEach(System.out::println); //结果为h e l o w r d }
6. Collections工具类
Collectors是一个工具类，里面封装了很多方法，可以很方便的获取到一个Collector接口的实现类对象，从而可以使用collect()方法，对流中的数据，进行各种各样的处理、整合。
常用方法：
Collectors.toList() 将流中的数据，聚合到一个List集合中
Collectors.toSet() 将流中的数据，聚合到一个Set集合中
Collectors.toMap() 将流中的数据，聚合到一个Map集合中
maxBy() 按照指定的规则，找到流中最大的元素，等同于max
minBy() 按照指定的规则，找到流中最小的元素，等同于min
joining() 将流中的数据拼接成一个字符串，注意:只能操作流中是String的数据
summingInt() 将流中的数据，映射成int类型的数据，并求和
averagingInt() 将流中的数据，映射成int类型的数据，并求平均值
summarizingInt() 将流中的数据，映射成int类型的数据，并获取描述信息
public static void main(String[] args) { //1. 准备一个字符串数组，作为数据源 String[] dataSource = {"nihao","wo","shi","xxx"}; //2. 读取数据源中的数据 Stream<String> stream = Arrays.stream(dataSource); //3. joining方法，只适用于 Stream<String> 这种流 //String collect = stream.collect(Collectors.joining());//拼接 //System.out.println(collect);//nihaowoshixxx //String collect = stream.collect(Collectors.joining(","));//拼接 按照逗号分隔 //System.out.println(collect);//nihao,wo,shi,xxx //tring collect = stream.collect(Collectors.joining(",","[","]"));//拼接 带前缀、后缀 //System.out.println(collect);//[nihao,wo,shi,xxx] //4. summingInt Integer collect = stream.collect(Collectors.summingInt(String::length)); System.out.println(collect);//13 }
持续更新！！！
注意：本篇文章大多数内容来自bilibili网站千锋教育，地址：https://www.bilibili.com/video/BV1fT4y177ui?p=6 本篇文章仅用于个人学习和总结，如有侵权，联系删除！