• Day07 Stream流&递归&Map集合&Collections&可变参数

    Stream

            也叫Stream流，是Jdk8开始新增的一套API (java.util.stream.*)，可以用于操作集合或者数组的数据。

           Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作

    1. public class Demo1 {
    2.     public static void main(String[] args) {
    3.         List list = new ArrayList<>();
    4.         list.add("张无忌");
    5.         list.add("周芷若");
    6.         list.add("赵敏");
    7.         list.add("张强");
    8.         list.add("张三丰");
    9.  
    10.         //需求:把集合中所有以"张"开头，且是3个字的元素存储到一个新的集合。
    11.         
    12.         //实现2: 使用Stream流方式实现
    13.  
    14.          List list1 = list.stream().filter(name -> name.startsWith("张") ).
    15.                    filter(name -> name.length() == 3).collect(Collectors.toList());
    16.         System.out.println(list1);
    17.     }
    18. }

    Stream流的使用步骤 

    1.                                       2.                                              3.

                      

    如何获取Stream流 

    如何获取Stream流:
    Collection集合:
        单列集合都支持一个stream()方法,它可以直接获取集合的Stream流
    数组:
        Arrays.stream(数组)
    零散数据:
        Stream.of(T... values)
    Map
        双列集合并没有提供直接获取Stream流的方法,他需要间接获取

    1. public class Demo2 {
    2.     public static void main(String[] args) {
    3.         //"玄奘", "悟空", "悟能", "悟净"
    4.  
    5.         List list = List.of("玄奘", "悟空", "悟能", "悟净");
    6.         //Collection集合: 单列集合都支持一个stream()方法,它可以直接获取集合的Stream流
    7.  
    8.         list.stream().forEach(System.out::println);
    9.  
    10.         //数组:Arrays.stream(数组)
    11.         System.out.println("-------------------------------------");
    12.         String[] arr = {"玄奘", "悟空", "悟能", "悟净"};
    13.  
    14.         Arrays.stream(arr).forEach(System.out::println);
    15.         //零散数据:Stream.of(T... values)
    16.  
    17.         System.out.println("-------------------------------------");
    18.         Stream.of("玄奘", "悟空", "悟能", "悟净").forEach(System.out::println);
    19.         //Map:双列集合并没有提供直接获取Stream流的方法,他需要间接获取
    20.  
    21.         System.out.println("-------------------------------------");
    22.         Map map = new HashMap<>();
    23.         map.put("001","玄奘");
    24.         map.put("002","悟空");
    25.         map.put("003","悟能");
    26.         map.put("004","悟净");
    27.  
    28.  
    29.         //返回一个Set集合
    30.         map.keySet().stream().forEach(System.out::println);
    31.         map.values().stream().forEach(System.out::println);
    32.         System.out.println("-------------------------------------");
    33.         //这是一个整体EntrySetkeyvalue -> e
    34.         map.entrySet().stream().forEach(e -> System.out.println(e.getValue() + e.getKey()));
    35.  
    36.     }
    37. }

    Stream流常见中间方法 

     

    1. public class Demo3 {
    2.     public static void main(String[] args) {
    3.         List list = List.of(61, 57, 66, 77, 88, 44, 100, 89, 97, 47, 70);
    4.         //需求1: 找出所有及格的分数,并打印
    5.         System.out.println("=================");
    6.  
    7.         list.stream()
    8.                 .filter(e -> e > 60)
    9.                         .forEach(System.out::println);
    10.         //需求2: 找出所有及格的分数, 正序排列, 打印输出
    11.         System.out.println("=================");
    12.  
    13.         list.stream()
    14.                 .filter(e -> e > 60)
    15.                 .sorted((o1, o2) -> o1 - o2)
    16.                 .forEach(System.out::println);
    17.         //需求3: 找出所有及格的分数, 倒序排列, 打印输出
    18.         System.out.println("=================");
    19.         list.stream()
    20.                 .filter(e -> e > 60)
    21.                         .sorted((o1, o2) -> o2 - o1)
    22.                                 .forEach(System.out::println);
    23.         //需求4: 找出所有及格的分数, 倒序排列, 取前3名, 打印输出
    24.         System.out.println("=================");
    25.  
    26.         list.stream().filter(e -> e > 60)
    27.                 .sorted((o1, o2) -> o2 - o1)
    28.                         .limit(3)
    29.                                 .forEach(System.out::println);
    30.  
    31.         //需求5: 找出所有及格的分数, 倒序排列, 取前4-6名, 打印输出
    32.         System.out.println("=================");
    33.  
    34.  
    35.         list.stream().filter(e -> e > 60)
    36.                 .sorted((o1, o2) -> o2 - o1)
    37.                         .skip(3)
    38.                                 .limit(3)
    39.                                         .forEach(System.out::println);
    40.         //需求6:  找出所有及格的分数, 倒序排列, 取前4-6名, 将每个人的分数加10分, 打印输出
    41.         System.out.println("=================");
    42.  
    43.         list.stream().filter(e -> e > 60)
    44.                 .sorted((o1, o2) -> o2 - o1)
    45.                 .skip(3)
    46.                 .limit(3)
    47.                 .map(e -> e + 10)
    48.                 .forEach(System.out::println);
    49.  
    50.         //需求7: 将下面两个集合中的元素进行合并去重
    51.         System.out.println("=================");
    52.         List list1 = List.of("1","2","3","4");
    53.         List list2 = List.of("1","5","7","4");
    54.         Stream.concat(list1.stream(),list2.stream())
    55.                 .distinct()
    56.                 .forEach(System.out::println);
    57.  
    58.  
    59.     }
    60. }

     Stream流常见终结方法

                         调用完成后，不会返回新Stream了，没法继续使用流了。 

     

    1. public class Demo4 {
    2.     public static void main(String[] args) {
    3.         List list = List.of(
    4.                 new Student("玄奘", 60, 165.5),
    5.                 new Student("悟空", 50, 175.5),
    6.                 new Student("悟能", 55, 145.5),
    7.                 new Student("悟净", 40, 185.5)
    8.         );
    9.  
    10.         //1. 打印出集合中所有元素
    11.  
    12.         list.stream().forEach(System.out::println);
    13.         //2. 统计出身高不足170的人数
    14.  
    15.         Stream stream = list.stream().filter(e -> e.getHeight() < 170);
    16.         long count = stream.count();
    17.         System.out.println(count);
    18.         //3. 请找出年龄最大的对象, 并输出(了解)
    19.  
    20.         Student student = list.stream()
    21.                 .max((o1, o2) -> o1.getAge() - o2.getAge())
    22.                 .get();
    23.         System.out.println(student);
    24.             //4. 请找出身高最低的对象, 并输出(了解)
    25.  
    26.         Student student2 = list.stream()
    27.                 .min((o1, o2) -> Double.compare(o1.getHeight(),o2.getHeight()))
    28.                 .get();
    29.         System.out.println(student2);
    30.     }
    31. }
    32.  
    33. class Student {
    34.     private String name;
    35.     private int age;
    36.     private double height;
    37.  
    38.     public Student() {
    39.     }
    40.  
    41.     public Student(String name, int age, double height) {
    42.         this.name = name;
    43.         this.age = age;
    44.         this.height = height;
    45.     }
    46.  
    47.     public String getName() {
    48.         return name;
    49.     }
    50.  
    51.     public void setName(String name) {
    52.         this.name = name;
    53.     }
    54.  
    55.     public int getAge() {
    56.         return age;
    57.     }
    58.  
    59.     public void setAge(int age) {
    60.         this.age = age;
    61.     }
    62.  
    63.     public double getHeight() {
    64.         return height;
    65.     }
    66.  
    67.     public void setHeight(double height) {
    68.         this.height = height;
    69.     }
    70.  
    71.     @Override
    72.     public String toString() {
    73.         return "Student{" +
    74.                 "name='" + name + '\'' +
    75.                 ", age=" + age +
    76.                 ", height=" + height +
    77.                 '}';
    78.     }
    79. }

     

    Stream流转数组/集合 

    1. public class Demo5 {
    2.     public static void main(String[] args) {
    3.         List list = List.of(
    4.                 new Teacher("玄奘", 60, 165.5),
    5.                 new Teacher("悟空", 50, 175.5),
    6.                 new Teacher("悟空", 50, 175.5),
    7.                 new Teacher("悟能", 55, 145.5),
    8.                 new Teacher("悟净", 40, 185.5));
    9.  
    10.         //1. 请找出身高超过170的教师, 并放到一个新数组中
    11.  
    12.         Object[] objects = list.stream()
    13.                      .filter(e -> e.getHeight() > 170)
    14.                      .toArray();
    15.         System.out.println(Arrays.toString(objects));
    16.  
    17.        Teacher[] teacher =  list.stream()
    18.                 .filter(e -> e.getHeight() > 170)
    19.                 //len代表元素中的个数
    20.                 .toArray(len -> new Teacher[len]);
    21.         System.out.println(Arrays.toString(teacher));
    22.         //2. 请找出身高超过170的教师, 并放到一个新List集合中
    23.  
    24.         List list1 = list.stream()
    25.                 .filter(e -> e.getHeight() > 170)
    26.                         .collect(Collectors.toList());
    27.         System.out.println(list1);
    28.         //3. 请找出身高超过170的教师, 并放到一个新Set集合中
    29.         Set list2 = list.stream()
    30.                 .filter(e -> e.getHeight() > 170)
    31.                         .collect(Collectors.toSet());
    32.         System.out.println(list2);
    33.         //4. 请找出所有的教师的姓名和身高, 放到一个新Map集合中
    34.         
    35.         Map map = list.stream()
    36.                 .distinct()
    37.                 .collect(Collectors.toMap(e -> e.getName(), e-> e.getHeight()));
    38.         System.out.println(map);
    39.     }
    40. }
    41.  
    42. class Teacher {
    43.     private String name;
    44.     private int age;
    45.     private double height;
    46.  
    47.     public Teacher() {
    48.     }
    49.  
    50.     public Teacher(String name, int age, double height) {
    51.         this.name = name;
    52.         this.age = age;
    53.         this.height = height;
    54.     }
    55.  
    56.     public String getName() {
    57.         return name;
    58.     }
    59.  
    60.     public void setName(String name) {
    61.         this.name = name;
    62.     }
    63.  
    64.     public int getAge() {
    65.         return age;
    66.     }
    67.  
    68.     public void setAge(int age) {
    69.         this.age = age;
    70.     }
    71.  
    72.     public double getHeight() {
    73.         return height;
    74.     }
    75.  
    76.     public void setHeight(double height) {
    77.         this.height = height;
    78.     }
    79.  
    80.     @Override
    81.     public boolean equals(Object o) {
    82.         if (this == o) return true;
    83.         if (o == null || getClass() != o.getClass()) return false;
    84.         Teacher teacher = (Teacher) o;
    85.         return age == teacher.age && Double.compare(teacher.height, height) == 0 && Objects.equals(name, teacher.name);
    86.     }
    87.  
    88.     @Override
    89.     public int hashCode() {
    90.         return Objects.hash(name, age, height);
    91.     }
    92.  
    93.     @Override
    94.     public String toString() {
    95.         return "Teacher{" +
    96.                 "name='" + name + '\'' +
    97.                 ", age=" + age +
    98.                 ", height=" + height +
    99.                 '}';
    100.     }
    101. }

    Map集合

    1.Map集合称为双列集合，一次需要存一对数据做为一个元素, 格式：{key1=value1 ,        key2=value2 , key3=value3 , ...}

    2.Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

    Map集合体系

     

    Map集合的实现类有哪些？各自的特点是？ 

       1.HashMap: 无序，不重复

       2.LinkedHashMap: 有序，不重复

       3.TreeMap：排序，不重复 

     Map接口常用方法

     

    Map集合三种遍历方式 

    1. public class Demo2 {
    2.     public static void main(String[] args) {
    3.         //1. 创建map
    4.         HashMap map = new HashMap<>();
    5.         map.put("001", "玄奘");
    6.         map.put("002", "悟空");
    7.         map.put("003", "悟能");
    8.         map.put("004", "悟净");
    9.  
    10.         //2. 各种方式进行遍历
    11.         test1(map);
    12.         System.out.println("=================");
    13.         test2(map);
    14.         System.out.println("=================");
    15.         test3(map);
    16.     }
    17.  
    18.     //遍历方式1: 先获取Map集合全部的键，再通过遍历键来找值
    19.     private static void test1(HashMap map) {
    20.  
    21.         Set set = map.keySet();
    22.         for (String s : set) {
    23.             System.out.println(s + map.get(s));
    24.         }
    25.     }
    26.  
    27.     //遍历方式2: 将map中的所有键值对放入一个set集合中, 然后遍历set集合拿到每个键值对, 再取里面的键值
    28.     private static void test2(HashMap map) {
    29.  
    30.         Set> entries = map.entrySet();
    31.  
    32.         for (Map.Entry entry : entries) {
    33.             System.out.println(entry.getKey() + entry.getValue());
    34.         }
    35.     }
    36.  
    37.     //遍历方式3: Lambda, 使用foreach(BiConsumer bc)
    38.     private static void test3(HashMap map) {
    39.  
    40.         map.forEach((k,v) -> System.out.println(k+v));
    41.     }
    42. }

    Map集合案例 

     

    现有字符串数组如下:
    String[] bookArr = {"《红楼梦》-曹雪芹","《西游记》-吴承恩","《三国演义》-罗贯中","《水浒传》-施耐庵"};
需求:
    请将字符串中的书名提取为Map集合的键，将作者提取为Map集合的值
    并使用三种不同方式，遍历Map集合打印键值对元素内容
    1. public class Demo3 {
    2.     public static void main(String[] args) {
    3.  
    4.         Map map = new HashMap<>();
    5.         String[] bookArr = {"《红楼梦》-曹雪芹","《西游记》-吴承恩","《三国演义》-罗贯中","《水浒传》-施耐庵"};
    6.         for (String book : bookArr) {
    7.  
    8.             String[] split = book.split("-");
    9.             map.put(split[0],split[1] );
    10.         }
    11.  
    12.         System.out.println(map);
    13.  
    14.         Set set = map.keySet();
    15.         for (String key : set) {
    16.  
    17.             System.out.println(key + map.get(key));
    18.  
    19.         }
    20.         System.out.println("----------------------------");
    21.         Set> entries = map.entrySet();
    22.         for (Map.Entry entry : entries) {
    23.             System.out.println(entry.getKey()+entry.getValue());
    24.         }
    25.         System.out.println("----------------------------");
    26.         map.forEach((key , value) -> System.out.println(key+value));
    27.  
    28.  
    29.     }
    30. }

     HashMap底层原理

          和HashSet一样 :Day06List接口&Set接口&树-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_60388241/article/details/133930070?spm=1001.2014.3001.5501

    LinkedHashMap

    底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)。 

    TreeMap 

    1. public class Demo6 {
    2.     private String put;
    3.  
    4.     public static void main(String[] args) {
    5.         //创建集合
    6.         Map map = new TreeMap<>((o1, o2) -> o1.getAge() - o2.getAge());
    7.         map.put(new Teacher("张三", 21), "河北");
    8.         map.put(new Teacher("李四", 20), "山东");
    9.         map.put(new Teacher("王五", 19), "山西");
    10.         map.put(new Teacher("赵六", 21), "河南");
    11.  
    12.         map.forEach((k, v) -> {
    13.             System.out.println(k + "-----" + v);
    14.         });
    15.     }
    16. }
    17.  
    18. class Teacher {
    19.     private String name;
    20.     private int age;
    21.  
    22.     public Teacher() {
    23.     }
    24.  
    25.     public Teacher(String name, int age) {
    26.         this.name = name;
    27.         this.age = age;
    28.     }
    29.  
    30.     public String getName() {
    31.         return name;
    32.     }
    33.  
    34.     public void setName(String name) {
    35.         this.name = name;
    36.     }
    37.  
    38.     public int getAge() {
    39.         return age;
    40.     }
    41.  
    42.     public void setAge(int age) {
    43.         this.age = age;
    44.     }
    45.  
    46.     @Override
    47.     public String toString() {
    48.         return "Teacher{" +
    49.                 "name='" + name + '\'' +
    50.                 ", age=" + age +
    51.                 '}';
    52.     }
    53. }

     集合的嵌套

    集合嵌套
    要求在程序中记住如下省份和其对应的城市信息，记录成功后，要求可以查询出湖北省的城市信息。

数据
    江苏省 = "南京市","扬州市","苏州市","无锡市","常州市"
    湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"
    河北省 = "石家庄市","唐山市","邢台市","保定市","张家口市"

分析:
    定义一个Map集合，键用表示省份名称，值表示城市名称，注意：城市会有多个。 Map>
    根据“湖北省”这个键获取对应的值展示即可。

    1. public class Demo7 {
    2.     public static void main(String[] args) {
    3.  
    4.         Map> map = new HashMap<>();
    5.  
    6.         List list = List.of("南京市","扬州市","苏州市","无锡市","常州市");
    7.         List list2 = List.of("石家庄市","唐山市","邢台市","保定市","张家口市");
    8.         map.put("江苏省",list);
    9.         map.put("河北省",list2);
    10.  
    11.         System.out.println(map);
    12.  
    13.     }
    14. }

     Collections

      可变参数 

    可变参数
    就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型... 参数名称

优点
    特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。
    好处：常常用来灵活的接收数据。

注意事项
    1. 可变参数在方法内部就是一个数组
    2. 一个形参列表中可变参数只能有一个
    3. 可变参数必须放在形参列表的最后面

    1. public class Demo {
    2.  
    3.     public static void main(String[] args) {
    4.  
    5.         sum(1546);
    6.  
    7.     }
    8.  
    9.     //计算2个整数的和
    10.  
    11.     //计算3个整数的和
    12.  
    13.     //计算4个整数的和
    14. 	
    15. 	//计算n个整数的和
    16.  
    17.     public static void sum(int... a){
    18.  
    19.         for (int i : a) {
    20.             System.out.println(i);
    21.         }
    22.     }
    23. }

     Collections工具类

     

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.  
    4.         List list = new ArrayList<>();
    5.         //static  boolean addAll(单列集合，可变参数)   批量添加元素
    6.         Collections.addAll(list,1,2,100,3,45);
    7.         System.out.println(list);
    8.         //static void shuffle(List集合)    打乱List集合元素顺序，每次调用都会打乱
    9.  
    10.         Collections.shuffle(list);
    11.         System.out.println(list);
    12.         //static  void  sort(List集合)   List集合进行自然排序
    13.  
    14.         Collections.sort(list);
    15.         System.out.println(list);
    16.         //排自定义类对象，需要指定排序规则
    17.         List stuList = new ArrayList<>();
    18.         stuList.add(new Student("zhangsan", 18));
    19.         stuList.add(new Student("wangwu", 22));
    20.         stuList.add(new Student("zhaoliu", 21));
    21.         stuList.add(new Student("lisi", 19));
    22.         stuList.add(new Student("qianqi", 20));
    23.  
    24.         //static void sort(List集合，比较器);List集合进行比较器排序
    25.  
    26.         Collections.sort(stuList,(o1, o2) -> o1.getAge() - o2.getAge());
    27.         System.out.println(stuList);
    28.     }
    29. }
    30.  
    31.  
    32. class Student {
    33.     private String name;
    34.     private int age;
    35.  
    36.     public Student() {
    37.     }
    38.  
    39.     public Student(String name, int age) {
    40.         this.name = name;
    41.         this.age = age;
    42.     }
    43.  
    44.     public String getName() {
    45.         return name;
    46.     }
    47.  
    48.     public void setName(String name) {
    49.         this.name = name;
    50.     }
    51.  
    52.     public int getAge() {
    53.         return age;
    54.     }
    55.  
    56.     public void setAge(int age) {
    57.         this.age = age;
    58.     }
    59.  
    60.     @Override
    61.     public String toString() {
    62.         return "Student{" +
    63.                 "name='" + name + '\'' +
    64.                 ", age=" + age +
    65.                 '}';
    66.     }
    67. }

     

     

     

     

     

  • 相关阅读:
    Linux云服务器安装mail邮件服务
    分布式事务解决方案
    Asp.Net Core6.0中MediatR的应用CQRS
    Selenium获取百度百科旅游景点的InfoBox消息盒
    C语言关于自定义字符函数和字符串函数的相关笔试题（找工作必看）
    Spring官宣网传大漏洞，并提供解决方案
    Hyperledger Fabric组织的动态添加和删除
    让技术文档网站看起来更专业
    【深度学习】大模型卷到机器人上了
    浅谈spring的@Scheduled定时任务（演示）
  • 原文地址：https://blog.csdn.net/m0_60388241/article/details/133965111