Collection和Map

最新推荐文章于 2024-05-25 15:56:40 发布

qingshui_913

最新推荐文章于 2024-05-25 15:56:40 发布

阅读量42

点赞数

分类专栏： Java笔记文章标签： java

本文链接：https://blog.csdn.net/m0_59809997/article/details/134491826

版权

Java笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Collection集合

单列集合的顶层接口 表示一组对象这些对象被称为Collection的元素
JDK不提供此接口的任何实现他提供更具体的子接口Set和List实现
创建Collection集合的对象可通过多态的方式创建

常见用法：

//多态创建ArrayList集合
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("Hello");
        c.add("world");
        c.add("java");

        //从集合中移除指定元素
        System.out.println(c.remove("world"));//true
        System.out.println(c.remove("javaee"));//false 不存在javaee

        //清空集合中所有元素
        //c.clear();

        //判断集合中是否存在指定元素
        System.out.println(c.contains("java"));//true
        System.out.println(c.contains("javaee"));//false

        //判断集合是否为空
        System.out.println(c.isEmpty());//false 即 不为空

        //集合长度
        System.out.println(c.size());

        System.out.println(c);

遍历方法

🐱‍👓Iterator 迭代器（集合专用遍历方式）

Iterator<String> it = c.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

//有一个学生类的情况
Iterator<Student> it = c.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }

🐱‍🚀Listlterator列表迭代器（List集合特有）

允许往任一方向遍历列表的列表迭代器在迭代期间修改列表并获取列表中迭代器的当前位置

 //创建集合对象
        List<String> list = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        //通过listIterator()方法得到
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }

        System.out.println("----------------------------");

        //逆向遍历
        while (lit.hasPrevious()){
            String s = lit.previous();
            System.out.println(s);
        }

        System.out.println("----------------------------");

        //获取列表迭代器
        ListIterator<String> lit2 = list.listIterator();
        while (lit2.hasNext()){
            String s = lit2.next();
            if(s.equals("world")){
                lit2.add("javaee");
            }
        }
        System.out.println(list);

🧑可在迭代期间修改列表
如果用普通迭代器，底层代码中有期望次数和实际次数（防止无限次迭代发生的策略）如果对值进行修改则会出现期望次数和实际次数不一样的情况会产生运行错误。
如果使用列表迭代器则无需考虑期望次数和实际次数的问题即可以实现在迭代期间修改列表

🐱‍👤增强for

简化数组和Collection集合的遍历
实现Iterable接口的类允许其对象成为增强for语句的目标
内部原理为迭代器

        //int数组迭代
        int[] arr = {1,2,3,4,5};
        for(int i : arr){
            System.out.println(i);
        }

        System.out.println("------------------");

        //String数组迭代
        String[] strArray = {"Hello", "World", "Java"};
        for(String s : strArray){
            System.out.println(s);
        }

        System.out.println("------------------");

        //List集合的迭代
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        for(String s : list){
            System.out.println(s);
        }

🐱‍💻普通for（有索引）

for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

Collections类

针对集合操作的工具类

常见用法：

List<Integer> list = new ArrayList<>();
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);

//升序排序
Collections.sort(list);

//反转
Collections.reverse(list);

//随机置换 即 元素位置随机，每次执行位置不同
Collections.shuffle(list);

System.out.println(list);

List

有序
可重复

🐮ArrayList

底层数据结构是数组查询快增删慢

常见用法：

        //多态创建集合对象
        List<String> list = new ArrayList<>();
        //创建集合对象
        //ArrayList<String> array = new ArrayList<>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("world");

        //索引不要越界
        //在此集合中的指定位置插入指定元素
        list.add(3,"javaee");
        //list.add(13,"javaee"); 索引越界
        

        //删除指定索引处的元素，返回被删除的元素
        System.out.println(list.remove(1));//输出被删除元素

        //修改指定索引处元素 返回被修改元素
        System.out.println(list.set(1,"JAVA"));//输出被删除的元素

        //返回指定索引处的元素
        System.out.println(list.get(1));

        //迭代器遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

        System.out.println("-------");

        //for遍历
        for(int i = 0; i < list.size(); i++){
            String s = list.get(i);
            System.out.println(s);
        }

        System.out.println("--------");

        //增强for
        for(String s : list){
            System.out.println(s);
        }

🐴LinkedList

底层数据结构是链表查询慢增删快

常见用法：

        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Hello");
        linkedList.add("World");
        linkedList.add("Java");

        linkedList.addFirst("javase");//在该列表开头插入指定元素
        linkedList.addLast("javaee");//在该列表结尾插入指定元素

        System.out.println(linkedList.getFirst());//返回列表中第一个元素
        System.out.println(linkedList.getLast());//返回列表中最后一个元素

        System.out.println(linkedList.removeFirst());//从列表中删除并返回第一个元素
        System.out.println(linkedList.removeLast());//从列表中删除并返回最后一个元素

        //迭代器
        Iterator<String> itLink = linkedList.iterator();
        while (itLink.hasNext()){
            String s = itLink.next();
            System.out.println(s);
        }

Set

不包含重复元素
没有带索引的方法不能使用普通for遍历

🐶HashSet

对集合的迭代顺序不做保证
底层数据结构是哈希表
没有带索引方法不能使用普通for遍历
由于是Set集合不包含重复元素

常见用法：

        //多态创建集合对象
        Set<String> set = new HashSet<>();

        //添加元素
        set.add("Hello");
        set.add("World");
        set.add("Java");
        set.add("World");//不包含重复元素

        //遍历
        //增强for
        for(String s : set){
            System.out.println(s);
        }

        System.out.println("------");

        //迭代器
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }

哈希值

JDK根据对象的地址或字符串或数字计算出的 int 类型的数值
同一个对象多次调用hashCode相同
默认情况下，不同对象调用hashCode不同
通过方法重写可以实现不同对象相同哈希值

对于中文字符串重写了哈希值

//有外部学生类
        Student s1 = new Student("小黑", 25);
        //获取哈希值
        //同一个对象多次调用hashCode相同
        System.out.println(s1.hashCode());//1163157884
        System.out.println(s1.hashCode());//1163157884

        System.out.println("--------");

        Student s2 = new Student("小黑", 25);

        //默认情况下，不同对象调用hashCode不同
        //通过方法重写 可以实现不同对象相同哈希值
        System.out.println(s2.hashCode());//1956725890

        System.out.println("Hello".hashCode());//69609650
        System.out.println("World".hashCode());//83766130
        System.out.println("Java".hashCode());//2301506

        //对于中文字符串重写了哈希值 为相同哈希值
        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395

🐺LinkedHashSet

由哈希表和链表实现的Set接口，具有可预测的迭代顺序
由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

由哈希表保证元素唯一即没有重复元素

        LinkedHashSet<String> lhs = new LinkedHashSet<>();
        lhs.add("Hello");
        lhs.add("World");
        lhs.add("Java");
        lhs.add("World");//没有重复元素

        for(String s : lhs){
            System.out.println(s);
        }

🐷TreeSet

元素有序
- TreeSet():根据自然排序
  - TreeSet(Comparator comparator):根据指定比较器进行排序
没有带索引的方法不能使用普通for

由于是Set集合不包含重复元素集合

        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(10);
        ts.add(40);
        ts.add(50);
        ts.add(20);
        //ts.add(50);不包含重复元素

        for(Integer i : ts){
            System.out.println(i);//自然排序
        }

Comparable自然排序

重写方法注意排序规则必须按照要求的主要条件和次要条件来写

类需要先 implements Comparable<>即实现类

public class Student implements Comparable<Student> {//实现类
    //学生类
    
    @Override//重写
    public int compareTo(Student s) {
        //return 0;   不添加
        //return 1;   升序
        //return -1;  降序

        //按照年龄从大到小排序
        //int num = this.age - s.age;//年龄升序 age > 1
        int num = s.age - this.age;//年龄降序 age < 1
        //次要条件排序 当年龄相同时按姓名字母排序
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}

//存储学生对象并遍历 创建TreeSet集合使用 无参构造方法 自然排序        
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();

        //创建学生对象
        Student s1 = new Student();
        s1.setName("xishi");
        s1.setAge(22);
        Student s2 = new Student("wangzhaojun", 23);
        Student s3 = new Student("diaochan", 24);
        Student s4 = new Student("yangyuhuan", 25);
        Student s5 = new Student("sudaji", 24);

        //学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        //增强for
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }

输出：
yangyuhuan,25
diaochan,24
sudaji,24
wangzhaojun,23
xishi,22

Comparator比较器排序

注意排序规则必须按照要求的主要条件和次要条件来写

//存储学生对象并遍历 创建TreeSet集合使用 带参构造方法 比较器排序
//有外部学生类
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {//比较器
            @Override//重写
            public int compare(Student s1, Student s2) {
                //this.age-----s1
                //s.age-----s2
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });

        //创建学生对象
        Student s1 = new Student();
        s1.setName("xishi");
        s1.setAge(22);
        Student s2 = new Student("wangzhaojun", 23);
        Student s3 = new Student("diaochan", 24);
        Student s4 = new Student("yangyuhuan", 25);
        Student s5 = new Student("sudaji", 24);

        //学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);

        //增强for
        for (Student s : ts) {
            System.out.println(s.getName() + "," + s.getAge());
        }

输出：
xishi,22
wangzhaojun,23
diaochan,24
sudaji,24
yangyuhuan,25

Map集合

存储键/值对
键key唯一，一个键最多能绑定一个值
指定的值与该映射中的指定键相关联
null可以作为键，这样的键只有一个
键和值都可以为类或为基本数据类型

🐱HashMap

键无序排列
覆盖了equals（）方法和hashcode（）方法，使得HashMap中两个相等的映射返回相同的哈希值

Map操作功能：

        //创建集合对象
        Map<String, String> map = new HashMap<>();

        //添加元素
        map.put("佩奇", "乔治");
        map.put("加菲猫", "欧迪");
        map.put("喜羊羊", "灰太狼");

        //根据键删除键值对元素
        System.out.println(map.remove("佩奇"));//删除键值对 返回 值
        System.out.println(map.remove("其他"));//返回null

        //移除所有键值对元素
        //map.clear();

        //判断集合是否包含指定的键
        System.out.println(map.containsKey("加菲猫"));//返回true或false
        System.out.println(map.containsKey("其他"));

        //判断集合是否包含指定的值
        System.out.println(map.containsValue("灰太狼"));//返回true或false
        System.out.println(map.containsValue("其他"));

        //判断集合是否为空
        System.out.println(map.isEmpty());//返回true或false  false即不为空

        //返回集合长度
        System.out.println(map.size());

        System.out.println(map);

Map集合获取功能：

        Map<String, String> map = new HashMap<>();
        map.put("佩奇", "乔治");
        map.put("加菲猫", "欧迪");
        map.put("喜羊羊", "灰太狼");

        //根据键获取值
        System.out.println(map.get("佩奇"));//乔治
        System.out.println(map.get("其他"));//null

        //获取所有键的集合
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            System.out.println(key);
        }

        //获取所有值的集合
        Collection<String> values = map.values();
        for(String value : values){
            System.out.println(value);
        }

Map集合遍历方法1：

        Map<String, String> maphm = new HashMap<>();
        map.put("佩奇", "乔治");
        map.put("加菲猫", "欧迪");
        map.put("喜羊羊", "灰太狼");

        //获取所有键的集合
        Set<String> keySet = maphm.keySet();

        //遍历键的集合 获取到每一个键
        for (String key : keySet) {
            String value = maphm.get(key);//根据键去找值
            System.out.println(key + "," + value);
        }

Map集合遍历方法2：

        Map<String, String> hm = new HashMap<>();
        map.put("佩奇", "乔治");
        map.put("加菲猫", "欧迪");
        map.put("喜羊羊", "灰太狼");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = hm.entrySet();

        //遍历键值对对象的集合 得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }

🦊TreeMap

键有序排列
实现了SortedMap接口，使其有序

注

Student类

- - 代码案例中的外部Student类

public 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;
    }
}

qingshui_913

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Collection和Map

如果用普通迭代器，底层代码中有期望次数和实际次数（防止无限次迭代发生的策略）如果对值进行修改则会出现期望次数和实际次数不一样的情况会产生运行错误。覆盖了equals（）方法和hashcode（）方法，使得HashMap中两个相等的映射返回相同的哈希值。JDK根据对象的地址或字符串或数字计算出的 int 类型的数值。由链表保证元素有序，也就是说元素的存储和取出顺序是一致的。由哈希表和链表实现的Set接口，具有可预测的迭代顺序。JDK不提供此接口的任何实现他提供更具体的。
复制链接

扫一扫