Collection集合(40)

集合

1. 集合概念：

   • 集合是Java中提供的一种容器，可以用来存储多个数据 。
   • 数组的长度是固定的。集合的长度是可变的 。
   • 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

2. 集合框架：

   • 集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map。
   • java.util.Collection特点：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。其中，List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，Set接口的
     主要实现类有java.util.HashSet和java.util.TreeSet。
   • java.util.Map特点：中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

   

   

3. Collection常用方法：

   • add(Object element); 向集合中添加元素

   • size(); 获取集合中的个数

   • boolean isEmpty(); 判断集合中是否有元素

   • clear(); 清空集合

   • toArray(); 将集合转换成数组

   • Iterator iterator(); 获取集合所依赖的迭代器对象

   • boolean contains(Object o); 判断集合中是否包含某个元素

   • boolean remove(Object o); 删除集合中某个元素

   • 示例代码01：

               // * add(Object element); 向集合中添加元素
             // * size(); 获取集合中的个数
             // * boolean isEmpty(); 判断集合中是否有元素
             // * clear(); 清空集合
             // * toArray(); 将集合转换成数组
             // 1.创建一个集合
             Collection c1 = new ArrayList(); // --> 多态
     
             // 2.添加元素
             c1.add(new Animal("JACK",12,2021));
             c1.add(10); // 其中10使用了JDK5.0中的自动装箱，将10转换成了Integer引用类型
             // Integer i = new Integer(10); // 以上等同于这条语句
             Object o = new Object();
             c1.add(o);
     
             //3.获取集合中的元素
             System.out.println("c1集合中的元素个数为："+c1.size());
             // 判断集合中是否有元素
             System.out.println(c1.isEmpty());   // --》 false
     
     
             //4.将集合转换为数组
             Object[] objs = c1.toArray();
             for (int i = 0; i < objs.length; i++) {
                 System.out.println(objs[i]);
             }
             //5.清空集合
             c1.clear();
             System.out.println(c1.isEmpty());   // --》 true
     

   • 示例代码02：

               // Iterator iterator(); 获取集合所依赖的迭代器对象
             // 创建ArrayList集合
             Collection c1 = new ArrayList();
             // 添加对象
             c1.add("String");   // 自动装箱
             c1.add(2021);       // 自动装箱
             c1.add(true);       // 自动装箱
             // 创建迭代器
             Iterator i1 = c1.iterator(); // 多态--夫类型接口引用子类型(迭代器)对象
             /*
              * 迭代/遍历
              * 1.不需要关系底层调用的是哪个迭代器，当前集合创建的集合是什么集合底层调取相应的迭代器
              * 2.迭代器是面向接口的编程
              * 3.例：ArrayList集合所依赖的迭代器是是java.util.ArrayList$Itr
              *   例：LinkedList集合所依赖的迭代器是java.util.LinkedList$ListItr
              */
             // while遍历
             System.out.println("while遍历");
             while (i1.hasNext()){
                 Object o = i1.next();
                 System.out.println(o);  // 自动拆箱
             }
             // for遍历
             System.out.println("for遍历");
             for (Iterator i2 = c1.iterator(); i2.hasNext();) {
                 Object o2 = i2.next();
                 System.out.println(o2);
             }
     

   • 示例代码03：

             // boolean contains(Object o); 判断集合中是否包含某个元素
             // 创建ArrayList集合
             Collection c1 = new ArrayList();
             // 添加元素
             c1.add(10);
             Integer i1 = new Integer(10);
             // contains()比较
             System.out.println(c1.contains(i1)); // --> true
             /**
              * 以上方法为什么返回true?
              * 答：contains()方法的内部是使用的Integer的equals()，而Integer类重写了Object中的equals()
              * 方法，所以最后比较的是i1与集合c1中的value值，所以返回true
              */
     
             // Student使用contains()比较：
             Student s1 = new Student("JACK",20,20212000,"男");
             // 添加元素
             c1.add(s1);
     
             Student s2 = new Student("JACK",20,20212000,"男");
             // System.out.println(c1.contains(s2)); // --> false
             System.out.println(c1.contains(s2)); // --> 重写后true
             /**
              * 以上方法为什么返回true?
              * 答：contains()方法的内部是使用的Object中的equals()，而Object类中的equals()方法默认比较的是引用地址是否相同
              * 所以返回false，但是与实际业务逻辑冲突所以在Student中重写equals()方法.
              */
     class Student{
         private String name;
         private int age;
         private int id;
         private String sex;
     
         public Student(String name, int age, int id, String sex) {
             this.name = name;
             this.age = age;
             this.id = id;
             this.sex = sex;
         }
     
         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 int getId() {
             return id;
         }
     
         public void setId(int id) {
             this.id = id;
         }
     
         public String getSex() {
             return sex;
         }
     
         public void setSex(String sex) {
             this.sex = sex;
         }
     
         // 重写equals()方法
         @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 && id == student.id && Objects.equals(name, student.name) && Objects.equals(sex, student.sex);
         }
     }
     

   • 示例代码03：

     /**
      * boolean remove(Object o); 删除集合中某个元素
      * 注意：
      * remove和contains方法都需要集合中的元素重写equals方法
      * 因为Object中的equals方法比较内存地址，在现实的业务逻辑当中不能比较内存地址，应该比较内容
      */
             // 创建集合
             Collection c1 = new ArrayList();
             // 添加元素
             c1.add(10);
             Integer i1 = new Integer(10);
             c1.remove(i1);
             System.out.println(c1.size()); // ---> 0
             Student s1 = new Student("Javk",12,2020,"女");
             c1.add(s1);
             Student s2 = new Student("Javk",12,2020,"女");
             c1.remove(s2);
             System.out.println(c1.size()); // ---> 0
     
             // 深入remove方法
             /**
              * 问：迭代器中的remove方法与集合中自带的remove方法有什么不同？
              */
             c1.add(1);
             c1.add(2);
             c1.add(3);
             c1.add(4);
             // 创建迭代器
             Iterator a1 = c1.iterator();
             // 使用迭代器中的remove方法删除
             /*while (a1.hasNext()) {  // next()如果迭代具有更多元素，则返回 true
                 a1.next();  // 游标下移
                 a1.remove();// 删除当前元素
             }*/
             System.out.println(c1.size()); // --》 0
             // 使用集合中的remove方法删除
             while (a1.hasNext()) {
                 Object o = a1.next();
                 c1.remove(o);   // 使用集合中的remove方法删除元素
             }
             System.out.println(c1.size()); // --》 Error: ConcurrentModificationException
             /**
              * 报错原因：迭代器中remove中的方法与集合中remove方法区别：
              * 1.如果需要批量删除集合中的元素的话，调用集合中的remove方法删除了集合中的元素，但是循环是使用的未删除之前的
              * 集合元素，这样会使迭代器中记录集合元素不是最新的.所以每删除一个都需要重新定义迭代器，从而保证迭代器中的元素
              * 与集合元素相同.所以这种方法不能用
              * 2.迭代器中的remove方法可以实时记录当前集合删除多少元素从而实时更新游标，这种方式值得推荐
              */
     

4. s