day07-集合-Map&Stream&递归

于 2024-09-04 21:11:58 发布
阅读量963 收藏 18
点赞数 14
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58478983/article/details/141872963
版权

一、Collections

1.1 可变参数

可变参数
    就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型... 参数名称
​
优点
    特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。
    好处：常常用来灵活的接收数据。
​
注意事项
    1. 可变参数在方法内部就是一个数组
    2. 一个形参列表中可变参数只能有一个
    3. 可变参数必须放在形参列表的最后面
public class Demo {
​
    public static void main(String[] args) {
        add();//可变参数可以不传参
        add(1);//可变参数可以传一个
        add(1,2);//可变参数可以传多个
        add1(1,2,3);
​
    }
​
    //计算整数的和
    public static void add(int ... nums){//一个形参列表中可变参数只能有一个
        int sum = 0;
        for (int i : nums) {
            sum += i;
        }
        System.out.println("sum=" + sum);
    }
    public static void add1(int index, int ... nums){//可变参数必须放在形参列表的最后面
        int sum = index;
        for (int i : nums) {
            sum += i;
        }
        System.out.println("sum=" + sum);
    }
​
}

1.2 Collections常用方法

Collections
    这是一个用于操作单列集合的工具类
    注意跟Collection的区别(Collection是单列集合的根接口)
​
常用方法
    static <T> boolean addAll(单列集合，可变参数)   批量添加元素
    static void shuffle(List集合)    打乱List集合元素顺序，每次调用都会打乱
    static <T> void sort(List集合)   List集合进行自然排序
    static <T> void sort(List集合，比较器)  List集合进行比较器排序
public class Demo {
    public static void main(String[] args) {
        //static <T> boolean addAll(单列集合，可变参数)   批量添加元素
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三", "李四", "王五", "赵六", "钱七");
        System.out.println(list);
        System.out.println("----------------------------");
​
        //static void shuffle(List集合)    打乱List集合元素顺序，每次调用都会打乱
        Collections.shuffle(list);
        System.out.println(list);
        System.out.println("----------------------------");
​
        //static <T> void  sort(List集合)   List集合进行自然排序
        List<Integer> nums = new ArrayList<>();
        Collections.addAll(nums,5,9,8,5,4,0,1,2);
        Collections.sort(nums);
        System.out.println(nums);
        System.out.println("----------------------------");
​
        //排自定义类对象，需要指定排序规则
        List<Student> stuList = new ArrayList<>();
        stuList.add(new Student("zhangsan", 18));
        stuList.add(new Student("wangwu", 22));
        stuList.add(new Student("zhaoliu", 21));
        stuList.add(new Student("lisi", 19));
        stuList.add(new Student("qianqi", 20));
​
        //static<T> void sort(List集合，比较器);List集合进行比较器排序
        Collections.sort(stuList, ( o1,  o2)-> {
                return o1.getAge() - o2.getAge();});
        System.out.println(stuList);
​
    }
}
​
​
class Student {
    private String name;
    private int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
​
运行结果：
    [张三, 李四, 王五, 赵六, 钱七]
    ----------------------------
    [张三, 赵六, 王五, 李四, 钱七]
    ----------------------------
    [0, 1, 2, 4, 5, 5, 8, 9]
    ----------------------------
    [Student{name='zhangsan', age=18}, Student{name='lisi', age=19},        Student{name='qianqi', age=20}, Student{name='zhaoliu', age=21},        Student{name='wangwu', age=22}]

二、Map集合

2.1 认识Map集合(适用于一一对应的一组数据)

  • Map集合称为双列集合，一次需要存一对数据做为一个元素，格式：[key1=value1，key2=value2，key3=value3，)

  • Map集合的每个元素分为两部分：key和value，key称为键，value称为值，整体叫键值对，因此Map也叫“键值对集合”

  • key不可重复，value可重复

 

2.2 Map常用方法

Map
    双列集合根接口，它的功能是全部双列集合都可以继承过来使用的。
​
常用方法
    V put(K key,V value)   添加/修改元素(存在k就修改value，不存在k就保存一组(k，v))
    int size() 获取集合的大小
    boolean isEmpty()  判断集合是否为空，为空返回true, 反之
    V get(Object key)  根据键获取对应值(根据k获取v)
    V remove(Object key)   根据键删除整个元素(根据k删除(k，v))
    boolean containsKey(Object key)      判断是否包含某个键(判断是否包含K)
    boolean containsValue(Object value)  判断是否包含某个值(判断是否包含v)
    Set<K> keySet()     获取全部键的集合
    Collection<V> values()  获取Map集合的全部值
    void clear()   清空集合
public class Demo1 {
    public static void main(String[] args) {
        //向map中存入西游四人组的编号和姓名 001-玄奘  002-悟空  003-悟能  004-悟净
        Map<String, String> hashMap = new HashMap<>();
        
        //V put(K key,V value)   添加元素
        hashMap.put("001", "玄奘");
        hashMap.put("002", "悟空");
        hashMap.put("003", "悟能");
        hashMap.put("004", "悟净");
        hashMap.put("004", "悟净11");
        System.out.println(hashMap);
        System.out.println("--------------------------");
        
        //int size()   获取集合的大小
        System.out.println("hashMap的长度为：" + hashMap.size());
        
        //boolean isEmpty()    判断集合是否为空，为空返回true, 反之
        System.out.println("hashMap是否为空：" + hashMap.isEmpty());
        System.out.println("--------------------------");
        
        //V get(Object key)    根据键获取对应值
        String s = hashMap.get("001");
        System.out.println("编号001对应的姓名为：" + s);
        System.out.println("--------------------------");
        
        //V remove(Object key) 根据键删除整个元素
        String remove = hashMap.remove("003");
        System.out.println("删除003对应的值：" + remove);
        System.out.println("删除003后的Map：" + hashMap);
        System.out.println("--------------------------");
        
        //boolean containsKey(Object key)    判断是否包含某个键
        boolean b = hashMap.containsKey("003");
        System.out.println("是否包含003：" + b);
        boolean b1 = hashMap.containsKey("004");
        System.out.println("是否包含004：" + b1);
        System.out.println("--------------------------");
        
        //boolean containsValue(Object value)    判断是否包含某个值
        boolean b2 = hashMap.containsValue("玄奘");
        System.out.println("是否包含玄奘：" + b2);
        boolean b3 = hashMap.containsValue("悟空11");
        System.out.println("是否包含悟空11：" + b3);
        System.out.println("--------------------------");
        
        //Set<K> keySet()   获取全部键的集合
        Set<String> strings = hashMap.keySet();
        System.out.println("全部键的集合为：" + strings);
        System.out.println("--------------------------");
        
        //Collection<V> values()    获取Map集合的全部值
        Collection<String> values = hashMap.values();
        System.out.println("Map集合的全部值：" + values);
        System.out.println("--------------------------");
        
        //void clear() 清空集合
        hashMap.clear();
        System.out.println("清空集合后的Map：" + hashMap);
​
    }
}

 

2.3 Map集合遍历

2.3.1 遍历方式一

遍历方式1: 先获取Map集合全部的键，再通过遍历键来找值

 

public class Demo2 {
    public static void main(String[] args) {
        //1. 创建map
        HashMap<String, String> map = new HashMap<>();
        map.put("001", "张三");
        map.put("002", "李四");
        map.put("003", "王五");
        map.put("004", "赵六");
​
        //2. 各种方式进行遍历
        test1(map);
​
    }
​
    //遍历方式1: 先获取Map集合全部的键，再通过遍历键来找值
    private static void test1(HashMap<String, String> map) {
        //1. 获取map中的所有key,Set集合
        Set<String> keys = map.keySet();
        //2.获取每个key
        for (String key : keys) {
            //3.通过key，从map中获取对应的value
            String value = map.get(key);
            System.out.println(key + "---" + value);
        }
    }
}
运行结果:
    001---张三
    002---李四
    003---王五
    004---赵六

2.3.2 遍历方式二

遍历方式2: 将map中的所有键值对放入一个set集合中, 然后遍历set集合拿到每个键值对, 再取里面的键值

 

public class Demo2 {
    public static void main(String[] args) {
        //1. 创建map
        HashMap<String, String> map = new HashMap<>();
        map.put("001", "张三");
        map.put("002", "李四");
        map.put("003", "王五");
        map.put("004", "赵六");
​
        //2. 各种方式进行遍历
        test2(map);
​
    }
​
    //遍历方式2: 将map中的所有键值对放入一个set集合中, 然后遍历set集合拿到每个键值对, 再取里面的键值
    private static void test2(HashMap<String, String> map) {
        //1.获取map中的所有entry对象(键值对)，Set集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //2.循环每个entry对象
        for (Map.Entry<String, String> entry : entrySet) {
            //System.out.println(entry);
            //3.通过entry对象获取键和值
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "---" + value);
        }
​
}
运行结果:
    001---张三
    002---李四
    003---王五
    004---赵六

2.3.3 遍历方式三

遍历方式3: Lambda, 使用foreach(BiConsumer bc)

public class Demo2 {
    public static void main(String[] args) {
        //1. 创建map
        HashMap<String, String> map = new HashMap<>();
        map.put("001", "张三");
        map.put("002", "李四");
        map.put("003", "王五");
        map.put("004", "赵六");
​
        //2. 各种方式进行遍历
        test3(map);
​
    }
    
    //遍历方式3: Lambda, 使用foreach(BiConsumer bc)
    private static void test3(HashMap<String, String> map) {
        map.forEach((k,v) -> {
            System.out.println(k + "---" + v);
        });
    }
}
运行结果:
    001---张三
    002---李四
    003---王五
    004---赵六

2.4 Map集合案例

现有字符串数组如下

String[] s = {"《红楼梦》-曹雪芹","《西游记》-吴承恩","《三国演义》-罗贯中","《水浒传》-施耐庵"};

需求

请将字符串中的书名提取为Map集合的键，将作者提取为Map集合的值

并使用三种不同方式，遍历Map集合打印键值对元素内容

public class Demo3 {
    public static void main(String[] args) {
        //1. 定义字符串数组
        String[] bookArr = {"《红楼梦》-曹雪芹","《西游记》-吴承恩","《三国演义》-罗贯中","《水浒传》-施耐庵"};
        //2.定义Map集合
        HashMap<String, String> map = new HashMap<>();
        //3.循环遍历数组
        for (String str : bookArr) {
            String[] split = str.split("-");
            //4.将字符串数组中的元素添加到Map集合中
            map.put(split[0],split[1]);
        }
        //5.循环展示（使用k找v）
        Set<String> kays = map.keySet();
        System.out.println("作品" + "---" + "作者");
        for (String kay : kays) {
            String value = map.get(kay);
            System.out.println(kay + "---" + value);
        }
        System.out.println("------------------------------");
        //6.循环展示（获取所有的entry）
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        System.out.println("作品" + "---" + "作者");
        for (Map.Entry<String, String> entry : entrySet) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "---" + value);
        }
        System.out.println("----------------------------");
        //7.循环展示（使用Lambda）
        System.out.println("作品" + "---" + "作者");
        map.forEach((key,value) ->{
            System.out.println(key + "---" + value);
        });
​
    }
}
运行结果：
    作品-----------作者
    《三国演义》---罗贯中
    《红楼梦》---曹雪芹
    《西游记》---吴承恩
    《水浒传》---施耐庵

2.5 HashMap集合的底层原理

 

/*
需求：创建一个HashMap集合，键是学生对象(Student)，值是籍贯(String)。存储三个键值对元素，并遍历
*/

public class Demo4 {
    public static void main(String[] args) {
        //1. 创建一个Map集合
        HashMap<Student, String> map = new HashMap<>();
        //2. 存储三个学生和地址
       map.put(new Student("张三", 23), "北京");
       map.put(new Student("李四", 24), "上海");
       map.put(new Student("王五", 25), "广州");
       map.put(new Student("王五", 25), "广州");
        //3. 遍历打印
        map.forEach((key,value)->{
            System.out.println(key + "---" + value);
        });
    }
}
​
class Student {
    private String name;
    private int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
运行结果：
    Student{name='张三', age=23}---北京
    Student{name='李四', age=24}---上海
    Student{name='王五', age=25}---广州

2.6 LinkedHashMap 底层原理

//存取有序
public class Demo5 {
    public static void main(String[] args) {
        //创建LinkedHashMap
       Map<Object, Object> map = new LinkedHashMap<>();
        //保存数据
        map.put("悟空", "001");
        map.put("八戒", "002");
        map.put("沙僧", "003");
        map.put("白龙马", "004");
        //观察顺序
        map.forEach((key,value)->{
            System.out.println(key + "---" + value);
        });
    }
}

2.7 TreeMap

2.7.1 TreeMap案例

需求：创建一个TreeMap集合，键是老师对象(Teacher)，值是籍贯(String)。

学生属性姓名和年龄，按照年龄进行排序并遍历。

1、让类实现Comparable接口，重写比较规则。

public class Demo6 {
    private String put;
​
    public static void main(String[] args) {
        //创建集合
        Map<Teacher, String> map = new TreeMap<>();
        map.put(new Teacher("张三", 21), "河北");
        map.put(new Teacher("李四", 20), "山东");
        map.put(new Teacher("王五", 19), "山西");
        map.put(new Teacher("赵六", 21), "河南");
​
        map.forEach((k, v) -> {
            System.out.println(k + "-----" + v);
        });
    }
}
​
class Teacher implements Comparable<Teacher>{
    private String name;
    private int age;
​
    public Teacher() {
    }
​
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    @Override
    public int compareTo(Teacher o) {
        if(this.age != o.age){
            return this.age - o.age;
        }else {
            return this.name.compareTo(o.name);
        }
​
    }
}
运行结果：   
    Teacher{name='王五', age=19}-----山西
    Teacher{name='李四', age=20}-----山东
    Teacher{name='张三', age=21}-----河北
    Teacher{name='赵六', age=21}-----河南

2、TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。

public class Demo8 {
    private String put;
​
    public static void main(String[] args) {
        //创建集合
        Map<Teacher1, String> map = new TreeMap<>(new Comparator<Teacher1>() {
            @Override
            public int compare(Teacher1 o1, Teacher1 o2) {
                if(o1.getAge()==o2.getAge()){
                    return o1.getName().compareTo(o2.getName());
                }else {
                    return o1.getAge()-o2.getAge();
                }
            }
        });
        map.put(new Teacher1("张三", 21), "河北");
        map.put(new Teacher1("李四", 20), "山东");
        map.put(new Teacher1("王五", 19), "山西");
        map.put(new Teacher1("赵六", 21), "河南");
​
        map.forEach((k, v) -> {
            System.out.println(k + "-----" + v);
        });
    }
}
​
class Teacher1 {
    private String name;
    private int age;
​
    public Teacher1() {
    }
​
    public Teacher1(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
运行结果：   
    Teacher{name='王五', age=19}-----山西
    Teacher{name='李四', age=20}-----山东
    Teacher{name='张三', age=21}-----河北
    Teacher{name='赵六', age=21}-----河南

2.8 集合的嵌套(集合中的元素又是一个集合)

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

数据

江苏省 = "南京市","扬州市","苏州市","无锡市","常州市"

湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"

河北省 = "石家庄市","唐山市","邢台市","保定市","张家口市"

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

public class Demo7 {
    public static void main(String[] args) {
        //1.创建一个Map集合，key是一个字符串，value是一个list集合
        HashMap<String, List<String>> map = new HashMap<>();
        //2.向Map集合中添加江苏省和其对应的城市
        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"南京市","扬州市","苏州市","无锡市","常州市");
        map.put("江苏省",list1);
        //3.向Map集合中添加河北省和其对应的城市
        List<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"石家庄市","唐山市","邢台市","保定市","张家口市");
        map.put("河北省",list2);
        //4.向Map集合中添加湖北省和其对应的城市
        List<String> list3 = new ArrayList<>();
        Collections.addAll(list3,"武汉市","孝感市","十堰市","宜昌市","鄂州市");
        map.put("湖北省",list3);
​
        System.out.println(map);
​
        //5.根据“湖北省”这个键获取对应的值展示即可。
        List<String> list = map.get("湖北省");
        System.out.println(list);
    }
}
运行结果：
    {江苏省=[南京市, 扬州市, 苏州市, 无锡市, 常州市], 湖北省=[武汉市, 孝感市, 十堰市, 宜昌市, 鄂州市], 河北省=[石家庄市, 唐山市, 邢台市, 保定市, 张家口市]}
    [武汉市, 孝感市, 十堰市, 宜昌市, 鄂州市]

三、Stream流

3.1 获取Stream流

使用流程
    集合/数组/…---->获取Stream流---->对流中的数据进行各种操作---->结果获取
                                   (排序、过滤、去重等等)     (收集、打印、统计)
​
如何获取Stream流
    Collection集合:
        单列集合都支持一个stream()方法,它可以直接获取集合的Stream流
    数组:
        Arrays.stream(数组)
    零散数据:
        Stream.of(T... values)
    Map
        双列集合并没有提供直接获取Stream流的方法,他需要间接获取
public class Demo2 {
    public static void main(String[] args) {
        //"玄奘", "悟空", "悟能", "悟净"
        ArrayList<String> list = new ArrayList<>();
        list.add("玄奘");
        list.add("悟空");
        list.add("悟能");
        list.add("悟净");
​
​
        //1、Collection集合: 单列集合都支持一个stream()方法,它可以直接获取集合的Stream流
        Stream<String> stream1 = list.stream();
​
        //2、数组:Arrays.stream(数组)
        String[] arr = {"玄奘", "悟空", "悟能", "悟净"};
        Stream<String> stream2 = Arrays.stream(arr);
​
        //3、零散数据:Stream.of(T... values)
        Stream<String> stream3 = Stream.of("玄奘", "悟空", "悟能", "悟净");
​
        //4、Map:双列集合并没有提供直接获取Stream流的方法,他需要间接获取
        Map<String, String> map = new HashMap<>();
        map.put("001", "玄奘");
        map.put("002", "悟空");
        map.put("003", "悟能");
        map.put("004", "悟净");
        //可以从map中获取所有的entry
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Stream<Map.Entry<String, String>> stream4 = entrySet.stream();
​
    }
}

3.2 Stream流常见的中间方法

中间方法
    对stream流进行操作的方法, 他们调用完成后会返回新的Stream流，可以继续使用(支持链式编程)。
​
常见的中间方法
    Stream<T> filter(Predicate<? super T> p) 按照规则过滤，保留满足条件的元素
    Stream<T> sorted() 升序排序
    Stream<T> sorted(Comparator<? super T> c) 按照规则排序
    Stream<T> limit(long maxSize) 截取
    Stream<T> skip(long n)  跳过
    Stream<R> map(Function<? super T, extends R> mapper) 对元素进行加工，并返回对应的新流
    Stream<T> distinct() 去重
    static <T> Stream<T> concat(Stream a,Stream b) 合并流
public class Demo3 {
    public static void main(String[] args) {
        List<Integer> list = List.of(61, 57, 66, 77, 88, 44, 100, 89, 97, 47, 70);
        //需求1: 找出所有及格的分数,并打印
        System.out.println("========及格的分数=========");
        list.stream()
                .filter(integer-> integer >= 60)
                .forEach(System.out::println);
​
        //需求2: 找出所有及格的分数, 正序排列, 打印输出
        System.out.println("=======所有及格的分数正序排列==========");
        list.stream()
                .filter(integer-> integer >= 60)
                .sorted().forEach(System.out::println);
​
        //需求3: 找出所有及格的分数, 倒序排列, 打印输出
        System.out.println("=======所有及格的分数倒序排列==========");
        list.stream().filter(integer-> integer >= 60)
                .sorted((o1, o2) ->o1<o2 ? 1 : -1)
                .forEach(System.out::println);
​
        //需求4: 找出所有及格的分数, 倒序排列, 取前3名, 打印输出
        System.out.println("=======找出所有及格的分数, 倒序排列, 取前3名==========");
        list.stream().filter(integer-> integer >= 60)
                .sorted((o1, o2) ->o1<o2 ? 1 : -1)
                .limit(3)
                .forEach(System.out::println);
​
        //需求5: 找出所有及格的分数, 倒序排列, 取前4-6名, 打印输出
        System.out.println("=======所有及格的分数, 倒序排列, 取前4-6名==========");
        list.stream().filter(integer-> integer >= 60)
                .sorted((o1, o2) ->o1<o2 ? 1 : -1)
                .skip(3)
                .limit(3)
                .forEach(System.out::println);
​
        //需求6:  找出所有及格的分数, 倒序排列, 取前4-6名, 将每个人的分数加10分, 打印输出
        System.out.println("=======所有及格的分数, 倒序排列, 取前4-6名,每个人的分数加10分==========");
        list.stream()
                .filter(e-> e >= 60)
                .sorted((o1,o2) -> o1 < o2 ? 1 : -1)
                .skip(3)
                .limit(3)
                .map(integer-> integer+10)
                .forEach(System.out::println);
        
        //需求7: 将下面两个集合中的元素进行合并
        System.out.println("=======合并==========");
        String[] arr1 = {"张三", "李四", "王五", "赵六", "田七"};
        Stream<String> stream1 = Arrays.stream(arr1);
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("吉吉");
        list1.add("毛毛");
        Stream<String> stream2 = list1.stream();
        Stream.concat(stream1, stream2).forEach(System.out::println);
​
    }
}

 

3.2 Stream流常见的终结方法

终结方法
    调用完成后，不会返回新Stream了，没法继续使用流了。
    它的作用是用来收集Stream流的结果转回到集合或者数组中去返回。
​
常见方法
    R collect(Collector collector); 将流中数据收集到指定集合，参数传递Collectors工具类调用对应方法
        Collectors.toList()
        Collectors.toSet()
        Collectors.toMap()
    Object[] toArray();把流处理后的结果收集到一个数组中去

 

public class Demo5 {
    public static void main(String[] args) {
        List<Teacher> list = List.of(
                new Teacher("玄奘", 60, 165.5),
                new Teacher("悟空", 50, 175.5),
                new Teacher("悟空", 50, 175.5),
                new Teacher("悟能", 55, 145.5),
                new Teacher("悟净", 40, 185.5));
​
        //1. 请找出身高超过170的教师, 并放到一个新数组中
        Object[] array = list.stream()
                .filter(e -> e.getHeight() > 170)
                .toArray();
        System.out.println(Arrays.toString(array));
​
        //2. 请找出身高超过170的教师, 并放到一个新List集合中
        List<Teacher> list1 = list.stream()
                .filter(e -> e.getHeight() > 170)
                .collect(Collectors.toList());
        System.out.println(list1);
​
        //3. 请找出身高超过170的教师, 并放到一个新Set集合中
        Set<Teacher> teacherSet = list.stream()
                .filter(e -> e.getHeight() > 170)
                .collect(Collectors.toSet());
        System.out.println(teacherSet);
        
        //4. 请找出所有的教师的姓名和身高, 放到一个新Map集合中
        Map<String, Double> map = list.stream().distinct()
                .collect(Collectors.toMap(teacher-> teacher.getName() , teacher -> teacher.getHeight()));
        System.out.println(map);
    }
}
​
class Teacher {
    private String name;
    private int age;
    private double height;
​
    public Teacher() {
    }
​
    public Teacher(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public double getHeight() {
        return height;
    }
​
    public void setHeight(double height) {
        this.height = height;
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        return age == teacher.age && Double.compare(teacher.height, height) == 0 && Objects.equals(name, teacher.name);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age, height);
    }
​
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}
运行结果：
    [Teacher{name='悟空', age=50, height=175.5}, Teacher{name='悟空', age=50, height=175.5}, Teacher{name='悟净', age=40, height=185.5}]
    [Teacher{name='悟空', age=50, height=175.5}, Teacher{name='悟空', age=50, height=175.5}, Teacher{name='悟净', age=40, height=185.5}]
    [Teacher{name='悟空', age=50, height=175.5}, Teacher{name='悟净', age=40, height=185.5}]
    {悟能=145.5, 悟空=175.5, 玄奘=165.5, 悟净=185.5}
​

草莓屁屁不酸
关注
  • 14
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法分析（十三）--- 集合与映射 + Set/Map容器（C++11）
流云
01-16 2526
一、集合与映射 人们把一堆东西放到一起，就称之为集合了。一般来讲，集合是具有某种特性的事物的整体，或是一些确认对象的汇集，构成集合的事物或对象称作元素或是成员。集合的元素可以是任何事物，集合具有无序性、互异性、确定性等特性。 在数学上，我们可以把映射看作是集合与集合之间的一种对应关系，比如函数实际上就是数的集合到数的集合之间的映射关系。计算机更擅长处理数字编号，我们的大脑更擅长处理概念词汇，因此我们经常需要通过某个关键词key来查询一组数据的信息value，于是就把这种映射关系抽象为一个数据结构：键值对。
Java开发学习day07-集合-Map&Stream&递归
2403_86799396的博客
09-03 190
在Java中，HashMap本身不保证元素的顺序。这意味着当你向HashMap中插入键值对时，它们在内存中的存储顺序可能会在不同的运行中或者在同一个运行的不同时间点发生变化。然而，从Java 8开始，HashMap的实现在内部使用链表和红黑树来维护条目的顺序，使得在大多数情况下，HashMap会按照插入顺序来遍历条目。但是，这种顺序的保证并不是HashMap规范的一部分，因此不应该依赖于它。如果你需要一个保证顺序的Map实现，你应该使用。维护了元素的插入顺序，或者在构造时指定的顺序（例如访问顺序）。
Day07 Stream流&递归&Map集合&Collections&可变参数
m0_60388241的博客
10-21 374
也叫Stream流，是Jdk8开始新增的一套API (java.util.stream.*)，可以用于操作集合或者数组的数据。Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作。
【Day12-Stream流&Map集合】
吾常自闭的博客
03-18 2854
一、Stream流 流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，流讲的是计算！” Stream 自己不会存储元素，Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。 一般开发的套路是：创建一个Stream：一个数据源（数组、集合）-->中间操作：一个中间操作，处理数据源数据-->终止操作：一个终止操作，执行中间操作链，产生结果。 1、JDK1.8中
day28-IO（字节流&字符流）
qq_63763836的博客
09-01 847
生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input和输出output，即流向内存是输入流，流出内存的输出流。Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。
day17-Map集合、Stream流、File类、递归
ZHUSHANGLIN的博客
05-28 891
比如有如下案例：往HashMap集合中存储Student对象作为键，学生的家庭住址当做值。要求，当学生对象的姓名和年龄相同时就认为键重复。
Day12-Java进阶-Stream流 & File类
weixin_68063226的博客
04-23 508
*需求: 键盘录入一个文件夹路径，如果输入错误就给出提示，并继续录入，直到正确为止*/System.out.println("请输入一个文件夹路径: ");if (!System.out.println("您输入的文件夹不存在, 请重新输入: ");System.out.println("您输入的是一个文件路径, 请重新输入: ");
day08-Map-递归-File-Stream
qq_25574081的博客
04-08 79
参数形式1.转list集合 2.转set集合3.转map集合（需要传递转key和value的规则）注意事项：同一流对象只能使用一次。count：统计此流运算后的元素个数。max：获取此流运算后的最大值元素。min：获取此流运算后的最小值元素。调用后，可以继续使用流中的方法，也可以使用链式调用。常用方法 foreach：对此流运算后的元素执行遍历。distinct去除流中的重复的元素。特点：返回值仍然是流对象。linkhashmap：仅仅是比hashmap多了一个保证添加元素的顺序和获取元素的一致的能力。
Day13-Java进阶-IO字节流&字符流及其练习题
weixin_68063226的博客
04-23 441
*FileReader: 用于读取纯文本文件，解决中文乱码问题构造方法:1. public FileReader(String fileName) 字符输入流关联文件，路径以字符串形式给出2. public FileReader(File file) 字符输入流关联文件，路径以File对象形式给出成员方法:public int read() : 读取单个字符public int read(char[] cbuf) : 读取一个字符数组, 返回读取到的有效字符个数*/
Day31 - 玩转Linux操作系统
Laic Zhang的博客
05-05 1888
Day31 - 玩转Linux操作系统 操作系统发展史 只有硬件没有软件的计算机系统被称之为“裸机”，我们很难用“裸机”来完成计算机日常的工作（如存储和运算），所以必须用特定的软件来控制硬件的工作。最靠近计算机硬件的软件是系统软件，其中最为重要的就是“操作系统”。“操作系统”是控制和管理整个计算机系统的硬件和软件资源，合理的分配资源和调配任务，为系统用户和其他软件提供接口和环境的程序的集合。 没有...
Python100Days学习笔记---Day16-20Python语言进阶
迷途可达C的博客
03-30 712
生成式（推导式）的用法 prices = { 'AAPL': 191.88, 'GOOG': 1186.96, 'IBM': 149.24, 'ORCL': 48.44, 'ACN': 166.89, 'FB': 208.09, 'SYMC': 21.29 } # 用股票价格大于100元的股票构造一个新的字典 prices2 = {key: ...
Day16 - Python语言进阶
Laic Zhang的博客
05-04 1266
Day16 - Python语言进阶 数据结构和算法 算法：解决问题的方法和步骤 评价算法的好坏：渐近时间复杂度和渐近空间复杂度。 渐近时间复杂度的大O标记： - 常量时间复杂度 - 布隆过滤器 / 哈希存储 - 对数时间复杂度 - 折半查找（二分查找） - 线性时间复杂度 - 顺序查找 / 桶排序 - 对数线性时间复杂度 - 高级排序算法（归并排序、快速排序） - 平...
[项目练手笔记-谷粒商城（SpringCloud Alibaba+vue前后端分离）]day03-day07商品信息三级分类API的编写（使用Element-ui树形组件）
叶落雨飘的博客
07-16 748
[项目练手笔记-谷粒商城]day03-day07三级分类API 一、获取三级分类树形列表 一、controller调用 /** * 查询所有产品，并以属性列表展示 */ @RequestMapping("/list/tree") //@RequiresPermissions("product:category:list") public R list(){ List<CategoryEntity> entities=catego
【JavaWeb】JDBC&Druid&Tomcat入门使用
lklalmq的博客
09-04 823
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3210
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 229
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1199
浅析synchronized锁升级的原理与实现
JVM 垃圾回收机制：GC
最新发布
m0_60462557的博客
09-04 796
JVM的垃圾回收机制：GC，是Java提供的对于内存自动回收的机制。
chmod 755 -R /goosefs-lite-1.0.2 && /goosefs-lite-1.0.2/bin/goosefs-lite mount /app/web cosn://app-online-1259451974/web/
04-28
这是一个 Linux 命令，用于修改文件或目录的权限。其中，“chmod”是命令，“755”是权限设置，“-R”表示递归地修改目录下的所有文件和子目录，“/goosefs-lite-1.0.2”是要修改权限的文件或目录的路径。具体来说，755 权限表示文件所有者具有读、写、执行权限，同组用户和其他用户只有读和执行权限。这个命令的作用是将/goosefs-lite-1.0.2目录及其下的所有文件和子目录的权限设置为755。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值