java day13 Set集合 & Map集合 & Stream流

moskidi

已于 2024-11-21 20:52:26 修改

阅读量2.1k

点赞数 40

分类专栏： JavaSE 文章标签： java 开发语言

于 2024-11-13 22:14:28 首次发布

本文链接：https://blog.youkuaiyun.com/moskidi/article/details/143729090

版权

JavaSE 专栏收录该内容

17 篇文章

订阅专栏

3.LinkedHashSet集合的底层原理：

3.流的终结方法（返回值不是Stream的方法）：

（1）.获取值：

（2）.获取集合或数组：

1.Set集合：

1.Set集合的特点：

Set和List 都为单列集合

2.HashSet的底层原理：

无序不重复无索引

重写equals和hashcode是为了在 HashSet和LinkedHashSet中能去重

HashSet的存储原理：

如果：

扩容到原来的2倍

链表转换成红黑树的条件：

3.LinkedHashSet集合的底层原理：

总结：哈希表 + 双向链表

有序（存取有序）就是通过双向链表实现的

4.TreeSet集合：

TreeSet 提供比较规则：

注意：TreeSet的去重逻辑为比较器中返回0则证明两元素相同则去除

1.使用TreeSet（Comprator c）构造方法创建集合指定比较规则传入一个Comprator接口的实现

类对象因为只用一次所以可以用匿名内部类并且这个接口时函数式接口所以可以用lambda表达式来简化

2. 让自定义类实现Comparable接口重写 compare To 方法

注意如果1，2同时存在时1优先执行

方式1：

public static void main(String[] args) {
        //TreeSet: 排序,不可重复, 不支持索引
        //对于Integer,Double这样的数值,默认都是从小到大排序

        //Set<Integer> is = new TreeSet<>();
        //如果我要从大到小排序呢? 使用重载的构造方法 TreeSet(Comparator c),指定比较规则
        /*
            @FunctionalInterface
                public interface Comparator<T>{
                    //比完的结果  >0 o1>o2   <0: o1<o2  =0  重复
                    int compare(T o1, T o2);
                }
         */
        Set<Integer> is = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });

        is.add(10);
        is.add(2);
        is.add(5);
        is.add(5);
        is.add(8);

        System.out.println(is);
    }

方式2：

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    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 int compareTo(Student o) {
        return this.age-o.getAge();
    }
}

public static void main(String[] args) {
        TreeSet默认要对元素排序
        TreeSet去除重复的规则: 比较的方法如果返回0,证明该元素已经存在,则不存储
        /*Set<Student> stus = new TreeSet<>((s1,s2)->{
            return s2.getAge()-s1.getAge();
        });*/
        ClassCastException: 类型转换异常, 无法将Student转换为Comparable
        
            如果TreeSet要存储自定义的对象,并且不想给他传递比较器,
            自定义的类必须实现Comparable接口,重写compareTo方法,用于提供默认的比较规则
         
        Set<Student> stus = new TreeSet<>();

        //想让TreeSet存储元素自定义的对象, 不需要传递比较器,也可以
        stus.add(new Student("张三",23));
        stus.add(new Student("李四",27));
        stus.add(new Student("王五",25));
        stus.add(new Student("赵六",26));
        stus.add(new Student("张三",23));

        System.out.println(stus);
    }

2.Map集合：

1.Map集合概述：

双列集合

Map类集合和Set类集合的底层实现原理相同所以特点相同

2.Map集合的常用方法：

注意单列集合的添加方式为add（Collection）双列集合Map为put

注意：put方法返回值如果key重复返回被覆盖元素的值如果key没有重复返回null

public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        添加
        map.put("杨过","小龙女");
        map.put("尹志平","小龙女");
        map.put("耶律齐","郭芙");

        clear()清空集合
        //map.clear();

        size():获取元素个数
        System.out.println(map.size());

        isEmpty(): 判断集合是否为空
        System.out.println(map.isEmpty());

        get(key): 根据键获取值
        System.out.println(map.get("杨过"));

        remove(key): 根据键删除键值对
        map.remove("尹志平");

        containsKey(key):判断当前集合中有没有指定的键
        System.out.println(map.containsKey("杨过"));

        containsValue(value): 判断当前集合中有没有指定的值
        System.out.println(map.containsValue("小龙女"));

        Set keySet(): 获取所有的键,并且放到一个Set集合中返回
        Set<String> keys = map.keySet();
        System.out.println(keys);

        Collection values(): 获取所有的值, 并且放到一个Collection集合中返回
        Collection<String> values = map.values();
        System.out.println(values);
        System.out.println(map);


    }

3.Map集合的遍历方式：

 Map<String,String> map = new HashMap<>();

        map.put("001","张三");
        map.put("002","李四");
        map.put("003","王五");
        map.put("004","赵六");

        //1. 遍历集合  键找值
        Set<String> keys = map.keySet();
        for (String key : keys) {
            //key键,value值
            String value = map.get(key);
            System.out.println(key+"----->"+value);
        }

方式2：

entries为一个set单列集合集合中的元素都为实现了Map.Entry这个接口中的接口的实现类对象

这个实现类对象中重写了两个Entry的抽象方法 getKey 和 getValue 并却每一个对象都存储了map对象的一对键值

 //2.键值对遍历方式  Set entrySet():用于获取所有键值对对象的集合  Map.Entry对应的对象中,都封装了一个键,一个值
        Set<Map.Entry<String, String>> es = map.entrySet();
        for (Map.Entry<String, String> e : es) {
            //getKey():用于获取键,  getValue()用于获取值
            String key = e.getKey();
            String value = e.getValue();
            System.out.println(key+"----->"+value);
        }

第三种方法：

//3.forEach()遍历, 底层依然是增强for
        /*
            大消费者接口:
            public interface BiConsumer<T, U> {
                 //方法是消费的方法, 参数就是用于消费的数据
                 void accept(T t, U u);
            }
         */
        map.forEach(new BiConsumer<String, String>() {
            //底层增强for遍历的时候,每次循环,都会调用一次accept方法, 把当前键值对对象的键和值作为参数传递进来
            @Override
            public void accept(String key, String value) {
                System.out.println(key+"----->"+value);
            }
        });

        System.out.println("=======");
        map.forEach((key,value)->{
            System.out.println(key+"----->"+value);
        });

4.Map集合的实现类：

3.Stream流：

1.获取流的方法：

获取Stream流对象 1.集合stream() 方法 2. 数组调用Arrays.stream(数组)静态方法散装数据 Stream.of(可变参数)

可变参数：格式：数据类型... 变量名

特点：传递任意多个参数都可以

本质：数组

public class Test {

    public static void main(String[] args) {
        //集合的流对象获取  stream()
        List<String> list = new ArrayList<>();
        Stream<String> s1 = list.stream();
        System.out.println(s1);

        //数组的流对象获取  Arrays.stream(数组)
        String[] names = {"a", "b", "c"};
        Stream<String> s2 = Arrays.stream(names);
        System.out.println(s2);

        //散装的数据  Stream.of(多个数据)
        Stream<String> s3 = Stream.of("a", "b", "c", "d", "e");
        System.out.println(s3);

        //调用含有可变参数的方法
        show("1","2","3");
        String[] aa = {"a","b","c"};
        show(aa);
    }

    //...叫可变参数, 数量可以变化, 你传递0个,1个,2个...
    //可变参数本质上就是个数组
    public static void show(String... names) {
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
    }
}

2.流的中间方法：

public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(6);
        nums.add(3);
        nums.add(3);
        nums.add(9);
        nums.add(1);

        //sorted(): 排序
        nums.stream().sorted().forEach(s-> System.out.println(s));

        //sorted(Comparator c): 排序指定比较规则
        nums.stream().sorted((i1,i2)-> i2-i1).forEach(s-> System.out.println(s));

        //limit(n): 限制获取前n个元素
        nums.stream().limit(2).forEach(System.out::println);

        //skip(n) : 跳过前n个元素, 使用后面的元素
        nums.stream().skip(2).forEach(System.out::println);

        //distinct() : 用于去重
        nums.stream().distinct().forEach(System.out::println);

        //map(): 完成转换, 把A类型的数据转换成B类型的数据返回
        /*
            JDK提供的用于完成数据类型转换的接口
            @FunctionalInterface
            public interface Function<T, R> {
                //把T类型的数据转换成R类型的数据返回
                R apply(T t);
            }
         */
        //需求: 数据源 中的整数 转换成字符串  6b, 3b
        /*nums.stream().map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return integer+"b";
            }
        }).forEach(System.out::println);*/
        //nums.stream().map((i)->{return i+"b";}).forEach(System.out::println);
        //nums.stream().map(i -> i + "b").forEach(System.out::println);


        //Static Stream concat(Stream s1, Stream s2): 合并两个流到一个流中
        Stream<Integer> s1 = Stream.of(1, 2, 3);
        Stream<Integer> s2 = Stream.of(4, 5, 6);

        Stream.concat(s1,s2).forEach(System.out::println);

    }