小白零基础快速入门Java —— 第十二课：集合框架之单列集合Collection

文章摘要：

小白零基础快速入门Java —— 第十二课：集合框架之单列集合Collection。本文介绍了以下内容：1、Collection体系概述。2、Collection的常用方法。3、Collection的遍历方式。4、List集合（Arraylist、LinkedList）。5、Set集合（HashSet、LinkedHashSet、TreeSet）。6、注意事项：集合的并发修改异样问题。7、Collections工具的使用

• 集合是一种容器，用来装数据的，类似于数组，但集合的大小可变，开发中也非常常用。
• 为了满足不同的业务场景需求，Java还提供了很多不同特点的集合给我们选择。
  
  

1、Collection体系概述

---

• 这里的有序和无序，说的不是升序和降序，而是说你从集合取出数据的排序和你将数据写入集合的顺序是不是一致。
  
  

2、Collection的常用方法

---

• boolean add(E e) : 添加元素，添加成功返回true
• void clear() : 清空集合的元素
• boolean isEmpty() ： 判断集合是否为空 是空返回true， 反之。
• int size() : 获取集合的大小
• boolean contains( Object obj) : 判断集合中是否包含某个元素
• boolean remove(E e) : 删除某个元素：如果有多个重复元素默认删除前面的第一个。
• Object [ ] toArray() : 把集合转成数组

Object[] arr = c.toArray(); //非指定类型数组
System.out.println(Arrays.toString(arr));
String[] arr2 = c.toArray(new String[c.size()]); // 指定类型的数组，这要保证集合中的数据都是String，否则会报错。

public class CollectionTest {
    public static void main(String[] args) {
        Collection<String> c1 = new ArrayList<>();
        Collection<String> c2 = new ArrayList<>();
        
        c1.add("java1");
        c1.add("java2");
        c2.add("java3");
        c2.add("java4");
        
        c1.addAll(c2); // 就是把才集合的全部数据倒入c1集合中去
    }
}

在这里插入图片描述

3、Collection的遍历方式

---

3.1 迭代器

3.1.1 迭代器概述

迭代器是用来遍历集合的专用方式（数组没有迭代器），在Java中迭代器的代表是Iterator

• Collection集合获取迭代器的方法
  • Iterator<E> iterator() //返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素。
• Iterator迭代器中的常用方法
  • boolean hasNext() // 询问当前位置是否有元素存在，存在返回true， 不存在返回false。
  • E next() // 获取当前位置的元素，并同时将迭代器对象指向下一个元素处。

public class CollectionTest {
    public static void main(String[] args) {
        Collection<String> c1 = new ArrayList<>();

        c1.add("java1");
        c1.add("java2");
        c1.add("java3");
        c1.add("java4");
        c1.add("java5");
        c1.add("java6");

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

运行结果：

3.2 增强for

3.3 lambda表达式

// default void forEach(Consumer<? super T> action)： 结合Lambda表达式遍历集合
        // 匿名类对象
        c1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        // Lambda 简化
        c1.forEach((String s) -> {
                System.out.println(s);
        });

        c1.forEach(s -> System.out.println(s));

        c1.forEach(System.out::println);

4、List集合

---

4.1 特点、特有方法

4.1.1 List集合的特有方法

List<String> list = new ArrayList<>(); // List是接口不能直接new， 要去new它的实现类。这是一行经典的多态模式的代码

4.2 遍历方式

4.3 ArrayList集合的底层原理

4.3.1 底层原理

ArrayList 的特点：查询快、增删慢

4.3.2 应用场景

1. ArrayList适合：根据索引查询数据，比如根据随机索引取数据（高效） 或者数据量不是很大时!
2. ArrayList不适合：数据量大的同时，又要频繁的进行增删操作 !

4.4 LinkedList集合的底层原理

基于双链表实现的。

LinkedList<String> queue = new LinkedList<>();
 LinkedList<String> stack = new LinkedList<>();
 stack.push("1"); //压栈
 stack.pop(); // 弹栈

5、Set 集合

---

5.1 Set 集合的特点

Set<Integer> set = new HashSet<>(); // 创建了一个HashSet的集合对象，一行经典代码，无序、不重复、无索引
Set<Integer> set = new LinkedHashSet<>(); // 有序、不重复、无索引
Set<Integer> set = new TreeSet<>(); // 可排序（默认升序）、不重复、无索引

5.2 HashSet 集合的底层原理

5.2.1 哈希值

5.2.2 二叉树

5.2.3 HashSet 集合的底层原理

• 如果数组快占满了，会出什么问题？ 该怎么办？
  • 问题： 链表会过长，导致查询性能降低
  • 解决方案： 扩容
    • 当 数组中元素的个数 = 数组长度 * 加载因子 时，数组就会扩容。
      
      

5.2.4 深入理解HashSet集合去重复的机制

• 去重复：是指去除内容一样的元素

• HashSet集合默认不能对内容一样的两个不同对象去重复！

• 比如内容一样的两个学生对象存入到HashSet集合中去，HashSet集合是不能去重复的！

• 如何让HashSet集合能够实现对内容一样的两个不容对象也能去重复？？？？
  

 //只要两个对象内容一样就返回true
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        set set = (set) o;
        return age == set.age && Objects.equals(name, set.name);
    }
    //只要两个对象内容一样，返回的哈希值就是一样的
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

5.3 LinkedHashSet集合

5.3.1 LinkedHashSet集合的底层原理

5.4 TreeSet集合

//方法一
public class Student implements Comparable<Student>{
    String name;
    int age;

    @Override
    public int compareTo(set o) {
        // 左 > 右 return 正数
        // 左 < 右 return 负数
        // 左 = 右 return 0
        // 要求： 按照年龄升序排序 return this.age - o.age
        //              降序    return o.age - this.age
        return this.age - o.age;
    }


//方法二
//TreeSet就近选择自己自带的比较器对象进行排序
Set<Student> students = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照身高升序排序
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        })
//简化
Set<Student> students = new TreeSet<>((Student o1, Student o2) -> Double.compare(o1.getHeight(), o2.getHeight()));

6、注意事项：集合的并发修改异常问题

---

7、Collection 的其他相关知识

---

7.1 前置知识：可变参数

注意事项：

• 一个形参列表中，只能有一个可变参数
• 可变参数必须放在形参列表的最后面

7.2 Collections

		List<String> c1 = new ArrayList<>();

        c1.add("java1");
        c1.add("java2");
        c1.add("java3");
        c1.add("java4");

        // 给集合批量添加元素
       Collections.addAll(c1, "java5", "java6", "Java7");

        // 打乱List集合中的元素顺序
        Collections.shuffle(c1);
        System.out.println(c1);

        // 对List集合中的元素进行升序排序
        Collections.sort(c1);
        System.out.println(c1);

        // 对List集合中元素，按照比较对象指定的规则进行排序
        Collections.sort(students, new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getage(), o2.getage());
            }
        });
        //简化
        Collections.sort((Student o1, Student o2) -> Double.compare(o1.getage(), o2.getage()));

7.3 综合案例