Java集合框架详解：接口、迭代器与常用实现-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_63597125/article/details/125864015

前言

兄弟们，终于更到Java集合了😭。
学完集合我们就可以刷算法题了😄。
但是目前博主还没有这个实力😎。

一、Java集合框架接口

Java集合其实就是别人写好的数据结构，分别为栈、队列、链表、动态扩容数组、哈希表、二叉树等等
数据结构呢，在这篇文章中不作为重点，我们主要介绍实现了此数据结构的集合。
现在我们开始吧👇(Φ皿Φ)

1.1Collection接口

我想大家也看到上面的图了，在Java类库中，集合类的基本接口是Collection接口。
Collection接口有三个子接口分别为List、Set
Collection接口中有很多的方法，其中有一种利与集合遍历的方法，就是使用迭代器iterator遍历。
**boolean add(E e)**确保此集合包含指定的元素
**boolean addAll(Collection<? extends E> c)**将指定集合中所有元素添加到此集合
**void clear()**从此集合中删除所有元素
**boolean contains(Object o)**如果此集合包含指定集合中的所有元素，则返回true
**boolean equals(Object o)**将指定的对象与此集合进行比较以获得相等性
int hashCode() 返回此集合的哈希码值
**boolean isEmpty()**如果此集合不包含元素，则返回true
**Iterator iterator()**返回此集合中的元素的迭代器
**boolean remove(Object o)**从该集合中删除指定元素的单个实例
**boolean removeAll(Collection<?> c)**删除指定集合中包含的所有此集合的元素
**boolean retainAll(Collection<?> c)**仅保留此集合中包含在指定集合中的元素
int size() 返回此集合中的元素数
**Object[] toArray()**返回一个包含此集合中所有元素的数组
** T[] toArray(T[] a)**返回包含此集合中所有元素的数组，返回的数组的运行时类型时指定数组的运行时类型

1.2Iterator迭代器

Collection也继承了Iterable接口，具体操作看如下或者上图。
我给大家写一段对于集合使用迭代器遍历的基本操作。

public class Test1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();//首先我们创建一个ArrayList集合
        list.add(1);//向集合中添加元素
        list.add(2);
        list.add(3);
        Iterator<Integer> iter = list.iterator();//调用集合中的迭代器方法
        while(iter.hasNext()) {//判断集合中是否还有元素
            int it = iter.next();//把集合中的元素取出来，然后跳过当前元素，指向下一个元素
            System.out.println(it);//输出🤔
        //这就是迭代器使用的基本操作啦！前面讲过，在迭代器操作过程中，我们不能在循环里对元素进行操作的o😊
        }
    }
}

我给大家画一个迭代器移动的图🎇
这就是我们迭代器移动的原理，其实它使指在了两个元素中间进行移动的。

for(Integer value:list) {
    System.out.println(value);//当然使用增强for循环，可谓是对我们集合非常的方便简洁。
}
    Iterator<Integer> iter = list.iterator();
    //我们可以利用lambda表达式。
    //直接调用forEachRemaining方法。(但是并不推荐使用此方法)
    iter.forEachRemaining(value-> System.out.println(list));

对于Iterator接口还有一个remove()方法，见名知意删除，用法也没什么大区别。
具体的Collection方法可以查看API文档进行学习，在这里我不一一介绍了。
**boolean hasNext()**如果集合中还有元素，则返回true
**E next()**返回迭代中的下一个元素
**default void remove()**删除此迭代器返回的当前元素
**default void forEachRemaining(Consumer<? super E> action)**对每个剩余元素执行给定的操作。

二、List接口✍

2.1List接口的特点

对于前面的学习我们已经知道了，集合的两个基本接口为：Collection和Map。
List是一个有序集合，当我们使用List接口的实现类时，元素都是按顺序添加进来的，就跟我们的数组一样。
同时List集合中可以添加重复的元素，每个元素有自己的下标。
所以我们可以采用两种访问方式：①使用迭代器访问 ②使用整数索引(数组下标)来访问----->也称之为随机访问。
ListIterator接口时Iterator的一个子接口，这个接口可以让我们在使用迭代器遍历时，对元素进行操作，我们可以对元素进行增删改查操作。
List接口下面有三个实现类分别为：ArrayList、LinkedList、Vector。

2.2ArrayList

ArrayList是用数组实现的，它支持动态扩容机制。当前数组是由默认构造方法生成的空数组并且第一次添加数据。此时minCapacity等于默认的容量（10）那么根据下面逻辑可以看到最后数组的容量会从0扩容成10。而后的数组扩容才是按照当前容量的1.5倍进行扩容。
优点：

根据下标遍历元素效率高
根据下标查询元素效率高
可以自动扩容
缺点：
插入、删除元素效率低。数组所谓的删除元素其实都是覆盖，没有真正的删除

Collection接口所拥有的方法，ArrayList都有
**void add(int index , E element)**在此列表中的指定位置插入指定的元素
**Object clone()**返回此ArrayList实例的浅拷贝
**boolean contains(Object o)**如果此列表包含指定的元素，则返回true
**void ensureCapacity(int minCapacity)**如果需要，增加此ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素
**void forEach(Consumer<? super E> action)**对Iterable的每个元素执行给定的操作，直到所有元素都被处理或者动作引发异常。
**E get(int index)**返回此列表中指定位置的元素
**int indexOf(Object o)**返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
**boolean isEmpty()**如果此列表不包含元素，则返回true
**int lastIndexOf(Object o)**返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
**ListIterator listIterator()**返回列表中的列表迭代器
**E set(int index , E element)**用指定的元素替换此列表中指定位置的元素
**void sort(Comparator<? super E> c)**使用提供的Comparator对此列表进行排序比较元素
**void trimToSize()**修改这个ArrayList实例的容量是列表当前的大小

2.3LinkedList

LinkedList是用链表来实现的，是一个有序集合。
**优点：**插入、删除效率高
**缺点：**查找、修改效率低
LinkedList的add()方法是链表的尾插法。
LinkedList类实现了ListIterator接口，可以在迭代的时候对元素进行操作

public class Test1 {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        ListIterator<Integer> iterator = list.listIterator();
        Integer next = iterator.next();
        iterator.add(10);//会在迭代器位置前添加元素
        System.out.println(list);
      //输出结果[1, 10, 2, 3, 4, 5]
    }
}

LinkedList常用的方法如下：仍然是Collection有的它也有
**void addFirst(E e)**在该列表开头插入指定的元素
**void addLast(E e)**将指定的元素追加到此列表的末尾
**void clear()**从列表中删除所有元素
**Object clone()**返回此LinkedList的浅版本
Iterator descendingIterator以相反的顺序返回此deque中的元素的迭代器
**E element()**检索但不删除此列表的头(第一个元素)
**E get(int index)**返回此列表中指定位置的元素
**E getFirst()**返回此列表中的第一个元素
**E getLast()**返回此列表中的最后一个元素
**boolean offer(E e)**将指定的元素添加到为此列表的尾部(最后一个元素)
**boolean offerFirst(E e)**在此列表的前面插入指定的元素
**boolean offerLast(E e)**在该列表的末尾插入指定的元素
**E peek()**检索但不删除此列表的头
**E peekLast()**检索但不删除此列表的第一个元素
**E peekLast()**检索但不删除此列表的最后一个元素
**E poll()**检索并删除此列表的头
**E pollFirst()**检索并删除此列表的第一个元素
**E pollLast()**检索并删除此列表的最后一个元素
**E pop()**从此列表表示的堆栈中弹出一个元素
**void push(E e)**将元素推送到由此列表表示的堆栈上
**E set(int index, E element)**用指定的元素替换此列表中指定位置的元素

三、Set接口✍

3.1Set接口的特点

首先我们要来了解一下什么是散列表
可以用来快速查找对象，每个对象都拥有一个自己的散列码。散列码是由String类的hashCode方法产生的。如果a.equals(b)为true，则a与b的hashCode必须相等。
Java集合中提供的HashSet类的实现就基于散列表的集。
它是无序的插入。
元素不可以重复
无法根据下标进行操作
Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一种，迭代器。

3.2HashSet

|——HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；

HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。

当元素的hashCode值相同时，才继续判断元素的equals是否为true。

如果为true，那么视为相同元素，不存。如果为false，那么存储。

如果hashCode值不同，那么不判断equals，从而提高对象比较的速度。

|——LinkedHashSet：有序，hashset的子类。

|——TreeSet：对Set集合中的元素的进行指定顺序的排序。不同步。TreeSet底层的数据结构就是二叉树。
　　对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。

对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

3.3TreeSet

用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。
如果元素不具备比较性，在运行时会发生ClassCastException异常。
所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。
依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。
**TreeSet方法保证元素唯一性的方式：**就是参考比较方法的结果是否为0，如果return 0，视为两个对象重复，不存。

四、Map接口✍

4.1映射

映射用来存放键/值对，如果提供了键，就能查找到值。
Java类库为映射提供了两个通用的实现：HaspMap和TreeMap。
Map集合：

|——Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。

|——HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

|——TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。

1，添加。

put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

void putAll(Map);

2，删除。

void clear()：清空

value remove(key) ：删除指定键。

3，判断。

boolean isEmpty()：

boolean containsKey(key)：是否包含key

boolean containsValue(value) ：是否包含value

4，取出。

int size()：返回长度

value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

Collection values()：获取map集合中的所有的值。

5，想要获取map中的所有元素：

原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

★ 把map集合转成set的方法：

Set keySet();
Set entrySet();//取的是键和值的映射关系。
Entry就是Map接口中的内部接口；
为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

——————————————————————————————————————————————————————
★取出map集合中所有元素的方式一：keySet()方法。

可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。
　　　Set keySet = map.keySet();

Iterator it = keySet.iterator();

while(it.hasNext()) {

Object key = it.next();

Object value = map.get(key);

System.out.println(key+“:”+value);

}
——————————————————————————————————————————————————————

★取出map集合中所有元素的方式二：entrySet()方法。

Set entrySet = map.entrySet();

Iterator it = entrySet.iterator();

while(it.hasNext()) {

Map.Entry me = (Map.Entry)it.next();

System.out.println(me.getKey()+“::::”+me.getValue());

}

——————————————————————————————————————————————————————

★使用集合的技巧：

看到Array就是数组结构，有角标，查询速度很快。
看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
看到tree就是二叉树，就要想到排序，就想要用到比较。

★比较的两种方式：

一个是Comparable：覆盖compareTo方法；
一个是Comparator：覆盖compare方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

★集合什么时候用？

当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。

保证唯一，就用Set。不保证唯一，就用List。

五、排序与查找小补充

Collections类提供的用于排序和查找的类方法如下：👇
public static sort(List list):该方法可以将list的元素按升序排序
int binarySearch(List list,T key,CompareTo c):二分查找
String类实现了Comparable接口，规定字符串按字典序比较大小，如果链表中存放的对象不是String对象，那么创建对象的类必须实现Comparable接口，即用该接口中的int compareTo(T b)方法来规定对象的大小关系，(原因是sort()方法在排序时需要调用名字时compareTo的方法，来比较的对象大小)。
就时如果对象不是String类型的，我们在用sort时需要自己编写compareTo()方法。

六、结尾

对于Java集合内容就总结这么多(后面比较水了！)，若想深入学习等待后续更新，基础部分掌握这些足矣。如果有不足之处，希望大家多多包涵，多多支持。如果有不懂的地方可以直接私信问我，欢迎来访！
我将会继续更新关于Java的学习知识，感兴趣的小伙伴可以关注一下。
文章写得比较走心，用了很长时间，绝对不是copy过来的！
尊重每一位学习知识的人，同时也尊重每一位分享知识的人。
😎你的点赞与关注，是我努力前行的无限动力。