Stream之JDK8-最全使用汇总V1，2024年最新大厂大数据开发面试总结+详细解答

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

	 }
	}
	
	```

---

3.4.聚合

• 方便我们对集合、数组的数据进行统计。

  • max、min、count
  • 【案例1】获取String集合中最长的元素

  public class StreamTest {
   public static void main(String[] args) {
    List<String> list = Arrays.asList("adnm", "pot", "xbangd", "weoujgsd");
  	//打开流，对每个值得长度进行比较返回最大的一个值
    Optional<String> max = list.stream().max(Comparator.comparing(String::length));
    System.out.println("最长的字符串：" + max.get());
   }
  }
  
  

  • 【案例2】获取Integer集合中的最大值

  public class StreamTest {
   public static void main(String[] args) {
    List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
  
    // 第一种方式：自然排序
    Optional<Integer> max = list.stream().max(Integer::compareTo);
    // 第二种方式：自定义排序
    Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
     @Override
     public int compare(Integer o1, Integer o2) {
      return o1.compareTo(o2);
     }
    });
    System.out.println("自然排序的最大值：" + max.get());
    System.out.println("自定义排序的最大值：" + max2.get());
   }
  }
  
  

  • 【案例3】获取员工工资最高的人

  public class StreamTest {
   public static void main(String[] args) {
    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
    personList.add(new Person("wf", 9500, 25, "male", "wuhan"));
    personList.add(new Person("zy", 7900, 26, "female", "kelamy"));
   //打开流，比价每个人得薪资值，返回最高得
    Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
    System.out.println("员工工资最大值：" + max.get().getSalary());
   }
  }
  
  

  • 【案例4】计算Integer集合中大于6的元素的个数

  public class StreamTest {
   public static void main(String[] args) {
    List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
  	//打开流，条件过滤大于6的元素，最后统计个数返回
    long count = list.stream().filter(x -> x > 6).count();
    System.out.println("list中大于6的元素个数：" + count);
   }
  }
  
  

---

3.5.映射

• 【概念】可以将一个流的元素按照一定的映射规则映射到另一个流中。
• 【map】：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
• 【flatMap】：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
• 【案例1】英文字符串数组的元素全部改为大写，整数数组每个元素+3：

public class StreamTest {
 public static void main(String[] args) {
  String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
  List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
  List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
  List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
  System.out.println("每个元素大写：" + strList);
  System.out.println("每个元素+3：" + intListNew);
 }
}
//结果如下：
//每个元素大写：[ABCD, BCDD, DEFDE, FTR]
//每个元素+3：[4, 6, 8, 10, 12, 14]

• 【案例2】将两个字符数组合并成一个新的字符数组:

public class StreamTest {
 public static void main(String[] args) {
  List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
  List<String> listNew = list.stream().flatMap(s -> {
   // 将每个元素转换成一个stream
   String[] split = s.split(",");
   Stream<String> s2 = Arrays.stream(split);
   return s2;
  }).collect(Collectors.toList());
  System.out.println("处理前的集合：" + list);
  System.out.println("处理后的集合：" + listNew);
 }
}
//结果如下：
//处理前的集合：[m-k-l-a, 1-3-5]
//处理后的集合：[m, k, l, a, 1, 3, 5]

---

3.6.归约

• 【概念】归约reduce，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
• 【案例】求Integer集合的元素之和、乘积和最大值：

public class StreamTest {
 public static void main(String[] args) {
  List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
  // 求和方式1
  Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
  // 求和方式2
  Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
  // 求和方式3
  Integer sum3 = list.stream().reduce(0, Integer::sum);
  // 求乘积
  Optional<Integer> product = list.stream().reduce((x, y) -> x \* y);
  // 求最大值方式1
  Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
  // 求最大值写法2
  Integer max2 = list.stream().reduce(1, Integer::max);
  System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
  System.out.println("list求积：" + product.get());
  System.out.println("list求和：" + max.get() + "," + max2);
 }
}
//结果：
//list求和：29,29,29
//list求积：2112
//list求和：11,11

---

3.7.收集

• 【概念】collect收集，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。
  • collect主要依赖java.util.stream.Collectors类内置的静态方法。
  • 因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合中。
  • 常用的toList、toSet、toMap、toCollection、toConcurrentMap等等这些用法。
• 【案例】

public class StreamTest {
 public static void main(String[] args) {
  List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
  //收集为list集合，只收集偶数
  List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
  //收集为set集合，过滤重复值
  Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
  //收集为map集合
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
  personList.add(new Person("wf", 7000, 25, "male", "shanghai"));
  personList.add(new Person("hw", 7800, 21, "female", "kelamay"));
  personList.add(new Person("zy", 8200, 24, "female", "kelamay"));
  
  Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
    .collect(Collectors.toMap(Person::getName, p -> p));
  System.out.println("toList:" + listNew);
  System.out.println("toSet:" + set);
  System.out.println("toMap:" + map);
 }
}
//结果：
//toList：[6, 4, 6, 6, 20]
//toSet：[4, 20, 6]
//toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}

---

3.8.统计

• 【Collectors提供的数据统计静态方法】
  • 计数：count
  • 平均值：averagingInt、averagingLong、averagingDouble
  • 最值：maxBy、minBy
  • 求和：summingInt、summingLong、summingDouble
  • 统计以上所有：summarizingInt、summarizingLong、summarizingDouble
• 【案例】

public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
  personList.add(new Person("sam", 7000, 25, "male", "kelamy"));
  personList.add(new Person("tom", 7800, 21, "female", "kelamy"));

  // 求总数
  Long count = personList.stream().collect(Collectors.counting());
  // 求平均工资
  Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
  // 求最高工资
  Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
  // 求工资之和
  Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
  // 一次性统计所有信息
  DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

  System.out.println("员工总数：" + count);
  System.out.println("员工平均工资：" + average);
  System.out.println("员工工资总和：" + sum);
  System.out.println("员工工资所有统计：" + collect);
 }
}

---

3.9.分组

• 【Collectors提供的分组方式】
  • partitioningBy：判断且分组
  • groupingBy：只分组
• 【案例】

public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, "male", "beijing"));
  personList.add(new Person("hw", 7000, "male", "wuhan"));
  personList.add(new Person("yw", 7800, "female", "shanghai"));
  personList.add(new Person("gal", 8200, "female", "kelamay"));
  personList.add(new Person("zw", 9500, "male", "kelamay"));
  personList.add(new Person("zss", 7900, "female", "kelamay"));

       // 将员工按薪资是否高于8000分组
        Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        // 将员工按性别分组
        Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
        // 将员工先按性别分组，再按地区分组
        Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println("员工按薪资是否大于8000分组情况：" + part);
        System.out.println("员工按性别分组情况：" + group);
        System.out.println("员工按性别、地区：" + group2);
 }
}

---

3.10.接合

• 【joining】可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
• 【案例】

public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();
  personList.add(new Person("douglas", 8900, 23, "male", "beijing"));
  personList.add(new Person("zw", 7000, 25, "male", "shanghai"));
  personList.add(new Person("zy", 7800, 21, "female", "wuhan"));
//以逗号分割链接为一个字符串
  String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
  System.out.println("所有员工的姓名：" + names);
  List<String> list = Arrays.asList("A", "B", "C");
//以-连接为一个字符串
  String string = list.stream().collect(Collectors.joining("-"));
  System.out.println("拼接后的字符串：" + string);
 }
}

---

3.11.排序

• 【sorted】排序由两种操作：
  • sorted()：自然排序，流中元素需实现Comparable接口
  • sorted(Comparator com)：Comparator排序器自定义排序
• 【案例】

public class StreamTest {
 public static void main(String[] args) {
  List<Person> personList = new ArrayList<Person>();

  personList.add(new Person("douglas", 9000, 24, "female", "beijing"));
  personList.add(new Person("hw", 8900, 22, "male", "wuhan"));
  personList.add(new Person("yw", 9000, 25, "male", "shanghai"));
  personList.add(new Person("gh", 8800, 26, "male", "kelamy"));
  personList.add(new Person("wff", 9000, 26, "female", "kelamy"));

  // 按工资升序排序（自然排序）
  List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
    .collect(Collectors.toList());


**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/2dc1532f45d8a3656996ba32775f1550.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

tring> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
    .collect(Collectors.toList());


**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
[外链图片转存中...(img-YYILWSSU-1713327480625)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**