java集合2--List

1、List接口

该接口定义的元素是有序的且可重复的。相当于数学里面的数列,有序可重复

  • boolean addAll(int index, Collection< ? extends E> c); 将指定集合中所有元素,插入至本集合第index个元素之后
  • default void replaceAll(UnaryOperator operator); 替换集合中每一个元素值
  • default void sort(Comparator< ? super E> c); 给集合中的元素进行排序
  • E get(int index); 获取集合中第index个元素
  • E set(int index, E element); 将集合中第index个元素替换成指定元素
  • void add(int index, E element); 向集合中第index个位置添加一个元素
  • E remove(int index); 移除集合中第index个元素
  • int indexOf(Object o); 得到指定元素在集合中的位置(第一次出现)
  • int lastIndexOf(Object o); 得到指定元素在集合中的位置(最后一次出现)
  • ListIterator listIterator(); 返回ListIterator
  • ListIterator listIterator(int index); 返回ListIterator,并设置当前位置
  • List subList(int fromIndex, int toIndex); 截取List,从fromIndex到toIndex

2、List子类

2.1、AbstractList抽象类

该类实现了基本的List集合功能,如果实现的是只读的List集合,继承自该抽象类的子类只需要实现get(int index)和size()两个方法,如果是可操作的List集合,则必须重写add和set方法,否则执行add和set时会抛出UnsupportedOperationException异常
AbstractList抽象类中的迭代器通过get(int index)访问元素,通过remove(Object o)删除元素。
AbstractList抽象类包含了一个SubList子类,该子类通过包装一个AbstractList抽象类对象实现元素的添加、删除等功能。

该抽象类主要实现了如下方法:

  • boolean add(E e); 添加元素e,内部调用add(int index,E element)实现
  • int indexOf(Object o); 得到指定元素第一次在集合中的位置,内部通过List迭代器实现
  • int lastIndexOf(Object o); 得到指定元素在集合中的位置(最后一次出现),内部List迭代器实现,注意此处是从后往前迭代
  • void clear(); 清空List集合中的元素,内部通过List迭代器实现
  • boolean addAll(int index, Collection< ? extends E> c); 插入集合c中所有元素,内部调用add(int index,E element)实现
  • Iterator iterator(); 返回一个迭代器对象,AbstractList抽象类内部实现了一个迭代器
  • ListIterator listIterator(); 返回一个List迭代器对象,AbstractList抽象类内部实现了一个List迭代器
  • boolean equals(Object o); 重写Object的equals方法,内部先判断是否同一个对象,是返回true,否则判断o是否是List对象,不是返回false,是的话迭代比较两个集合中每一个元素是否一致,都一致返回true
  • int hashCode(); 内部迭代集合中每一个元素计算出hashcode值
  • List subList(int fromIndex, int toIndex);得到List集合的子集合,内部通过构造AbstractList内部的SubList实现

2.2、ArrayList

ArrayList继承自AbstractList实现了List中所有方法,该集合可以插入任何元素包括null元素。
ArrayList内部使用数组保存元素,他的size、isEmpty、get、set、add等操作都是常数时间。在获取元素时会比LinkedList更有优势。
Arraylist有一个初始的大小,该大小会随着元素的增加而增长。
ArrayList不是线程安全的,在多线程环境下使用时需要注意,我们可以通过Collections.synchronizedList(new ArrayList(…));操作得到一个线程安全的ArrayList
ArrayList中的迭代器在List集合结果变化后,我们调用迭代器中的方法时会快速抛出ConcurrentModificationException异常通知程序,以免造成损失。
ArrayList的扩展策略:
在初始集合为空时,加入元素时会初始化Math.max(DEFAULT_CAPACITY, minCapacity)个空间,即取插入元素个数和DEFAULT_CAPACITY中比较大的那个数
集合非空时插入元素,如果空间不够时,则取原集合大小扩展2倍和最小需求大小中较大的那个进行扩展
ArrayList重写了Iterator和ListIterator,内部直接通过遍历数组实现
ArrayList重写了SubList类,该类直接通过访问数组实现
ArrayList主要包括以下属性:

  • transient Object[] elementData; 该对象数组用于存放集合中的元素
  • int size; 该属性用于保存集合的大小
  • transient int modCount; 记录ArrayList修改的次数,在集合迭代器中会使用该数字判断迭代时集合是否修改过
    ArrayList主要包含以下构造函数:
  • ArrayList(int initialCapacity); 构造初始大小为initialCapacity的集合对象
  • ArrayList(); 构造一个空的数组元素
  • ArrayList(Collection< ? extends E> c); 使用传入集合c构造一个集合对象

ArrayList主要包括以下函数:

  • void trimToSize(); 将集合中数组大小恢复至当前集合大小,该操作可以压缩集合使用空间
  • void ensureCapacity(int minCapacity); 通过传入的minCapacity判断集合是否需要扩展,需要的话则扩展数组大小,已足够存放元素
  • int indexOf(Object o); 得到指定元素第一次在集合中的位置,重写了AbstractList类的方法,内部直接遍历元素数组实现
  • int lastIndexOf(Object o); 同上
  • Object clone(); 重写了clone方法,并且将元素数组复制一份出来,且将modCount致0,注意此处数组中元素并没有clone,也就是说克隆后的集合和元集合使用同一份具体元素
  • Object[] toArray(); 直接返回本集合中的数组
  • E get(int index); 直接访问数组
  • E set(int index, E element); 直接设置数组元素值
  • boolean add(E e); 直接操作数组,想数组添加一个元素
  • E remove(int index); 直接操作数组
  • boolean remove(Object o); 一样遍历数组,注意该操作会导致数组移动
  • void clear(); 遍历将数组致空,同时设置size大小为0
  • boolean addAll(Collection< ? extends E> c); 通过数组直接添加
  • void sort(Comparator< ? super E> c); 实现集合中元素排序功能,接收一个Comparator用以比较集合中元素的大小

2.3、AbstractSequentialList抽象类

AbstractSequentialList是一个抽象类,继承自AbstractList抽象类
AbstractSequentialList内部基于链表实现,主要针对顺序访问list集合的情况,它在随机访问时表现较差
AbstractSequentialList的实现者需要提供listIterator和size两个实现,AbstractSequentialList内部本身通过listIterator实现了其他函数

ArrayList主要包含以下函数:

  • E get(int index); 获取第index个元素,内部通过ListIterator实现
  • E set(int index, E element); 替换集合的第index个元素,内部通过ListIterator实现
  • void add(int index, E element); 想list集合中插入元素,内部通过void add(int index, E element)实现
  • E remove(int index); 删除list中第index个元素,内部通过ListIterator实现
  • boolean addAll(int index, Collection< ? extends E> c); 添加另一个集合中的所元素,内部通过ListIterator实现
  • Iterator iterator(); 直接调用listIterator()方法

2.4、LinkedList

LinkedList继承自AbstractSequentialList抽象类,实现了List、Deque、Cloneable、和Serializable接口
LinkedList内部基于双向链表实现,允许插入任何元素,包括null
LinkedList不是线程安全的,在多线程环境下使用时需要注意,我们可以通过Collections.synchronizedList(new LinledList(…));操作得到一个线程安全的ArrayList
LinkedList中的迭代器在List集合结果变化后,我们调用迭代器中的方法时会快速抛出ConcurrentModificationException异常通知程序,以免造成损失。
LinkedList内部使用Node类存储元素,该类包含下面三个属性,
E item; 保存元素值得对象
Node next; 下一个节点对象
Node prev; 上一个节点对象
LinkedList重写了ListIterator,内部直接通过遍历链表实现迭代器功能
LinkedList主要包含以下属性

  • transient int size = 0; 集合当前大小
  • transient Node first; 链表的首元素
  • transient Node last; 链表的尾元素
    LinkedListList主要包含以下构造函数:
  • LinkedList(); 空构造函数
  • LinkedList(Collection< ? extends E> c); 使用另外一个集合的构造函数,会将另一个集合所有元素加入本集合中

LinkedList主要包含以下函数:
自有函数

  • void linkFirst(E e); 插入元素至第一个位置
  • void linkLast(E e); 插入元素至最后一个位置
  • void linkBefore(E e, Node succ); 在某个元素之前插入一个元素
  • E unlinkFirst(Node f); 移除第一个元素
  • E unlinkLast(Node l); 移除最后一个元素
  • E unlink(Node x); 移除指定元素
  • E getFirst(); 得到第一个元素
  • E getLast(); 得到最后一个元素
  • E removeFirst(); 移除第一个元素
  • E removeLast(); 移除最后一个元素
  • void addFirst(E e); 插入第一个元素
  • void addLast(E e); 插入最后一个元素
  • Node node(int index); 返回index对应的Node节点

List函数

  • boolean contains(Object o); 是否包含某个元素
  • int size(); 返回集合大小,直接返回size变量
  • boolean add(E e); 添加一个元素,调用linkLast(e);
  • boolean remove(Object o); 删除指定元素,通过遍历链表删除
  • boolean addAll(Collection< ? extends E> c); 将集合c插入至本集合,链表插入
  • void clear(); 遍历链表,清空所有元素,将首尾元素制空
  • E get(int index); 获取第index个元素,通过node(index)得到node节点
  • E set(int index, E element); 替换第index个元素,通过node(index)得到node节点,然后设置值
  • void add(int index, E element); 在第index位置插入元素,调用linkBefore(element, node(index));
  • E remove(int index); 删除第index个元素,通过unlink(node(index));实现
  • int indexOf(Object o); 得到o对象在集合中的位置(第一次出现),通过遍历链表实现,从头部开始遍历
  • int lastIndexOf(Object o) 得到o对象在集合中的位置(最后一次出现),通过遍历链表实现,从尾部开始遍历
    Deque函数
  • E peek(); 返回第一个元素,但不删除。直接去first首元素,集合空时,返回null
  • E element(); 返回第一个元素,但不删除。集合空时抛出异常,调用getFirst();
  • E remove(); 获得并移除队列顶部元素,如果队列为空抛出异常,调用removeFirst
  • E poll(); 获得并移除队列顶部元素,如果队列为空返回null调用unlinkFirst(f)
  • boolean offer(E e); 队列尾部插入元素,调用add(e)
  • boolean offerFirst(E e); 队列首部插入元素,调用addFirst(e);
  • boolean offerLast(E e); 队列尾部插入元素,调用addLast(e)
  • E peekFirst(); 返回首元素
  • E peekLast(); 返回最后一个元素,不删除,空时返回null
  • E pollFirst(); 获得并移除队列顶部元素,如果队列为空返回null调用unlinkFirst(f)
  • E pollLast(); 获得并移除队列尾部元素,如果队列为空返回null调用unlinkLast(f)
  • void push(E e); 向首部插入元素,调用addFirst(e);,栈方法
  • E pop(); 返回并移除首元素,调用removeFirst();,栈方法
  • boolean removeFirstOccurrence(Object o); 删除第一次出现o的元素,调用remove(o);函数
  • boolean removeLastOccurrence(Object o); 删除最后一次出现o的元素,从后向前遍历链表,匹配后移除

2.5、Vector

功能和ArrayList类似,不同的是Vector是线程安全的,其大部分方法都加了synchronized关键字以保证多线程环境下线程安全问题。不过在可以确保没有线程安全问题的情况下,我们还是应该选择ArrayList,因为ArrayList的效率要比Vector高。

2.6、CopyOnWriteArrayList

CopyOnWriteArrayList继承Object,实现了List, RandomAccess, Cloneable, java.io.Serializable接口
CopyOnWriteArrayList是
CopyOnWriteArrayList内部使用数组保存元素,但是它的数组大小等于集合的大小,因为它的增加、删除、修改元素都是新copy一份数组
CopyOnWriteArrayList是线程安全的,他的写操作加锁,读操作没有加锁,适用于读多写少的情况
CopyOnWriteArrayList实现了Iterator和ListIterator,内部通过遍历数组实现,但是它的迭代器不支持操作元素。会抛出UnsupportedOperationException

CopyOnWriteArrayList主要包含以下属性:

  • final transient ReentrantLock lock; CopyOnWriteArrayList内部使用的线程同步锁
  • transient volatile Object[] array; 集合内部用于保存元素的地方

CopyOnWriteArrayList主要包含以下构造函数:

  • CopyOnWriteArrayList(); 构造一个空的集合
  • CopyOnWriteArrayList(Collection< ? extends E> c); 创建一个包括闯入集合所有元素的集合
  • CopyOnWriteArrayList(E[] toCopyIn); 创建一个包含传入数组所有元素的集合,注:此处会copy原有数组。

CopyOnWriteArrayList主要包括以下函数:

  • final Object[] getArray(); 得到集合持有的数组对象
  • void setArray(Object[] a); 设置集合的数组对象
  • int size(); 返回集合大小,直接返回数组的长度
  • boolean isEmpty(); 判断集合是否为空
  • boolean contains(Object o); 判断集合是否包含某元素
  • int indexOf(Object o) ; 得到传入元素在集合中第一次出现的位置索引
  • int indexOf(E e, int index); 得到传入元素在集合中第一次出现的位置索引,从index开始查找
  • int lastIndexOf(Object o); 得到传入元素在集合中最后一次出现的位置索引,从集合尾部开始查找
  • lastIndexOf(E e, int index); 得到传入元素在集合中出现的位置索引,从集合index开始往前查找
  • Object clone(); 返回集合的clone,集合的元素没有被clone
  • Object[] toArray(); 转换成数组,此处返回的是数组的copy
  • T[] toArray(T a[]); 转换成数组,如果传入数组小于当前集合,重新申请一块空间,否则使用数组a,当数组a大于集合长度时将数组a的临近集合元素的第一个元素设置成null,可以方便用户在知道集合不含null元素时判断集合的大小
  • E get(int index); 获取集合的index索引元素
  • E set(int index, E element); 设置集合的index元素的值
  • boolean add(E e); 往集合中添加元素
  • void add(int index, E element); 插入元素至指定位置
  • E remove(int index); 移除指定位置的元素
  • boolean remove(Object o); 移除第一次出现元素o
  • void removeRange(int fromIndex, int toIndex); 移除范围内的所有元素
  • boolean addIfAbsent(E e); 当集合中不包含该元素时,添加该元素
  • boolean addIfAbsent(E e, Object[] snapshot); 当集合中不包含该元素且传入数组中也不包含该元素时,添加该元素
  • boolean containsAll(Collection<?> c); 判断集合是否全部包含传入集合的元素
  • boolean removeAll(Collection<?> c); 移除集合中c中所有元素
  • boolean retainAll(Collection<?> c); 移除集合中所有不在c中的元素
  • int addAllAbsent(Collection<?extends E> c); 遍历c,当c中元素不在集合中时,加入至集合
  • void clear(); 清空集合
  • boolean addAll(Collection<? extends E> c); 将集合c中所有元素加入至集合中
  • boolean addAll(int index, Collection<? extends E> c); 将集合c中所有元素插入至index后

2.7、Stack

Stack继承自Vector,他表示一种后进先出的数据结构,即栈。他拥有五种基本的操作即push、pop、peek、empty、search
Stack继承自Vector,所以它也是线程安全的
Stack继承自Vector,所以它内部也是用数组存储元素的

Stack自定义函数如下

  • E push(E item); 向栈顶添加一个元素
  • E pop(); 从栈顶取出并删除一个元素
  • E peek(); 得到栈顶元素
  • boolean empty(); 判断栈是否为空
  • int search(Object o); 查找o的位置,存在返回距栈顶位置,否则返回-1
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/linpeng123l/article/details/52366228
个人分类: java基础
上一篇java 集合1--接口及父类介绍
下一篇java任意进制转换
想对作者说点什么? 我来说一句

JAVA 经典算法书集合(1)

2011年06月27日 10.57MB 下载

java集合与映射(牛)

2009年04月28日 3KB 下载

java集合框架图

2011年10月18日 313KB 下载

java 文件管理集合

2010年07月11日 6KB 下载

java集合API

2007年11月05日 204KB 下载

java集合思维导图

2017年08月07日 64KB 下载

JAVA应用实例集合

2011年12月03日 59KB 下载

没有更多推荐了,返回首页

关闭
关闭