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

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

news 2025/10/6 6:54:42

 一.单列集合体系结构

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

二.单列集合的通用方法

1.1基本数据类型的用法

package 集合;import java.util.ArrayList;
import java.util.Collection;public class demo1 {public static void main(String[] args) {// 1. 使用多态方式创建集合Collection<String> 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<Student> list = new ArrayList<Student>();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<String> list = new ArrayList<>();list.add("a");list.add("b");list.add("c");Iterator<String> it1 = list.iterator();while(it1.hasNext()){String s = it1.next();System.out.println(s);}Iterator<String> 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<String> 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<String> list = new ArrayList<>();list.add("a");list.add("b");list.add("c");list.forEach(new Consumer<String>() {@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<Integer> 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<Integer> 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<Integer> 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<Integer> 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<Integer> 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<list.size();i++){System.out.println(list.get(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<Integer> list = new ArrayList<>();list.add(3);list.add(2);list.add(1);ListIterator<Integer> 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<Student> set = new HashSet<Student>();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<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;}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<Student> set2 = new TreeSet<Student>();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<String> set = new TreeSet<>(new Comparator<String>() {@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<T> {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<E>{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<String> 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 <T> void printArray(T[] array) {for (T element : array) {System.out.print(element + " ");}System.out.println();}// 另一个泛型方法，有两个类型参数public static <T, U> 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.<Integer>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<String> {...@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<E> implements List<E> {...@Overridepublic boolean add(E e) {return false;}...
}

    list2<String> list3 = new list2<>();
list3.add("hello");
list3.add("world");
System.out.println(list3);

    4.通配符

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

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

    http://www.dtcms.com/a/445916.html

    相关文章：

  • 查看邮箱注册过的网站百度资源搜索引擎
  • 网站建设常用编程语言square wordpress
  • 动规：01背包
  • 返利APP的“订单追踪”技术难点：如何通过埋点+消息队列（RocketMQ）实时同步淘宝/京东订单状态？
  • Net开发工具最新Rider 2025使用
  • 基于华为openEuler部署Dillinger个人文本编辑器
  • wordpress 标签固定链接宁波seo网络推广外包报价
  • 网站建设数据库是什么百度一下京东
  • 【Leetcode hot 100】131.分割回文串
  • ARM - GCC - 建立自己的命令行编译环境
  • Nginx限流配置
  • 大岭山做网站九亭做网站公司
  • 微软宣布 Windows 11 v25H2 GA
  • Burp Suite模拟器抓包全攻略
  • 佛山营销型网站定制绿色企业网站源码
  • Qt 5.14.2+Mysql5.7 64位开发环境下无法连接数据库
  • 【Python】
  • [特殊字符]ui设计公司灵感备忘录 | 网格布局 UI 收集
  • Base UI：一款极简主义的「无样式」组件库
  • MySQL 运维知识点（十六）---- 读写分离
  • 网站建设生存期模型希音电商网站
  • 济南网站建设培训班永久免费网站建设
  • 高层次综合报告分析-vivado hls第四章
  • Go语言中的Zap日志库
  • Linux网络编程——UdpServer
  • Daily算法刷题【面试经典150题-3️⃣】
  • MybatisPlus和pagehelper分页冲突—关于jsqlparser、pagehelper、MybatisPlus三者的版本兼容问题
  • R 数组：深入解析与高效使用
  • 缩点学习笔记
  • Go基础：用Go语言操作MongoDB详解