首页 > 其他分享 >Collection单列集合总结

Collection单列集合总结

时间：2023-03-19 22:12:25浏览次数：39  
标签：迭代 List 单列 元素 list Collection 哈希 集合

这篇文章记录了Collection集合，List集合，Set集合

在文章第七点总结了两大系列集合的五种实现类的区别，有需要的小伙伴可以直接去查看

一、什么是集合

集合是Java中存储对象数据的一种容器

二、集合有什么特点

  1. 大小不固定，类型也可以不固定（通常需要泛型约束）
  2. 集合只能存储引用数据类型
  3. 集合适合对容器中的元素进行增删操作

三、体系结构

Collection单列集合，每个元素（数据）只包含一个值。

Map双列集合，每个元素包含两个值（键值对）。

四、Collection

1. 什么是Collection

官方的解释：

  • Collection是集合层次结构中的根接口。 集合表示一组对象，称为其元素 。 有些集合允许重复元素而其他集合则不允许。 有些是有序的，有些是无序的。
  • JDK不提供此接口（Collection）的任何直接实现：它提供了更具体的子接口的实现，如 Set 和 List
  • 此接口通常用于传递集合并在需要最大通用性的情况下对其进行操作。

说的通俗一点就是：

  • Collection是根接口，所有集合都来自Collection
  • jdk不提供该接口实现类对象，但提供了更具体的实现类
  • 就好比父类和子类，你可以用父类对象接收一个子类的实例化对象

   例如：Father f = new Sun(); // Sun类继承了Father类

2. Collection的体系结构

3. 常用方法

方法名称

说明

public boolean add(E e)

把给定的对象添加到当前集合中

public void clear()

清空集合中所有的元素

public boolean remove(Object o)

把给定的对象在当前集合中出现的第一个位置删除，如果删除失败返回false

public boolean contains(Object obj)

判断当前集合中是否包含给定的对象

public boolean isEmpty()

判断当前集合是否为空

public int size()

返回集合中元素的个数。

public Object[] toArray()

把集合中的元素，存储到数组中

4. 集合的遍历方式

4.1 迭代器

Iterator是集合专用的迭代方法，只能集合调用

Iterator中常用方法

  • next()：返回迭代中的下一个元素
  • hasNext()：如果迭代具有更多元素，则返回true
Collection<Integer> list = new ArrayList<>();
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
    Integer next = iterator.next();
    System.out.println(next);
}

注意事项：

  1. 迭代器只能使用一次
  2. next()移动指针到下一个元素，如果没有抛异常
  3. hasNext()检查下一个元素是否为空，但不移动指针
  4. 迭代器迭代元素越界出现：NoSuchElementException

4.2 普通for

只适用于List系列集合，因为他有序

通过调用集合的get方法，根据索引取值

4.3 增强for

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(2);
//增强for
for (int i : list) {
    if (i == 3) {
        i = 5;//增强for中如果对取出的这个元素修改，将不会对集合产生影响
    }
    System.out.println(i);
}

4.4 Lambda迭代

// 使用lambda表达式集合的迭代 
colStr.forEach(new Consumer() { 
    @Override public void accept(String s) { 
        System.out.println(s); 
    } 
}); 
// 简化写法 
System.out.println("-------------------------"); 
colStr.forEach(s-> System.out.println(s)); 
System.out.println("-------------------------"); 
// 再次简化 
colStr.forEach(System.out::println);

五、List

Collection的子接口

1. 特点

有序，有索引（是独有的），可重复，可存储null值，此实现不同步，线程不安全

存储和取出顺序一致

2. 特有方法

方法名称

说明

注意

void add(int index, E element)

将给定的元素插入到指定位置

索引不能越界，否则报错

 

E get(int index)

返回该索引位置的元素，没找到返回-1

E set(int index, E element)

对给定位置的元素进行替换

E remove(int index)

删除指定位置的元素

int lastIndexOf(Object o)

返回特定元素在集合中最后一次出现的位置

没找到返回-1

int indexOf(Object o)

返回特定元素在集合中第一次出现的位置

ListIterator<E> listIterator()

List集合特有的迭代器

 

List<E> subList(int fromIndex, int toIndex)

根据开始索引和结束索引（左闭右开）返回一个新的集合，该集合是原集合的子集

 

ListIterator叫做列表迭代器，将在第3.2解释

3. 迭代方式

和Collection一样的：迭代器、增强for、Lambda表达式

List独有的：listIterator、普通for（因为有索引）

3.1 并发修改异常

迭代器在迭代集合，但是集合本身被修改，换而言之：就是在同一时刻只能有一个对象来操作集合，否则就会出现并发修改异常

下面两种情况会出现并发修改异常

  1. 迭代器和集合方法都会对集合进行操作

List<String> list = new ArrayList<>();
list.add("java");
list.add("css");
list.add("python");

while(stringListIterator.hasNext()){ 
    String ele = stringListIterator.next(); 
    if("css".equals(ele)){ 
        stringListIterator.remove();//允许 
        //list.remove("css");// 不允许 出现 ConcurrentModificationException 
    } 
    System.out.println(ele); 
}

  2. 增强for本身也是一个Iterator迭代器，同样不能使用

List<String> list = new ArrayList<>();
list.add("java");
list.add("css");
list.add("python");

for (String s : list) {
    if("css".equals(s)){
        list.remove("css");//不允许，并发修改异常
    }
    System.out.println(s);
}

不会出现并发修改异常

List<String> list = new ArrayList<>();
list.add("java");
list.add("css");
list.add("python");

for (int i= 0; i < list.size();i++){ 
    String ele = list.get(i); 
    if("css".equals(ele)){ 
        list.remove("css");// 允许 
    } 
} 
System.out.println(list);

并发修改异常总结

  1. 同一时间只能有一个对象操作集合
  2. 使用迭代器要保证集合不在改变
  3. 出现异常的原因：
    1. 迭代器在进行遍历过程中，如果对数组进行操作，会导致迭代器的实际修改值和集合的预期修改值不对应，就会出异常
    2. 迭代器是一次性的，如果对集合进行操作，没有及时更新迭代器就会引发异常
  4. 如何解决并发修改异常
    1. 使用普通for：用索引取值，同一时间只有一个对象对集合操作
    2. 使用列表迭代器ListIterator

3.2 ListIterator

  • ListIterator的两个遍历方法

boolean hasNext()

从前往后遍历

boolean hasPrevious()

从后往前遍历，前提是先得从前往后遍历一遍，让迭代器指针走到末尾

 
List<String> list = new ArrayList<>();
ListIterator<String> listIterator = list.listIterator();
  • ListIterator和Iterator的区别
    1. ListIterator每进行一次迭代都会把实际修改值重新赋值给预期修改值，但是Iterator不行
    2. ListIterator是List集合特有的，Iterator是所有集合都有的

4. 两个主要的接口实现类

4.1 特点

List的接口实现类，List的特点就是ArrayList、LinkedList的特点

4.2 ArrayList

  • 使用的是数组，默认容量为10
  • 一旦数组满了，则创建一个新的数组，新数组的容量是原数组的容量的1.5倍。并且会将原数组内容复制到新数组
  • 因为底层是数组，具有数组的特点：查询快，增删慢

  • 可存储null值
  • 此实现不同步，线程不安全

4.3 LinkedList

  • 底层是双向链表
  • 具有链表的特点：查询慢，增删快
  • 此实现不同步，线程不安全
  • 常用方法

六、Set

1. 特点

元素唯一，无序，没有索引，最多只能一个null

三个主要的接口实现类

HashSet、TreeSet、LinkedHashSet

2. HashSet

2.1 特点：无序（HashSet只是不保证有序，并不是保证无序），不重复，无索引，此实现不同步

2.2 底层实现：哈希表，是一种对增删改查性能都较好的结构

  • 哈希表组成

  jdk8之前：数组+链表

  jdk8之后：数组+链表+红黑树

  • 哈希值

  • 哈希值是jdk根据对象计算得出的内存地址，根据某个规则算出来的int类型数值
  • 对象可以通过调用hashCode()返回对象的哈希值
  • 同一个对象的哈希值是相同的
  • 在默认情况下，不同对象的哈希值是相同的（除非重写了hashCode方法）

2.3 HashSet底层存储结构

  1. 当调用无参hashSet构造器，会默认创建一个长度为16的数组
  2. 添加元素，元素哈希值和数组长度根据哈希算法计算元素存储位置
  3. 判断该位置是否为空，如果为空直接存数组
  4. 如果位置不为空，判断哈希值，如果不同直接存链表
  5. 如果哈希值相同，判断equals是否相同，如果不同直接存链表
  6. 如果都相同就不存

  • 版本差异

  jdk8之前：新元素占据旧元素位置，指向旧元素。当元素链表挂载元素过多会造成查询性能下降。

  jdk8之后：新元素挂在旧元素下面。当链表长度超过8时，自动将链表转换为红黑树，进一步提高性能

  • 元素去重原理（面试会问）

  1. 判断hashcode值是否相同，如果不同，则不重复
  2. 如果hashcode相同，调用equals比较，如果为true，则重复。否则挂在元素下边
  3. 在类中可以重写equals和hashCode方法，进行自定义特征比较
//假设这是一个学生类，有name和age两个属性
//重写equals和hashCode方法
@Override 
public boolean equals(Object o) { 
    if (this == o) 
        return true; 
    if (o == null || getClass() != o.getClass()) 
        return false; 
    Student student = (Student) o; 
    return Objects.equals(name, student.name); //例如这里
    //可以自定义比较对象中的哪一个特征，比如就比较名字是否一样，不在乎年龄是否一样
} 
@Override 
public int hashCode() { 
    return Objects.hash(name); //例如这里
    //可以自定义要进行计算哈希的对象，比如只想判断名字哈希是否一样，
    //名字哈希一样就认为这俩对象哈希一样，不在乎年龄哈希是否一样
}

3. TreeSet

3.1 特点：默认自然升序排序，不重复，无索引，可排序

3.2 排序方式

  • 自然排序

  1. 必须实现Comparable接口，重写compareTo，定义排序规则
  2. Integer、String这些类默认已经实现了Comparable接口，可以直接去调用
  3. 英文按照字母顺序，中文按照Unicode码大小升序

  • 比较器排序（定制排序）：

  创建集合时候就实现Comparator接口

  如何理解排序呢

  首先要知道这俩的区别

  • Comparable是比较接口，Comparator是比较器
  • 实现比较接口（Comparable）就意味着该类支持排序
  • 实现比较器（Comparator）就意味着该集合要使用自定义的比较方法
  • Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

  通俗一点，用人话说就是：

  • 使用Comparable就是支持排序，意思是我这个类支持排序
  • 使用了Comparator就是比较器，不管类支不支持，想要排序就得按照我比较器的规矩排序

LinkedHashSet

  1. 特点：有序（存入和取出顺序一样），不重复，无索引
  2. 底层存储结构：哈希表和双向链表，双向链表用来记录存储的顺序

七、所有集合最全面总结

  List Set
实现类 ArrayList LinkedList HashSet TreeSet LinkedHashSet
顺序 有序 有序 无序 有序 有序
重复 可重复 可重复 不可重复 不可重复 不可重复
空值 允许多个null 允许多个null 最多一个null 最多一个null 最多一个null
索引 有索引 有索引 无索引 无索引 无索引
排序 存入顺序就是取出顺序 存入顺序就是取出顺序 不能排序 自然排序和比较器排序 存入顺序就是取出顺序
特点 查询快 增删首尾操作快 增删改查都快的五边形战士 唯一可以自定义排序 增删改查都快的五边形战士
底层 数组 链表 哈希表 红黑树 哈希表和双链表
凡是带list都可重复、有索引 凡是带set都不可重复、无索引
凡是带hash都是五边形战士，增删改查都快 只有HashSet无序、不能排序

八、集合工具类Collections

Collections 不属于集合，是用来操作集合的工具类

 

标签：迭代,List,单列,元素,list,Collection,哈希,集合
From： https://www.cnblogs.com/wanghycoder/p/17231876.html

相关文章

  • Web API接口返回实现类集合的姿势了解
    大家好，我是沙漠尽头的狼。一.问题描述如下图，定义两个子类Student和Employ，都继承自抽象类PersonBase:publicabstractclassPersonBase{publicstringName{ge......
  • 集合（可恶啊，学的好慢，去青岛玩了5天）
    集合集合概念对象的容器，实现了对对象常用的操作，类似于数组的功能集合和数组的区别：数组长度固定，集合长度不固定数组可以存储基本类型和引用类型，集合只能引用类型Colle......
  • C#集合的种类,待补充。。。
    一。数组类型。查看快，修改慢，在中间插入一个数据，会移动其他数据的下标志。1.数组Array2.ArrayList3.List<T>,这个是最常用的。本质也是带有类型的Array。执行Add操作，大于......
  • 在 Java 中使用集合框架
    一.什么是集合框架集合框架的概述Java中的集合框架是一组用于管理和操作对象集合的类和接口，它们提供了比数组更高级别的数据结构和算法，以及更方便的数据访问和操作方式。Ja......
  • 测试JUC安全类型的集合
    packageedu.wtbu;importjava.util.concurrent.CopyOnWriteArrayList;//测试JUC安全类型的集合publicclassDemo09{publicstaticvoidmain(String[]args){......
  • 【转载】集合中元素的数据类型可以不同，但集合中不能嵌套列表、元组、集合、字典
    1、问题根源：text={"a":{"aa":1,"b":2},"b":2,"c":3,"d":4,"e":5}list_dict=[{v:text[v]}forvintext]set(list_dict)输出：TypeError......
  • Python 中，set() 是一个内置函数，它用于创建一个集合（set）。
    在Python中，set()是一个内置函数，它用于创建一个集合（set）。集合是一种无序的、不重复的的数据集合，它的元素可以是任何不可变的数据类型，如整数、浮点数、字符串、元组等。......
  • Java 集合（泛型 Stream）
    1.泛型JDK5开始出现了泛型的使用泛型符号可以应用在类，接口，方法的声明处，起到一个占位符的作用，先占个位置，给引用类型占个位置；泛型符号名称和个数无要求;TtypeE......
  • 不可变集合和Stream流
    不可变集合1.不可变集合的特点定义完成后不可以添加,删除和修改2.不可变集合的优点更安全,更效率3.如何创建可以用List,Set,Map接口种,都存在的of方法创建不可变集合......
  • 【洛谷】P4139 上帝与集合的正确用法（扩展欧拉定理）
    原题链接题意求：\[2^{2^{2^{\ldots}}}\modp\]可以证明这个式子一定为一个常数。\(1\leqp\leq10^7\)思路根据扩展欧拉定理，可以得到：\[2^{2^{2^{\ldots}}}\equi......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99