当前位置： 首页 > news >正文

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

news 2026/3/27 4:35:15

 一.单列集合体系结构

  • 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.添加元素,添加成功返回trueboolean result1 = list.add("1");boolean result2 = list.add("2");boolean result3 = list.add("3");System.out.println(result1); // trueSystem.out.println(list);// 3.删除元素,删除成功返回truelist.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() {@Overridepublic 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;}@Overridepublic 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);}@Overridepublic 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 + "}";}@Overridepublic 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() {@Overridepublic 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方法@Overridepublic 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 被推断为 IntegerUtility.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 {...@Overridepublic 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 {...@Overridepublic 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的父类
    • ? 表示任意类型

    http://www.jsqmd.com/news/31185/

    相关文章：

  • 2025 年 11 月 ESB 集成平台，API 管理集成平台，集易云集成平台公司最新推荐，聚焦资质、案例、售后的五家机构深度解读！
  • 三场比赛（四）
  • mssql public权限sql注入
  • 2025 年 11 月 SAP 集成平台，EDI 集成平台，ERP 集成平台公司最新推荐，聚焦资质、案例、售后的五家机构深度解读！
  • Luogu P11361 [NOIP2024] 编辑字符串 题解
  • AI辅助编程下的软件分层设计：让生成的代码井然有序
  • 2025年钢管总成加工厂权威推荐榜单：液压钢管总成/硬管总成品牌/免焊接钢管总成源头厂家精选
  • 2025年变电站接地线定做厂家权威推荐榜单：便携型接地线/单簧卡口接地线/电厂专用接地线源头厂家精选
  • 关于Dify工作流的项目实现与思考
  • 2025年河北搬家渠道权威推荐榜单：河北单位搬迁/河北搬运小时工/河北大型设备搬运服务精选
  • 2025年顶尖候车亭/公交站台//电子站牌/公交站牌/公交候车厅厂家： 江苏兰太城市科技领跑
  • 华为高斯Gauss数据库版本与兼容协议--详解(附带Gorm连接示例代码) - 教程
  • 任务栏图标变空白
  • 2025年酒店剃须刀生产厂家权威推荐榜单：一次性剃须刀套装/女士刮毛刀/刮胡刀供应商精选
  • 打开word或PDF，在同目录下自动生成debug.log文件，文件大小0字节！最后发现竟然是一个时时刻刻都要用到的软件引起的
  • 2025年铸铁修正轮企业权威推荐榜单：丸片修正轮/金刚石丸片修正轮/镀砂修正轮源头厂家精选
  • 西南地区钢结构工程设计施工服务TOP5推荐：钢结构工程设计服务商哪个靠谱
  • 2025年防水卷材供应商权威推荐榜单：防水涂料/堵漏材料/外墙防水涂料源头厂家精选
  • 2025年不锈钢门定制工厂排名，不锈钢酒柜定制公司推荐
  • 1000UserGuide：独立开发者获取前1000个用户的终极指南
  • 2025年不锈钢家具定制工厂推荐：5家靠谱专业不锈钢机构全解析
  • 2025年重庆叛逆孩子强制管教学校排行榜推荐
  • 2025 年清污机源头厂家最新推荐榜单权威发布，聚焦耐腐蚀技术与智能清污实力，结合协会测评数据精选品牌回转式格栅/不锈钢清污机公司推荐公司推荐
  • CSP2025 题解
  • 都昌电子病历编辑器最新特性
  • C/C++跳动的爱心③ - 详解
  • 2025年五大靠谱劳动仲裁律师服务公司推荐
  • 2025年电梯装潢开槽机厂商权威推荐榜单：铝单板开槽机/幕墙开槽机/门业开槽机源头厂家精选
  • 【MySQL 从入门到精通：核心知识点与实战优化指南】 - 指南
  • 2025年东北地区电气自动化公司排名，东宇电气市场口碑与产品质量全解析