java基础-12 : 单列集合(Collection) - 详解

 一.单列集合体系结构

  • List系列集合:添加的元素时有序,可重复,有索引
  • Set系列集合:添加的元素时无序,不重复,无索引

二.单列集合的通用方法

1.1基本数据类型的用法

package 集合;
import java.util.ArrayList;
import java.util.Collection;
public class demo1 {
    public static void main(String[] args) {
        // 1. 使用多态方式创建集合
        Collection list = new ArrayList<>();
        // 输出空列表：[]
        System.out.println(list);
        // 2.添加元素,添加成功返回true
        boolean result1 = list.add("1");
        boolean result2 = list.add("2");
        boolean result3 = list.add("3");
        System.out.println(result1); // true
        System.out.println(list);
        // 3.删除元素,删除成功返回true
        list.remove("2");
        System.out.println(list);
        // 4. 集合长度
        System.out.println(list.size()); // 2
        // 5. 集合是否为空
        System.out.println(list.isEmpty()); // false
        // 6. 集合是否包含某个元素
        System.out.println(list.contains("1")); // true
    }
}

1.2引用数据类型的用法

public static void main(String[] args) {
        ArrayList list = new ArrayList();
        Student s1 = new Student("张三", 12);
        Student s2 = new Student("李四", 13);
        Student s3 = new Student("王五", 14);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).getName() + "," + list.get(i).getAge());
        }
        for (int i = 0; i < 3; i++) {
            Student s = new Student();
            Scanner sc = new Scanner(System.in);
            System.out.println("输入学生姓名:");
            String name = sc.nextLine();
            System.out.println("输入学生年龄");
            int age = sc.nextInt();
            s.setName(name);
            s.setAge(age);
            list.add(s);
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).getName() + "," + list.get(i).getAge());
        }
    }

2.遍历集合

1.迭代器

先获取数据,再移动指针,遍历后指针不复位,既依然指向最后没有数据的位置,删除时只能使用迭代器的remove方法,不能使用集合的remove方法

package 集合;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;
public class demo1 {
    public static void main(String[] args) {
        Collection list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        Iterator it1 = list.iterator();
        while(it1.hasNext()){
            String s = it1.next();
            System.out.println(s);
        }
        Iterator it2 = list.iterator();
        while(it2.hasNext()){
            String s = it2.next();
            if("b".equals(s)){
                it2.remove();
            }
        }
        System.out.println(list);
    }
}
a
b
c
[a, c]

2.增强for

增强for: 内部原理是迭代器,只能遍历单列集合,数组,不能遍历Set双列集合

package 集合;
import java.util.ArrayList;
import java.util.Collection;
public class demo1 {
    public static void main(String[] args) {
        Collection list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        for (String s : list) {
            //s = "d";//不能修改集合中的元素
            System.out.println(s);
        }
    }
}
a
b
c

3.使用forEach+lambda

package 集合;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
public class demo1 {
    public static void main(String[] args) {
        Collection list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.forEach(new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        list.forEach((String s) -> System.out.println(s));
        //等同于:list.forEach(s -> System.out.println(s));
    }
}
a
b
c
a
b
c

三.集合list的特有方法

特性ArrayListLinkedList
底层数据结构动态数组双向链表
访问元素极快，通过索引直接访问，时间复杂度 O(1)慢，需要从头或尾遍历，时间复杂度 O(n)
插入/删除元素慢，需要移动后续元素，时间复杂度 O(n)快，只需修改指针，时间复杂度 O(1)
内存开销较小，只存储数据和数组容量较大，每个节点都需要存储数据和两个指针
适用场景频繁随机访问，多读少写频繁在头尾或中间插入/删除，少随机访问

ArrayList 和 LinkedList 都实现了 List<E> 接口。这意味着它们对外承诺了完全相同的一组方法。因此，从代码编写的角度来看，你可以用完全相同的方式去调用 add(int index, E element), remove(int index), set(int index, E element), get(int index) 这些方法，而不需要关心底层是数组还是链表.

有序可重复

  1. 有序: 元素有索引,可以根据索引操作元素
  2. 可重复: 集合中可以存储重复元素

1.void add(int index ,E element)

package 集合;
import java.util.ArrayList;
import java.util.List;
public class demo1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println(list);
        list.add(1,5);
        System.out.println(list);
    }
}
[3, 2, 1]
[3, 5, 2, 1]

2.remove(int index)/remove(Object O)

  • remove(int index): 删除指定索引处的元素,返回被删除的元素
  • remove(Object o): 删除指定元素,返回是否删除成功
package 集合;
import java.util.ArrayList;
import java.util.List;
public class demo1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println(list);
        list.remove(Integer.valueOf(2));
        System.out.println(list);
        list.remove(1);
        System.out.println(list);
    }
}
[3, 2, 1]
[3, 1]
[3]

    因为在调用方法时,如果出现了重载的现象,优先调用实参跟形参类型一致的方法(缺少了封箱这一步)

    3.set(int index,E element)

    package 集合;
import java.util.ArrayList;
import java.util.List;
public class demo1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println(list);
        list.set(0, 100);
        System.out.println(list);
    }
}
    [3, 2, 1]
[100, 2, 1]

    4.get(int index)

    package 集合;
import java.util.ArrayList;
import java.util.List;
public class demo1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println(list.get(1));
    }
}
    2

    5.列表遍历

    1.普通for循环与增强for循环

    因为list是有序的,所以可以使用索引

    package 集合;
import java.util.ArrayList;
import java.util.List;
public class demo1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(3);
        list.add(2);
        list.add(1);
        for (Integer i : list) {
            System.out.println(i);
        }
        System.out.println("-----------------");
        for(int i = 0;i
    3
2
1
-----------------
3
2
1

    2.列表迭代器

    package 集合;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class demo1 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(3);
        list.add(2);
        list.add(1);
        ListIterator listit = list.listIterator();
        while(listit.hasNext()){
            Integer i = listit.next();
            if(i == 2){
                listit.add(521);
            }
            System.out.println(i);
        }
        System.out.println(list);
    }
}
    3
2
1
[3, 2, 521, 1]

    对比总结

    特性维度迭代器遍历增强for循环普通for循环列表迭代器forEach遍历
    删除能力✅ 安全删除❌ 不支持⚠️ 需手动调整索引✅ 安全删除❌ 不支持
    添加能力❌ 不支持❌ 不支持⚠️ 需手动调整索引✅ 支持添加❌ 不支持
    修改能力❌ 不支持❌ 不支持✅ 直接修改✅ 支持修改❌ 不支持
    双向遍历❌ 单向❌ 单向⚠️ 可反向但复杂✅ 双向❌ 单向
    适用集合所有Collection数组+Iterable仅List仅List所有Iterable
    • 迭代器循环:在遍历过程中需要删除元素
    • 增强for循环:仅仅遍历
    • forEach:仅仅遍历
    • 普通for循环:需要对索引进行操作
    • 使用列表迭代器:在遍历过程中需要添加元素

    四.底层原理

    1.ArrayList

    1. 利用空参构造创建的集合,在底层创建一个默认长度为0的数组
    2. 在添加第一个元素时,底层会创建一个新的长度为10的数组
    3. 存满时,会扩容1.5倍
    4. 如果一次性添加多个元素,1.5倍放不下,则新创建的数组长度以实际为准

    2.LinkedList

    3.iterator

    五.集合Set

    特性HashSetTreeSet
    底层数据结构基于 HashMap (哈希表)基于 TreeMap (红黑树)
    元素顺序无序（不保证插入顺序或任何特定顺序）有序（按元素的自然顺序或自定义比较器排序）
    性能 (增、删、查)O(1) 平均时间复杂度O(log n) 平均时间复杂度
    元素要求必须正确实现 equals() 和 hashCode() 方法必须实现 Comparable 接口 或 提供 Comparator
    允许 null 元素允许一个 null 元素不允许（如果使用自然排序，因为 null 无法比较）
    线程安全非线程安全非线程安全

    1.HashSet

    赖 hashCode 和 equals：

    • 当添加元素时，HashSet 会调用元素的 hashCode() 方法来确定存储位置。

    • 如果两个元素的 hashCode 相同，它会再调用 equals() 方法来检查它们是否真的相等。

    • 如果两个对象通过 equals() 比较是相等的，那么它们的 hashCode() 必须返回相同的值。 否则，会导致重复元素被加入，破坏了 Set 的唯一性。

    在使用引用数据类型时,需要重写hashCode()和equals()方法
    String 与 integer 类型都重写了hashCode()和equals()方法

    import java.util.Objects;
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;
    }
    @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 && Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
    import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("张三", 18);
        Student s3 = new Student("李四", 19);
        Student s4 = new Student("王五", 20);
        Set set = new HashSet();
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        System.out.println(set);
    }
}
    [Student{name = 张三, age = 18}, Student{name = 王五, age = 20}, Student{name = 李四, age = 19}]

    2.TreeSet

    TreeSet 是基于红黑树（一种自平衡的二叉搜索树）实现的 Set，它保证了元素处于排序状态。

    元素必须可比较：

    • 自然排序：元素类必须实现 java.lang.Comparable 接口，并重写 compareTo 方法。

    • 定制排序：在创建 TreeSet 时，传入一个 Comparator 比较器对象。

    1.实现Comparable接口,并重写 compareTo方法

    package 集合;
import java.util.Objects;
public class Student implements Comparable {
    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;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
    @Override
    public int compareTo(Student o) {
//        this 表示当前要填加的元素, o 表示在红黑树存在的元素
        return this.age - o.age;
    }
}
    package 集合;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18);
        Student s2 = new Student("张三", 18);
        Student s3 = new Student("李四", 19);
        Student s4 = new Student("王五", 20);
        Set set2 = new TreeSet();
        set2.add(s1);
        set2.add(s2);
        set2.add(s3);
        set2.add(s4);
        System.out.println(set2);
    }
}
    [Student{name = 张三, age = 18}, Student{name = 李四, age = 19}, Student{name = 王五, age = 20}]

    2.使用比较器

    import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class test2 {
    public static void main(String[] args) {
//        使用比较器进行排序规则的指定
//        规则当长度相同时,按照字典序排序,长度不同时,按照长度排序
        Set set = new TreeSet<>(new Comparator() {
            @Override
            public int compare(String o1, String o2) {
//                o1 表示当前要填加的元素, o2 表示在红黑树存在的元素
                int i = o1.length() - o2.length();
                i = i==0? o1.compareTo(o2) : i;
                return i;
            }
        });
        set.add("a");
        set.add("bw");
        set.add("qwer");
        set.add("s");
        System.out.println(set);
    }
}
    [a, s, bw, qwer]

    六.泛型

    1.泛型类

    在集合中不限制子类类型时,会默认为Object类型,可以往集合中添加任意类型的数据,类似于多态形式,但是不可以调用子类的特性

    // 定义一个泛型类 Box
public class Box {
    private T content; // T 代表一个未知的类型
    public void setContent(T content) {
        this.content = content;
    }
    public T getContent() {
        return content; // 返回类型是 T，不需要强制转换
    }
}

    在创建类时,使用形参E进行表示,在创建实例对象时,才给出数据类型        

    import java.util.Arrays;
//1.泛型类
public class myArrayList{
    Object[] obj = new Object[10];
    int size = 0;
//    添加元素
    public boolean add(E e){
        obj[size] = e;
        size++;
        return true;
    }
    public E get(int index){
        return (E)obj[index];
    }
    //    重写toString方法
    @Override
    public String toString(){
        return Arrays.toString(obj);
    }
}
    import java.util.ArrayList;
public class demo1 {
    public static void main(String[] args) {
//        1.泛型类
        myArrayList list = new myArrayList<>();
        list.add("hello");
        list.add("world");
        System.out.println(list);
    [hello, world, null, null, null, null, null, null, null, null]

    2.泛型方法

    public class Utility {
    // 一个普通的泛型方法（在非泛型类中）
    public static  void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
    // 另一个泛型方法，有两个类型参数
    public static  void printPair(T first, U second) {
        System.out.println("First: " + first + ", Second: " + second);
    }
}
    public class Main {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        String[] strArray = {"A", "B", "C"};
        // 调用泛型方法。通常编译器可以推断出类型 T，无需显式指定
        Utility.printArray(intArray); // T 被推断为 Integer
        Utility.printArray(strArray); // T 被推断为 String
        // 显式指定类型（不常用，通常在类型推断失败时使用）
        Utility.printArray(intArray);
        Utility.printPair("Age", 25); // T 是 String, U 是 Integer
    }
}

    3.泛型接口

    1.实现类给出具体类型

    import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
//3.泛型接口
public class list implements List {
    ...
    @Override
    public boolean add(String s) {
        return false;
    }
    ...
}
    list list2 = new list();
list2.add("hello");
list2.add("world");
System.out.println(list2);

    2.实现类延续泛型,在创建实现类对象时再确定类型

    import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class list2 implements List {
    ...
    @Override
    public boolean add(E e) {
        return false;
    }
    ...
}
    list2 list3 = new list2<>();
list3.add("hello");
list3.add("world");
System.out.println(list3);

    4.通配符

    当方法中不确定使用什么类型的泛型时，使用通配符?

    • ? extends E 表示泛型类型是E的子类
    • ? super E 表示泛型类型是E的父类
    • ? 表示任意类型

    posted @ 2025-11-04 14:31  yangykaifa  阅读(4)  评论(0)    收藏  举报