Collection集合

1 、集合和数组的区别

长度区别

• 数组 : 长度固定

• 集合 : 长度可变

  存储数据类型

• 数组 : 可以存储基本数据类型, 也可以存储引用数据类型

• 集合 : 只能存储引用数据类型 , 要想存储基本数据类型 , 需要存储对应的包装类类型

  2、 集合的体系

  1、Collection集合常用的方法

• 在学习集合体系，一般先学习顶层接口。学习了顶层接口的方法，子类型继承而来的方法，就可以不用重复学习。

  • public boolean add(E e)： 把给定的对象添加到当前集合中 。
  • public void clear() :清空集合中所有的元素。
  • public boolean remove(E e): 把给定的对象在当前集合中删除。
  • public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
  • public boolean isEmpty(): 判断当前集合是否为空。
  • public int size(): 返回集合中元素的个数。

  • public Object[] toArray(): 把集合中的元素，存储到数组中

    3、 迭代器

    概述 :

  • 迭代器就是对Iterator的称呼 , 专门用来对Collection集合进行遍历使用的。学习迭代器的目的就是为了遍历集合

    注意 :

  • 只有继承/实现Iterable接口才具有迭代的能力

  • Collection接口继承了Iterable接口所以 , Collection及其子类都具备迭代的能力

    获取迭代器对象的方式

  • 通过Collection集合对象调用Iterable接口中的iterator方法 , 就可以获取迭代器对象

    Iterator(迭代器)中的方法

    | boolean | hasNext() | 如果迭代具有更多元素，则返回 true 。 | | —- | —- | —- | | E | next() | 返回迭代中的下一个元素。 | | default void | remove() | 从底层集合中删除此迭代器返回的最后一个元素（可选操作）。 |

迭代器的注意事项

• 当迭代器迭代元素完成后，不能继续next获取元素，否则会报：NoSuchElementException
• 当迭代器在使用的过程中，不能使用集合对象直接增删元素。会导致报错ConcurrentModificationException。如果要删除可以使用迭代器来删除

  5、 增强for循环

• 增强for循环（foreach），专门用来遍历集合或者数组，底层实现使用迭代器

• 定义格式 : for(元素的类型 变量名 : 数组/单列集合 ){ 变量代表的就是集合或者数组的元素}

  5、Collections单列集合工具类

• Collections工具类介绍

  • java.util.Collections 是集合的工具类，里面提供了静态方法来操作集合，乱序，排序….

    1 、shuffle方法

• public static void shuffle(List<?> list) 对集合中的元素进行打乱顺序。

• 集合中元素类型可以任意类型

  /*   Collections类 : 操作单列集合的工具类       public static void shuffle(List<?> list) 对集合中的元素进行打乱顺序       1 乱序只能对List集合进行乱序       2 集合中元素类型可以任意类型       需求 : 定义一个List集合，里面存储若干整数。对集合进行乱序 */public class ShuffleDemo {
        public static void main(String[] args) {
            ArrayList<Integer> list = new ArrayList<>();
            list.add(10);
            list.add(30);
            list.add(50);
            list.add(40);
            list.add(20);
            Collections.shuffle(list);
           System.out.println(list);// 打印集合中的元素  }}

2 、sort方法

• public static void sort (List list): 对集合中的元素自然排序

  • 该方法只能对List集合进行排序
  • 从方法中泛型分析可知，集合中元素类型必须是Comparable的子类型

    public class SortDemo1 {
           public static void main(String[] args) {
               ArrayList<Integer> list = new ArrayList<>();
               list.add(3);
               list.add(2);
               list.add(4);
               list.add(1);
               // 使用此方法 , 需要集合中存储的元素实现Comparable接口      
               Collections.sort(list);
               System.out.println(list);
           }
       }

• public static void sort (List list, Comparator<? super T> c)

  • 方法只能对List集合排序
  • 对元素的类型没有要求
  • 需要定义一个比较器Comparator （规则和之前TreeSet时一样）

  • 使用场景：

    • List集合中的元素类型不具备自然排序能力（元素类型没有实现结果 Comparable）

    • List集合中的元素类型具备自然排序能力，但是排序规则不是当前所需要的。 ```java /* Collections类 : 单列集合的工具类 sort方法是一个重载的方法，可以实现自然排序及比较器排序。 要特别注意的是sort方法只能对List集合进行排序，方法如下：

      public static void sort (List list) : 只能对集合中的元素自然排序

      需求1：定义一个List集合，存储若干整数，要求对集合进行降序排序 分析：整数类型Integer具备自然排序能力，但是题目要求降序排序

      需求2：定义一个学生类，属性有姓名，年龄。创建若干对象放到List集合中。要求对List集合中学生对象进行年龄的升序排序。 分析：自定义类型默认是没有自然排序能力的，我们使用自定义比较器方式排序。

*/ public class SortDemo2 { public static void main(String[] args) {

   /*
       需求2：定义一个学生类，属性有姓名，年龄。创建若干对象放到List集合中。要求对List集合中学生对象进行年龄的升序排序。
       分析：自定义类型默认是没有自然排序能力的，我们使用自定义比较器方式排序
   */
            ArrayList<Student> list = new ArrayList<>();
            list.add(new Student("lisi", 24));
            list.add(new Student("zhangsan", 23));
            Collections.sort(list, new Comparator<Student>() {
                @Override
                public int compare(Student o1, Student o2) {
                    return o1.getAge() - o2.getAge();
                }
            });
            System.out.println(list);
        }
        /*
            需求1：定义一个List集合，存储若干整数，要求对集合进行降序排序
            分析：整数类型Integer具备自然排序能力，但是题目要求降序排序
         */
        private static void method1() {
            ArrayList<Integer> list = new ArrayList<>();
            list.add(3);
            list.add(2);
            list.add(4);
            list.add(1);
            // 使用此方法 , 需要集合中存储的元素实现Comparable接口
            Collections.sort(list, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2 - o1;
                }
            });
            System.out.println(list);
        }
    }
}

```