Java集合总复习(内容详细涉及面多)

集合概述

1.为了解决数组的缺点。我们开始使用了集合！
2.多集合底层都是依赖于数组的实现。数组一旦初始化后，长度就确定了，存储数据对象不能达到动态扩展，其次数组存储元素不便于对数组进行添加、修改、删除操作，而且数组可以存储重复元素。这个时候集合对作用显现出来了。集合分为Collection和Map两种体系。

集合介绍

Collection（接口）：
1:Collection接口是 (java.util.Collection)是Java集合类的顶级接口之一
2:Collection 接口是在整个 Java 类集中保存单值的最大操作父接口，里面每次操作的时候都只能保存一个对象的数据，此接口使用了泛型技术，在 JDK 1.5 之后为了使类集操作的更加安全，所以引入了泛型。
3.Collection接口方法

方法名	说明
boolean add（Object o）	向集合中添加元素，添加成功返回true
void clear()	清空所有集合元素
boolean contains(Object o)	判断集合中是否包含对象o
boolean remove(Object o)	删除指定集合包含c的元素,若集合中指定删除元素不唯一则删除第一个元素
int size()	返回集合元素的个数
T[] toArrar(T[] a	将集合转换为T类型的数组
boolean idEmpty ()	判断指定集合的元素长度是否为0
boolean containsAll(Collection<?> c)	判断指定集合是否包含集合c的所有元素
boolean removeAll(Collection<?> c)	删除指定集合包含集合C的元素
boolean retainAll(Collectioni<?> c)	从指定集合中保留包含集合c的元素,删除其他元素

img

Collection子接口<T>

特点：Collection主要有三个子接口，分别为List(列表)、Set(集)、Queue(队列)。其中，List、Queue中的元素有序可重复，而Set中的元素无序不可重复。

1.List<T>集合(列表)

List中主要有ArrayList、LinkedList两个实现类
List集合是有序的，可对其中每个元素的插入位置进行精确地控制，可以通过索引来访问元素，遍历元素。

ArrayList集合

介绍：
1，ArrayList底层通过数组实现，随着元素的增加而动态扩容。
2，ArrayList是Java集合框架中使用最多的一个类，是一个数组队列。
3，它继承于AbstractList，实现了List, RandomAccess, Cloneable, Serializable接口。

特点:
1，ArrayList实现List，得到了List集合框架基础功能；
2，ArrayList实现RandomAccess，获得了快速随机访问存储元素的功能，RandomAccess是一个标记接口，没有任何方法；
3，ArrayList实现Cloneable，得到了clone()方法，可以实现克隆功能；
4，ArrayList实现Serializable，表示可以被序列化，通过序列化去传输，典型的应用就是hessian协议。
5，容量不固定，随着容量的增加而动态扩容（阈值基本6，不会达到）
7，有序集合（插入的顺序==输出的顺序）
8，插入的元素可以为null
9，增删改查效率更高（相对于LinkedList来说）
10, 没有同步，线程不安全
11, 有序，不唯一
12, 查询快，增删慢

ArrayList方法

方法名	说明
boolean add(Object element)	向列表末尾添加指定的元素
int size()	返回列表中的元素个数
E get(it index)	返回列表中指定位置的元素 index从o开始
E set(int i,Object o)	将索引i位置元素替换为元素o并返回替换的元素
void clear()	从列表中移除所有元素
boolean isEmpty()	判断列表是否包含元素,不包含则返回true,否则返回false
boolean contains(Object o)	如果列表中包含指定的元素则返回true
E remove(int index)	删除列表中指定下标的元素,并返回被删除元素
boolean remove(Object o)	删除集合中第一次出现的指定元素,成功返回true,否则返回false
boolean removeAll​(Collection<?> c)	从此列表中删除指定集合中包含的所有元素。
boolean removeIf​(Predicate<? super E> filter)	删除此集合中满足给定谓词的所有元素
boolean retainAll​(Collection<?> c)	仅保留此列表中包含在指定集合中的元素。
Iterator<E> iterator()	返回按适当顺序在列表的元素上进行迭代的迭代器
RemoveRange(int index,int count)	移除从索引index开始，移除count个元素
void add​(int index, E element)	将指定元素插入此列表中的指定位置。
boolean addAll​(int index, Collection<? extends E> c)	从指定位置开始，将指定集合中的所有元素插入此列表。
boolean addAll​(Collection<? extends E> c)	将指定集合中的所有元素按指定集合的Iterator返回的顺序附加到此列表的末尾。
Object clone()	返回此 ArrayList实例的浅表副本。
void ensureCapacity​(int minCapacity)	如有必要，增加此 ArrayList实例的容量，以确保它至少可以容纳由minimum capacity参数指定的元素数。
void forEach​(Consumer<? super E> action)	对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。
int indexOf​(Object o)	返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
int lastIndexOf​(Object o)	返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
ListIterator<E> listIterator()	返回此列表中元素的列表迭代器（按适当顺序。
ListIterator<E> listIterator​(int index)	从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
E remove​(int index)	删除此列表中指定位置的元素。
Spliterator spliterator()	在此列表中的元素上创建late-binding和故障快速 Spliterator 。
List subList​(int fromIndex, int toIndex)	返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
Object[] toArray()	以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
T[] toArray​(T[] a)	以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。
void trimToSize()	将此 ArrayList实例的容量调整为列表的当前大小。

ArrayList遍历方式

迭代器遍历

// 声明集合
ArrayList<Integer> arrayList=new ArrayList<>();
// 添加数据
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
// 使用迭代器遍历:声明迭代器
Iterator<Integer> iterator=arrayList.iterator();
// .hasNext() 判断是否含有迭代元素（boolean）
while(iterator.hasNext()){
// .next() 返回迭代的下一个元素
System.out.println(iterator.next());
}

索引值遍历

// 声明集合
ArrayList arrayList=new ArrayList<>();
// 添加数据
arrayList.add(1);
// 使用for循环遍历
for (int i=0;i<arrayList.size();i++){
System.out.println(arrayList.get(i));
}

foreach循环遍历

// 声明集合
ArrayList arrayList=new ArrayList<>();
// 添加数据
arrayList.add(1);
// 使用foreach遍历
for (Integer integer : arrayList) {
System.out.println(integer);
}

Vector集合

介绍：
Vector类实现了可增长的对象数组。 像数组一样，它包含可以使用整数索引访问的组件。 但是， Vector的大小可以根据需要增大或缩小，以便在创建Vector后添加和删除项目。
在内存中分配一块连续的内存空间进行存储。支持不指定vector大小的存储。STL内部实现时，首先分配一个非常大的内存空间预备进行存储，即capacity（）函数返回的大小，当超过此分配的空间时再整体重新放分配一块内存存储，这给人以vector可以不指定vector即一个连续内存的大小的感觉。通常此默认的内存分配能完成大部分情况下的存储。
从Java 2平台v1.2开始，该类被改进以实现List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector是同步的。 如果不需要线程安全实现，建议使用ArrayList代替Vector 。

特点：
(1) 不指定一块内存大小的数组的连续存储，即可以像数组一样操作，但可以对此数组进行动态操作。通常体现在push_back() pop_back()
(2) 随机访问方便，即支持[ ]操作符和vector.at()
(3) 节省空间。
缺点:
(1) 在内部进行插入删除操作效率低。
(2) 只能在vector的最后进行push和pop，不能在vector的头进行push和pop。
(3) 当动态添加的数据超过vector默认分配的大小时要进行整体的重新分配、拷贝与释放

Vector方法

方法名	说明
void add​(int index, E element)	将指定元素插入此Vector中的指定位置。
boolean add​(E e)	将指定的元素追加到此Vector的末尾。
boolean addAll​(int index, Collection<? extends E> c)	将指定Collection中的所有元素插入到此Vector中的指定位置。
boolean addAll​(Collection<? extends E> c)	将指定Collection中的所有元素追加到此Vector的末尾，按照指定Collection的Iterator返回的顺序。
void addElement​(E obj)	将指定的组件添加到此向量的末尾，将其大小增加1。
int capacity()	返回此向量的当前容量。
void clear()	从此Vector中删除所有元素。
Object clone()	返回此向量的副本。
boolean contains​(Object o)	如果此向量包含指定的元素，则返回 true 。
boolean containsAll​(Collection<?> c)	如果此Vector包含指定Collection中的所有元素，则返回true。
void copyInto​(Object[] anArray)	将此向量的组件复制到指定的数组中。
E elementAt​(int index)	返回指定索引处的组件。
Enumeration<E> elements()	返回此向量的组件的枚举。
void ensureCapacity​(int minCapacity)	如有必要，增加此向量的容量，以确保它至少可以容纳由minimum capacity参数指定的组件数。
boolean equals​(Object o)	将指定的Object与此Vector进行比较以获得相等性。
E firstElement()	返回此向量的第一个组件（索引 0处的项）。
void forEach​(Consumer<? super E> action)	对 Iterable每个元素执行给定操作，直到处理 Iterable所有元素或操作引发异常。
E get​(int index)	返回此Vector中指定位置的元素。
int hashCode()	返回此Vector的哈希码值。
int indexOf​(Object o)	返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回-1。
void insertElementAt​(E obj, int index)	将指定对象作为此向量中的组件插入指定的 index 。
boolean isEmpty()	测试此向量是否没有组件。
Iterator<E> iterator()	以适当的顺序返回此列表中元素的迭代器。
E lastElement()	返回向量的最后一个组件。
int lastIndexOf​(Object o)	返回此向量中指定元素最后一次出现的索引，如果此向量不包含该元素，则返回-1。
int lastIndexOf​(Object o, int index)	返回此向量中最后一次出现的指定元素的索引，从 index向后搜索，如果找不到该元素，则返回-1。
ListIterator<E> listIterator()	返回此列表中元素的列表迭代器（按适当顺序）。
ListIterator<E> listIterator​(int index)	从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
E remove​(int index)	删除此Vector中指定位置的元素。
boolean remove​(Object o)	删除此向量中第一次出现的指定元素如果向量不包含该元素，则不会更改。
boolean removeAll​(Collection<?> c)	从此Vector中删除指定Collection中包含的所有元素。
void removeAllElements()	从此向量中移除所有组件并将其大小设置为零。
boolean removeElement​(Object obj)	从此向量中移除参数的第一个（索引最低）事件。
void removeElementAt​(int index)	删除指定索引处的组件。
boolean removeIf​(Predicate<? super E> filter)	删除此集合中满足给定谓词的所有元素。
protected void removeRange​(int fromIndex, int toIndex)	从此列表中删除索引介于 fromIndex （含）和 toIndex （独占）之间的所有元素。
void replaceAll​(UnaryOperator operator)	将该列表的每个元素替换为将运算符应用于该元素的结果。
boolean retainAll​(Collection<?> c)	仅保留此Vector中包含在指定Collection中的元素。
E set​(int index, E element)	用指定的元素替换此Vector中指定位置的元素。
void setElementAt​(E obj, int index)	将此向量的指定 index处的组件设置为指定对象。
void setSize​(int newSize)	设置此向量的大小。
int size()	返回此向量中的组件数。
Spliterator<E> spliterator()	在此列表中的元素上创建late-binding和失败快速 Spliterator 。
List<E> subList​(int fromIndex, int toIndex)	返回此List的部分在fromIndex（包含）和toIndex（独占）之间的视图。
Object[] toArray()	以正确的顺序返回包含此Vector中所有元素的数组。
<T> T[] toArray​(T[] a)	以正确的顺序返回包含此Vector中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。
String toString()	返回此Vector的字符串表示形式，包含每个元素的String表示形式。
void trimToSize()	修剪此向量的容量为向量的当前大小。

Vector集合的遍历方式

迭代器遍历:

Vector<Integer> vector=new Vector<>();
vector.add(1);
vector.add(2);
vector.add(3);
// 使用迭代器遍历
// 声明迭代器
Iterator iterator= vector.iterator();
// .hasNext()判断是否有迭代元素
while(iterator.hasNext()){
// .next()取出迭代的下一个元素
System.out.println(iterator.next());
}

Vector特有迭代器遍历:

Vector<Integer> vector=new Vector<>();
vector.add(1);
vector.add(2);
vector.add(3);
// 使用迭代器遍历
// 声明迭代器
Enumeration<Integer> vector1=vector.elements();
// 测试此枚举是否包含更多元素。
while(vector1.hasMoreElements()){
// 如果此枚举对象至少还有一个要提供的元素，则返回此枚举的下一个元素。
System.out.println(vector1.nextElement());
}

使用for循环遍历:

Vector<Integer> vector=new Vector<>();
vector.add(1);
vector.add(2);
vector.add(3);
// 使用for循环遍历
for (int i=0;i<vector.size();i++){
System.out.println(vector.get(i));
}

使用增强for循环遍历:

Vector<Integer> vector=new Vector<>();
vector.add(1);
vector.add(2);
vector.add(3);
// 使用增强for循环遍历
for (Integer integer : vector) {
System.out.println(integer);
}

LinkedList集合

介绍:
**1:**LinkedList同时实现了List接口和Deque对口，也就是收它既可以看作一个顺序容器，又可以看作一个队列（Queue），同时又可以看作一个栈（stack），这样看来，linkedList简直就是无敌的，当你需要使用栈或者队列时，可以考虑用LinkedList,一方面是因为Java官方已经声明不建议使用Stack类，更遗憾的是，Java里根本没有一个叫做Queue的类（只是一个接口的名字）。关于栈或队列，现在首选是ArrayDeque，它有着比LinkedList（当作栈或队列使用时）更好的性能。
**2:**LinkedList的实现方式决定了所有跟下表有关的操作都是线性时间，而在首段或者末尾删除元素只需要常数时间。为追求效率LinkedList没有实现同步（synchronized），如果需要多个线程并发访问，可以先采用Collections.synchronizedList()方法对其进行包装。
**3:**链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
**4:**链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。
一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。
**5:**Java LinkedList（链表） 类似于 ArrayList，是一种常用的数据容器。
与 ArrayList 相比，LinkedList 的增加和删除对操作效率更高，而查找和修改的操作效率较低。

特点
1.存储数据，非连续空间
2.数据之间通过引用连接，方便遍历啊和使用
3.遍历效率较低，数据非连续空间存储，需要通过引用跳转来完成
4.删除插入操作效率高，但是注意地址的转移和保存问题
5.LinkedList链表当中的操作其实大部分都是和C语言指针一个概念
6.LinkedList实现了Queue、Deque接口，；
7.LinkedList适合删除操作，因为删除不会发生移位；
8.LinkedList可以包含重复的元素；
9.LinkedList是非线程安全的；
10.LinkedList维护了元素插入时的顺序。

LinkedList方法

方法名	说明
void add​(int index, E element)	将指定元素插入此列表中的指定位置。
boolean add​(E e)	将指定的元素追加到此列表的末尾。
boolean addAll​(int index, Collection<? extends E> c)	从指定位置开始，将指定集合中的所有元素插入此列表。
boolean addAll​(Collection<? extends E> c)	将指定集合中的所有元素按指定集合的迭代器返回的顺序附加到此列表的末尾。
void addFirst​(E e)	在此列表的开头插入指定的元素。
void addLast​(E e)	将指定的元素追加到此列表的末尾。
void clear()	从此列表中删除所有元素。
Object clone()	返回此 LinkedList的浅表副本。
boolean contains​(Object o)	如果此列表包含指定的元素，则返回 true 。
Iterator<E> descendingIterator()	以相反的顺序返回此双端队列中元素的迭代器。
E element()	检索但不删除此列表的头部（第一个元素）。
E get​(int index)	返回此列表中指定位置的元素。
E getFirst()	返回此列表中的第一个元素。
E getLast()	返回此列表中的最后一个元素。
int indexOf​(Object o)	返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
int lastIndexOf​(Object o)	返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
ListIterator<E> listIterator​(int index)	从列表中的指定位置开始，返回此列表中元素的列表迭代器（按正确顺序）。
boolean offer​(E e)	将指定的元素添加为此列表的尾部（最后一个元素）。
boolean offerFirst​(E e)	在此列表的前面插入指定的元素。
boolean offerLast​(E e)	在此列表的末尾插入指定的元素。
E peek()	检索但不删除此列表的头部（第一个元素）。
E peekFirst()	检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
E peekLast()	检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E poll()	检索并删除此列表的头部（第一个元素）。
E pollFirst()	检索并删除此列表的第一个元素，如果此列表为空，则返回 null 。
E pollLast()	检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E pop()	弹出此列表所代表的堆栈中的元素。
void push​(E e)	将元素推送到此列表所表示的堆栈上。
E remove()	检索并删除此列表的头部（第一个元素）。
E remove​(int index)	删除此列表中指定位置的元素。
boolean remove​(Object o)	从该列表中删除指定元素的第一个匹配项（如果存在）。
E removeFirst()	从此列表中删除并返回第一个元素。
boolean removeFirstOccurrence​(Object o)	删除此列表中第一次出现的指定元素（从头到尾遍历列表时）。
E removeLast()	从此列表中删除并返回最后一个元素。
boolean removeLastOccurrence​(Object o)	删除此列表中最后一次出现的指定元素（从头到尾遍历列表时）。
E set​(int index, E element)	用指定的元素替换此列表中指定位置的元素。
int size()	返回此列表中的元素数。
Spliterator<E> spliterator()	在此列表中的元素上创建late-binding和故障快速 Spliterator 。
Object[] toArray()	以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
<T> T[] toArray​(T[] a)	以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。

LinkedList集合的遍历

使用普通for循环遍历(不推荐，效率低，速度慢):

LinkedList<Integer> linkedList=new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
// 使用 for循环遍历(不推荐,效率低，速度慢)
for (int i=0;i<linkedList.size();i++){
System.out.println(linkedList.get(i));
}

使用增强foreach(增强for)循环遍历:

LinkedList<Integer> linkedList=new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
// 使用 for循环遍历(不推荐,效率低，速度慢)
for (Integer integer : linkedList) {
System.out.println(integer);
}
使用迭代器遍历:

LinkedList<Integer> linkedList=new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
// 使用 迭代器遍历
Iterator<Intege> linkedlist= linkedList.iterator();
// .hasNext() 判断可用元素
while(linkedlist.hasNext()){
// 取出可用元素
System.out.println(linkedlist.next());
}

使用列表迭代器遍历:

LinkedList<Integer> linkedList=new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
// 使用 迭代器遍历
ListIterator<Integer> listIterator= linkedList.listIterator();
// .hasNext() 判断可用元素
while(listIterator.hasNext()){
// 取出可用元素
System.out.println(listIterator.next());
}