Collection-List-Vector集合

最新推荐文章于 2024-06-04 19:55:16 发布
最新推荐文章于 2024-06-04 19:55:16 发布
阅读量293 收藏 1
点赞数
分类专栏： # Java全栈开发学习 文章标签： list java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eternity_time/article/details/125948033
版权

文章目录

Collection

1.单列集合框架结构

在这里插入图片描述
|----Collection接口：单列集合，用来存储一个一个的对象

  • |----List接口：存储有序的、可重复的数据。 -->“动态”数组

  • |----ArrayList、LinkedList、Vector

  • |----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”

  • |----HashSet、LinkedHashSet、TreeSet

2.Collection接口常用方法：

1）添加
add(Object obj):添加元素
addAll(Collection c):添加集合元素
2）删除
clear():清空
remove(Object obj):删除元素
removeAll(Collection c):删除集合元素
3）判断
isEmpty():是否为空
contains(Object obj):是否包含某个元素
containsAll(Collection c):是否包含指定集合元素
4）获取
size():集合大小
Iterator iterator():获取迭代器对象
5）其它功能
Object[] toArray():集合转数组
retainAll(Collection c):两个集合交集操作

3.Collection集合与数组间的转换

//集合 —>数组：toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}

//拓展：数组 —>集合:调用Arrays类的静态方法asList(T … t)
List list = Arrays.asList(new String[]{“AA”, “BB”, “CC”});
System.out.println(list);

List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1.size());//1

List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2

4.使用Collection集合存储对象，要求对象所属的类满足：

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().

5.遍历Collection的两种方式：

① 使用迭代器Iterator ② foreach循环（或增强for循环）

2.java.utils包下定义的迭代器接口：Iterator
2.1说明：
Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。
2.2作用：遍历集合Collectiton元素
2.3如何获取实例：coll.iterator()返回一个迭代器实例
2.4图示说明：
2.5remove方法的使用

3.jdk5.0新特性–增强for循环：(foreach循环)
简化数组或者集合的遍历
格式：
for(元素的数据类型 变量名:数组名或集合名){
}

4、可变参数
定义方法的时候不知道参数的个数
格式
修饰符 返回值类型 方法名(数据类型… 变量名){
方法体;
}
说明：变量名是所参数构成的一个数组的名称
注意：如果既可变参数，又其它参数，需要将可变参数放在最后面

要求：

层次一：选择合适的集合类去实现数据的保存，调用其内部的相关方法。

层次二：不同的集合类底层的数据结构为何？如何实现数据的操作的：增删改查等。

List

1. 存储的数据特点：存储有序的、可重复的数据。

按顺序存放元素，元素可以重复(可以存放null值)
实现类:
ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级 (线程安全、使用少)

2. 常用方法：(记住)

增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()`
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环

  int size()//返回集合的长度
  boolean isEmpty();//集合是否为空
  boolean contains(Object o);//如果此列表包含指定的元素，则返回 true。
  boolean add(E e);//增加元素
  boolean remove(Object o);//删除元素
  E get(int index);//获得指定位置上的元素
  int indexOf(Object o);//返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回 -1
  Iterator<E> iterator()//返回一个迭代器

3. 常用实现类：

|----Collection接口：单列集合，用来存储一个一个的对象
|----List接口：存储序的、可重复的数据。 -->“动态”数组,替换原的数组
|----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
|----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储 |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

4. 源码分析(难点)

4.3 Vector

底层结构是数组，查询快,增删慢；底层安全，效率低
jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
在扩容方面，默认扩容为原来的数组长度的2倍。
特有功能：
addElement(E obj):添加元素
E elementAt(int index):指定索引位置处对应的元素值
Enumeration elements():获取集合所元素构成的一个枚举对象
Enumeration里面方法
hasMoreElements():是否更多元素
nextElement():获取下个元素

Vector类实现了一个可增长的对象数组，像数组一样包含可以使用整数索引访问的组件，大小可以根据需要增加或缩小，以适应在创建 Vector 后添加和删除
每个向量都试图通过维护 capacity 和 capacityIncrement 增量来优化存储管理，capacity 总是至少与向量大小一样大；通常更大，因为随着组件被添加到向量中，向量的存储以 capacityIncrement 增量大小的块的形式增加
该类的 iterator 和 listIterator 方法返回的 iterator 是快速失败的：如果在创建迭代器后的任何时间对向量进行结构修改，除了通过迭代器自己的remove或add方法外，迭代器将抛出 ConcurrentModificationException。因此，面对并发修改，迭代器快速而干净地失败，而不是冒着在未来不确定的时间出现任意、非确定性行为的风险。elements方法返回的Enumerations 不是快速失败的
从 Java 2 平台 v1.2 开始，该类经过改造以实现List接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Vector是同步的、线程安全的。如果不需要线程安全的实现，建议使用ArrayList代替Vector
成员变量
    // 存储向量组件的数组缓冲区
	protected Object[] elementData;
	// Vector对象中有效组件的数量
    protected int elementCount;
   	// 当向量的大小大于其容量时，向量的容量自动增加的量
    protected int capacityIncrement;
构造函数定义
方法作用
Vector()构造一个空向量，使其内部数据数组的大小为 10 ，标准容量增量为零
Vector(int initialCapacity)构造具有指定初始容量并且其容量增量等于零的空向量
Vector(int initialCapacity, int capacityIncrement)构造具有指定的初始容量和容量增量的空向量
Vector(Collection<? extends E> c)构造一个包含指定集合元素的向量，按照集合的迭代器返回的顺序
详解
    /**
	 * 无参构造
	 */
	public Vector() {
        // 调用Vector(int initialCapacity)，初始容量 initialCapacity 默认为 10
        this(10);
    }
    
	/**
	 * 具有指定初始容量的构造器，增量等于零的空向量
	 */
	public Vector(int initialCapacity) {
        // 调用 Vector(int initialCapacity, int capacityIncrement)，初始容量为10，增量为0
        this(initialCapacity, 0);
    }
	
	/**
	 * 具有指定的初始容量和容量增量的空向量构造器
	 */
	public Vector(int initialCapacity, int capacityIncrement) {
        super();
        // 如果初始容量小于0，抛出IllegalArgumentException
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        // 向量数组缓冲区为 initialCapacity 长度的Object数组
        this.elementData = new Object[initialCapacity];
        // 增量为0
        this.capacityIncrement = capacityIncrement;
    }

	/**
	 * 构造一个包含指定集合元素的向量，按照集合的迭代器返回的顺序
	 */
	public Vector(Collection<? extends E> c) {
        // 向量数组缓冲区为指定对象转为数组
        elementData = c.toArray();
        // 有效元素数量为向量数组缓冲区的长度
        elementCount = elementData.length;
        // 如果向量数组缓冲区类对象不等于Object数组类对象
        if (elementData.getClass() != Object[].class)
        	// 调用本地函数拷贝数组
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }
方法定义
方法作用
添加boolean add(E e)将指定的元素追加到此Vector的末尾
void add(int index, E element)在此Vector中的指定位置插入指定的元素
boolean addAll(Collection<? extends E> c)将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序
boolean addAll(int index, Collection<? extends E> c)将指定集合中的所有元素插入到此向量中的指定位置
void addElement(E obj)将指定的组件添加到此向量的末尾，将其大小增加1
void insertElementAt(E obj, int index)在指定的index插入指定对象作为该向量中的一个 index
修改E set(int index, E element) 用指定的元素替换此Vector中指定位置的元素
void setElementAt(E obj, int index) 设置在指定的组件 index此向量的要指定的对象
void replaceAll(UnaryOperator operator) 将该列表的每个元素替换为将该运算符应用于该元素的结果
void setSize(int newSize) 设置此向量的大小
void trimToSize() 修改该向量的容量成为向量的当前大小
查询int size()返回此向量中的组件数
int capacity() 返回此向量的当前容量
boolean contains(Object o) 如果此向量包含指定的元素，则返回 true
boolean containsAll(Collection<?> c) 如果此向量包含指定集合中的所有元素，则返回true
boolean equals(Object o) 将指定的对象与此向量进行比较以获得相等性
E elementAt(int index) 返回指定索引处的组件
Enumeration elements() 返回此向量的组件的枚举
E firstElement() 返回此向量的第一个组件（索引号为 0的项目）
E get(int index) 返回此向量中指定位置的元素
int hashCode() 返回此Vector的哈希码值
int indexOf(Object o) 返回此向量中指定元素的第一次出现的索引，如果此向量不包含元素，则返回-1
int indexOf(Object o, int index) 返回此向量中指定元素的第一次出现的索引，从 index向前 index ，如果未找到该元素，则返回-1
int lastIndexOf(Object o) 返回此向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则返回-1
int lastIndexOf(Object o, int index) 返回此向量中指定元素的最后一次出现的索引，从 index ，如果未找到元素，则返回-1
E lastElement() 返回向量的最后一个组件
boolean isEmpty() 测试此矢量是否没有组件
List subList(int fromIndex, int toIndex) 返回此列表之间的fromIndex（包括）和toIndex之间的独占视图
删除void clear() 从此Vector中删除所有元素
E remove(int index) 删除此向量中指定位置的元素
boolean remove(Object o) 删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改
boolean removeAll(Collection<?> c) 从此Vector中删除指定集合中包含的所有元素
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之间的元素
boolean retainAll(Collection<?> c) 仅保留此向量中包含在指定集合中的元素
扩容void ensureCapacity(int minCapacity) 如果需要，增加此向量的容量，以确保它可以至少保存最小容量参数指定的组件数
克隆Object clone()返回此向量的克隆
迭代器Iterator iterator()以正确的顺序返回该列表中的元素的迭代器
ListIterator listIterator()返回列表中的列表迭代器
ListIterator listIterator(int index)从列表中的指定位置开始，返回列表中的元素的列表迭代器
Spliterator spliterator()在此列表中的元素上创建late-binding和故障切换 Spliterator
循环void forEach(Consumer<? super E> action) 对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常
复制到数组void copyInto(Object[] anArray)将此向量的组件复制到指定的数组中
转数组Object[] toArray()以正确的顺序返回一个包含此Vector中所有元素的数组
T[] toArray(T[] a)以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型
转stringString toString()返回此Vector的字符串表示形式，其中包含每个元素的String表示形式
排序void sort(Comparator<? super E> c)使用提供的 Comparator对此列表进行排序以比较元素
ensureCapacity(int minCapacity) 扩容详解
	/**
	 * 扩容
	 * 增加此向量的容量，确保它可以至少保存最小容量参数指定的元素
	 */
	public synchronized void ensureCapacity(int minCapacity) {
        // 如果参数大于0
        if (minCapacity > 0) {
            modCount++;
            // 确保容量
            ensureCapacityHelper(minCapacity);
        }
    }
    
	/**
	 * 确保容量
	 */
    private void ensureCapacityHelper(int minCapacity) {
        // 如果参数减去向量数组缓冲区长度大于0
        if (minCapacity - elementData.length > 0)
        	// 增长容量
            grow(minCapacity);
    }
    
    /**
     * 扩容
     */
    private void grow(int minCapacity) {
        // 获取当前向量数组缓冲区长度（旧容量）
        int oldCapacity = elementData.length;
        // 如果增量大于0，新容量 为 旧容量 + 增量
        // 如果增量小于等于0，新容量 为 旧容量 + 旧容量
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        // 如果新容量 - minCapacity 小于0
        if (newCapacity - minCapacity < 0)
        	// 新容量为 minCapacity
            newCapacity = minCapacity;
        // 如果新容量 - 2147483639 大于0
        if (newCapacity - MAX_ARRAY_SIZE > 0)
        	// 获取大容量
            newCapacity = hugeCapacity(minCapacity);
        // 复制数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
	/**
	 * 大容量
	 */
    private static int hugeCapacity(int minCapacity) {
        // 如果参数小于0，throw OutOfMemoryError
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        // 如果 minCapacity 大于 21474836339，返回 21474836347
        // 如果 minCapacity 小于 21474836339，返回 21474836339
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
copyInto(Object[] anArray)详解
	/**
	 * 将此向量的元素复制到指定的数组中
	 */
	public synchronized void copyInto(Object[] anArray) {
        // 调用本地函数copy数组
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }
trimToSize() 详解
/**

  * 修改该向量的容量成为向量的当前大小
    */
    public synchronized void trimToSize() {
      modCount++;
      // 获取向量数组缓冲区当前长度
      int oldCapacity = elementData.length;
      // 如果有效元素数量 < 向量数组缓冲区当前长度
      if (elementCount < oldCapacity) {
      	// 复制数组
          elementData = Arrays.copyOf(elementData, elementCount);
      }
    }
setSize(int newSize) 详解
设置向量的大小
*/
public synchronized void setSize(int newSize) {
  modCount++;
  // 如果新大小 大于 有效元素数量
  if (newSize > elementCount) {
  	// 确认容量，判断是否调用 grow 方法
      ensureCapacityHelper(newSize);
  } else {
  	// 循环置空元素
      for (int i = newSize ; i < elementCount ; i++) {
          elementData[i] = null;
      }
  }
  // 设置有效元素数量为 newSize
  elementCount = newSize;
}
capacity()、size()、isEmpty() 详解
/**

  * 获取向量数组缓冲区当前长度
    */
    public synchronized int capacity() {
      return elementData.length;
    }

	/**
	 * 获取有效元素数量
	 */
	public synchronized int size() {
	    return elementCount;
	}
	
	/**
	 * 判断是否为null
	 */
	public synchronized boolean isEmpty() {
	    return elementCount == 0;
	}
elements() 详解
/**

  * 返回此向量的组件的枚举
    */
    public Enumeration<E> elements() {
      return new Enumeration<E>() {
          int count = 0;
          // 是否包含更多元素
          public boolean hasMoreElements() {
              // 返回 0是否小于有效元素数量
              return count < elementCount;
          }
          // 如果此枚举对象至少有一个要提供的元素，则返回此枚举的下一个元素
          public E nextElement() {
              synchronized (Vector.this) {
              	// 0小于有效元素数量
                  if (count < elementCount) {
                      // 返回下标为count的元素，之后count+1
                      return elementData(count++);
                  }
              }
              throw new NoSuchElementException("Vector Enumeration");
          }
      };
    }
get(int index)、elementData(int index)详解
/**

  * 根据下标获取元素
    */
    public synchronized E get(int index) {
      // 如果下标大于等于有效元素数量，throw ArrayIndexOutOfBoundsException
      if (index >= elementCount)
          throw new ArrayIndexOutOfBoundsException(index);
      // 调用elementData(int index)
      return elementData(index);
    }

	/**
	 * 根据下标获取元素
	 */
	E elementData(int index) {
	    // 返回index所在对象
	    return (E) elementData[index];
	}
set(int index, E element)、setElementAt(E obj, int index) 详解
/**

  * 用指定的元素替换此Vector中指定位置的元素，并返回旧值
    */
    public synchronized E set(int index, E element) {
      // 如果下标大于等于有效元素数量，throw ArrayIndexOutOfBoundsException
      if (index >= elementCount)
          throw new ArrayIndexOutOfBoundsException(index);
      // 获取index所在元素
      E oldValue = elementData(index);
      // 赋值新元素
      elementData[index] = element;
      // 返回旧元素
      return oldValue;
    }

	/**
	 * 用指定的元素替换此Vector中指定位置的元素
	 */
	public synchronized void setElementAt(E obj, int index) {
	    // 如果下标大于等于有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index >= elementCount) {
	        throw new ArrayIndexOutOfBoundsException(index + " >= " +
	                                                 elementCount);
	    }
	    // 赋值
	    elementData[index] = obj;
	}
add(E e)、add(int index, E element)、insertElementAt(E obj, int index)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c) 详解
/**

  * 将指定的元素追加到此Vector的末尾
    */
    public synchronized boolean add(E e) {
      modCount++;
      // 判断有效元素数量+1-向量数组缓冲区长度是否大于0，是否增长
      ensureCapacityHelper(elementCount + 1);
      // 根据下标赋值
      elementData[elementCount++] = e;
      return true;
    }

	/**
	 * 指定位置插入指定的元素
	 */
	public void add(int index, E element) {
	    // 调用 insertElementAt(E obj, int index)
	    insertElementAt(element, index);
	}
	
	/**
	 * 指定位置插入指定的元素
	 */
	public synchronized void insertElementAt(E obj, int index) {
	    modCount++;
	    // 如果下标大于有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index > elementCount) {
	        throw new ArrayIndexOutOfBoundsException(index
	                                                 + " > " + elementCount);
	    }
	    // 判断有效元素数量+1-向量数组缓冲区长度是否大于0，是否增长
	    ensureCapacityHelper(elementCount + 1);
	    // 拷贝数组
	    System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
	    // 赋值
	    elementData[index] = obj;
	    // 有效元素数量增长
	    elementCount++;
	}
	
	/**
	 * 将指定集合中的所有元素追加到该向量的末尾
	 */
	public synchronized boolean addAll(Collection<? extends E> c) {
	    modCount++;
	    // 将参数集合转数组
	    Object[] a = c.toArray();
	    // 获取数组长度
	    int numNew = a.length;
	    // 判断有效元素数量 + 数组长度 - 向量数组缓冲区长度是否大于0，是否增长
	    ensureCapacityHelper(elementCount + numNew);
	    // 拷贝数组
	    System.arraycopy(a, 0, elementData, elementCount, numNew);
	    // 有效元素数量增长 numNew 大小
	    elementCount += numNew;
	    return numNew != 0;
	}
	
	/**
	 * 将指定集合中的所有元素插入到此向量中的指定位置
	 */
	public synchronized boolean addAll(int index, Collection<? extends E> c) {
	    modCount++;
	    // 如果 index 小于 0 或者 大于 有效元素数量 
	    if (index < 0 || index > elementCount)
	        throw new ArrayIndexOutOfBoundsException(index);
	    // 将参数集合转数组
	    Object[] a = c.toArray();
	    // 获取数组长度
	    int numNew = a.length;
	    // 判断有效元素数量 + 数组长度 - 向量数组缓冲区长度是否大于0，是否增长
	    ensureCapacityHelper(elementCount + numNew);
	    // 偏移量 = 有效元素数量 - index
	    int numMoved = elementCount - index;
	    // 偏移量大于0
	    if (numMoved > 0)
	        System.arraycopy(elementData, index, elementData, index + numNew,
	                         numMoved);
	    // 偏移量小于或等于0
	    System.arraycopy(a, 0, elementData, index, numNew);
	    // 有效元素数量增长 numNew 大小
	    elementCount += numNew;
	    return numNew != 0;
	}
remove(Object o)、removeElement(Object obj)、removeElementAt(int index)、remove(int index)、removeAll(Collection<?> c) 详解
/**

  * 删除指定元素的第一个出现，如果Vector不包含元素
    */
    public boolean remove(Object o) {
      // 调用removeElement(Object obj)
      return removeElement(o);
    }

	/**
	 * 删除指定元素的第一个出现，如果Vector不包含元素
	 */
	public synchronized boolean removeElement(Object obj) {
	    modCount++;
	    // 获取指定元素第一次出现的索引
	    int i = indexOf(obj);
	    // 元素存在
	    if (i >= 0) {
	    	// 调用removeElementAt(int index)
	        removeElementAt(i);
	        return true;
	    }
	    // 元素不存在
	    return false;
	}
	
	/**
	 * 根据下标删除元素
	 */
	public synchronized void removeElementAt(int index) {
	    modCount++;
	    // 如果index 大于等于 有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index >= elementCount) {
	        throw new ArrayIndexOutOfBoundsException(index + " >= " +
	                                                 elementCount);
	    }
	    // 如果index 小于 0，throw ArrayIndexOutOfBoundsException
	    else if (index < 0) {
	        throw new ArrayIndexOutOfBoundsException(index);
	    }
	    // j 等于 有效元素数量减index减1
	    int j = elementCount - index - 1;
	    //j 大于0，复制数组
	    if (j > 0) {
	        System.arraycopy(elementData, index + 1, elementData, index, j);
	    }
	    // 有效元素数量-1
	    elementCount--;
	    // 末尾置空
	    elementData[elementCount] = null;
	}
	
	/**
	 * 删除指定位置的元素，并返回
	 */
	public synchronized E remove(int index) {
	    modCount++;
	    // 如果index 大于等于 有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index >= elementCount)
	        throw new ArrayIndexOutOfBoundsException(index);
	    // 获取下标指向元素
	    E oldValue = elementData(index);
	    // 偏移量 等于 有效元素数量减index减1
	    int numMoved = elementCount - index - 1;
	    // 偏移量大于0
	    if (numMoved > 0)
	        System.arraycopy(elementData, index+1, elementData, index,
	                         numMoved);
	    // 末尾置空
	    elementData[--elementCount] = null;
	    // 返回原值
	    return oldValue;
	}
	
	/**
	 * 删除指定集合中包含的所有元素
	 */
	public synchronized boolean removeAll(Collection<?> c) {
	    // 调用父类removeAll(Collection<?> c)
	    return super.removeAll(c);
	}
	
	/**
	 * 父类removeAll(Collection<?> c)
	 */
	public boolean removeAll(Collection<?> c) {
	    // 判断是否为null
	    Objects.requireNonNull(c);
	    boolean modified = false;
	    // 获取迭代器
	    Iterator<?> it = iterator();
	    // 循环删除
	    while (it.hasNext()) {
	    	// 指定集合包含下一个元素，删除
	        if (c.contains(it.next())) {
	            it.remove();
	            modified = true;
	        }
	    }
	    return modified;
	}
clear()、removeAllElements() 详解
/**

  * 删除所有元素
    */
    public void clear() {
      // 调用removeAllElements()
      removeAllElements();
    }

	/**
	 * 删除所有元素
	 */
	public synchronized void removeAllElements() {
	    modCount++;
	    // 循环置空
	    for (int i = 0; i < elementCount; i++)
	        elementData[i] = null;
	    // 有效元素数量置为0
	    elementCount = 0;
	}
indexOf(Object o)、indexOf(Object o, int index) 详解
/**

  * 返回指定元素第一次出现的索引，如果不包含此元素，则返回-1
    */
    public int indexOf(Object o) {
      // 调用indexOf(Object o, int index)
      return indexOf(o, 0);
    }

    /**
     * 返回指定元素第一次出现的索引，如果不包含此元素，则返回-1
     */
    public synchronized int indexOf(Object o, int index) {
        // 指定元素为null
        if (o == null) {
            // 循环
            for (int i = index ; i < elementCount ; i++)
                // 下标为i的元素等于null
                if (elementData[i]==null)
                	// 返回下标
                    return i;
        // 指定元素不为null
        } else {
            for (int i = index ; i < elementCount ; i++)
                // 指定元素等于下标为i的元素
                if (o.equals(elementData[i]))
                	// 返回下标
                    return i;
        }
        // 不包含此元素，则返回-1
        return -1;
    }
contains(Object o)、containsAll(Collection<?> c) 详解
/**

  * 是否包含指定元素
    */
    public boolean contains(Object o) {
      // 如果元素所在下标大于等于0，存在
      return indexOf(o, 0) >= 0;
    }

	/**
	 * 是否包含指定集合中的所有元素
	 */
	public synchronized boolean containsAll(Collection<?> c) {
	    return super.containsAll(c);
	}
	/**
	 * 父类 containsAll(Collection<?> c)
	 */
	public boolean containsAll(Collection<?> c) {
	    // 循环判断是否包含
	    for (Object e : c)
	        if (!contains(e))
	            return false;
	    return true;
	}
retainAll(Collection<?> c) 详解
/**

  * 保留包含在指定集合中的元素
    */
    public synchronized boolean retainAll(Collection<?> c) {
      return super.retainAll(c);
    }
    	/**
  * 父类retainAll(Collection<?> c)
    */
    public boolean retainAll(Collection<?> c) {
      // 判断是否为null
      Objects.requireNonNull(c);
      boolean modified = false;
      Iterator<E> it = iterator();
      while (it.hasNext()) {
          // 如果指定集合不包含
          if (!c.contains(it.next())) {
              // 移除
              it.remove();
              modified = true;
          }
      }
      return modified;
    }
equals(Object o) 详解
/**

  * 判断是否相等
    */
    public synchronized boolean equals(Object o) {
      return super.equals(o);
    }
    /**
  * 父类equals(Object obj)
    */
    public boolean equals(Object obj) {
        return (this == obj);
    }
hashCode() 详解
/**

  * 获取哈希码值
    */
    public synchronized int hashCode() {
      return super.hashCode();
    }
    /**
  * 父类hashCode()
    */
    public int hashCode() {
        int hashCode = 1;
        for (E e : this)
            hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        return hashCode;
    }
subList(int fromIndex, int toIndex) 详解
/**

  * 返回此列表fromIndex（包括）和toIndex之间的元素集合
    */
    public synchronized List<E> subList(int fromIndex, int toIndex) {
      return Collections.synchronizedList(super.subList(fromIndex, toIndex),this);
    }
replaceAll(UnaryOperator operator) 详解
/**

  * 将该列表的每个元素替换为将该运算符应用于该元素的结果
    */
    public synchronized void replaceAll(UnaryOperator<E> operator) {
      Objects.requireNonNull(operator);
      final int expectedModCount = modCount;
      final int size = elementCount;
      for (int i=0; modCount == expectedModCount && i < size; i++) {
      	// operator.apply()传入一个T类型参数，返回一个R类型对象
          elementData[i] = operator.apply((E) elementData[i]);
      }
      if (modCount != expectedModCount) {
          throw new ConcurrentModificationException();
      }
      modCount++;
    }
sort(Comparator<? super E> c) 详解
/**

  * 使用提供的 Comparator对此列表进行排序以比较元素
    */
    @SuppressWarnings("unchecked")
    @Override
    public synchronized void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        // 调用数组工具类，以指定条件排序
        Arrays.sort((E[]) elementData, 0, elementCount, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }
toArray()、toArray(T[] a) 详解
/**

  * 以正确的顺序返回一个包含此Vector中所有元素的数组
    */
    public synchronized Object[] toArray() {
      // 数组拷贝
      return Arrays.copyOf(elementData, elementCount);
    }

	/**
	 * 以正确的顺序返回一个包含此Vector中所有元素的数组; 
	 * 返回的数组的运行时类型是指定数组的运行时类型
	 */
	@SuppressWarnings("unchecked")
	public synchronized <T> T[] toArray(T[] a) {
	    // 如果a的长度 小于 有效元素数量
	    if (a.length < elementCount)
	        return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
	    // 数组拷贝
	    System.arraycopy(elementData, 0, a, 0, elementCount);
	    // 如果a的长度 大于 有效元素数量
	    if (a.length > elementCount)
	        // 末尾置空
	        a[elementCount] = null;
	    return a;
	}

可以发现 Vector 中所有方法都是由 synchronized 修饰

一堆大佬的学生
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JDK源码阅读5-util】Collection-List---Vector
noaman_wgs的博客
11-06 456
Vector实现类                                        public class Vector                                                                          extends AbstractList
JAVA集合工具类Collections及Vector
Fjtd_2019的博客
05-07 301
就像数组有工具类Arrays一样，JAVA也同样在util包中提供了一个供集合使用的工具类Collections。 Collections工具类包含了很多功能，这里就提两大块：排序以及查找、替换 首先说一下排序，包含如下几种： reverse（List）：反转List中元素的顺序 shuffle (List): 对List集合元素进行随机排序 sort（List）:根据元素的自然排序对指定List...
详解Collection中的Vector
Cxf2018的博客
10-28 375
一、Vector简介 java.util.vector提供了向量类（Vector）以实现类似动态数组的功能；创建一个向量类对象以后，可以随意插入不同类的对象，不用顾及类型也不用预先选定容量，并可以实现方便的查找。 适应场景：预先不知道或者不愿预先定义数组大小，并且需要频繁的查找，插入，删除的工作情况，可以考虑使用向量类。 向量类提供了三种构造方法： public vector() public vector(int initialcapacity,int capacityIncrement) pub
第十五节:集合框架一(讲师笔记)
fengbird的博客
10-08 354
15.01_集合框架(对象数组的概述和使用) A:案例演示 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。 Student[] arr = new Student[5]; //存储学生对象 arr[0] = new Student("张三", 23); arr[1] = new Student("李四"
java Collection-Vector
qq_41786692的博客
03-17 513
一、Vector的概念1.vector实现了一个可以自动增长的对象数组，类似于动态数组，能够动态的调整自身的大小，能够根据索引进行查询；2.vector继承了AbstractList，实现了List，是一个队列，实现了相应的增删改查等功能；3.vector实现了RnadomAccess接口，因此能够对数据进行随机访问；4.vector的操作是线程安全的，Vector中的大部分方法增加了ychron...
Java集合框架-Collection-List-vector(遗留类)
xiong_tai的博客
04-25 628
Vector类是单列集合List接口的一个实现类。与ArrayList类似，Vector也实现了一个可以动态修改的数组，两者最本质的区别在于——Vector类是支持线程同步的，因此它线程安全，支持多线程；而ArrayList是线程不同步的，线程不安全。Vector底层也是由一个Object类型的数组来实现的 (注意Vector维护的elementData数组没有用transient关键字修饰)
集合篇---List集合
weixin_42107106的博客
09-20 1442
List，ArrayList，Vector概述
Java集合框架图析（Collection-List）
weixin_45670060的博客
08-10 2412
Java集合框架图析 ##前言 Java 集合，也称作容器，主要是由两大接口 (Interface) 派生出来的：Collection 和 Map,顾名思义，容器就是用来存放数据的。那么这两大接口的不同之处在于： Collection 存放单一元素; Map 存放 key-value 键值对。 集合框架 Java集合里使用接口来定义功能，是一套完善的继承体系。Iterator是所有集合的总接口，其他所有接口都继承于它，该接口定义了集合的遍历操作，Collection接口继承于Iterator，是集合
scala-collection-benchmark:JMH Scala 集合基准
06-19
基准 Scala 集合 第一个结果： L - List V - Vector Q - Queue [info] # Run complete. Total time: 06:11:26 [info] [info] Benchmark (field) Mode Cnt Score Error Units [info] CollectionsBench.appendL 100 ...
java8源码-csn-list:ArrayList、LinkedList、Vector、Stack源码分析
06-04
机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。 通过modCount的值来判断是否多线程同时操作，modCount用来记录List修改的次数：每修改一次...
Java期末复习-类集框架
08-06
List接口、ArrayList类、Vector类、栈操作类Stack、链表操作类LinkList、队列操作接口Queue、Set接口、HashSet类、TreeSet类、SortedSet接口 双值操作接口Map(key->value)及其子接口、子类： SortedMap接口、HashMap...
Java中集合的使用
12-22
在使用Java的时候，我们都会遇到使用集合（Collection）的时候，但是Java API提供了多种集合的实现。 总的说来，Java API中所用的集合类，都是实现了Collection接口，他的一个类继承结构如下：  Collection<...
Java集合总结.txt
06-03
Collection -- 集合接口 List -- List接口（添加了许多针对下标操作的方法） 特点：有序的，且可重复 ArrayList: 数据结构：一维数组 LinkedList: 数据结构：双向链表 Vector: 数据结构：一...
java 迭代 vector_java-Collection集合、List集合、Vector集合和迭代器Iterator、ListIterator的使用...
weixin_32060671的博客
02-15 172
1、对象数组的概述和使用* A:案例演示* 需求：我有5个学生，请把这个5个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。*Student[] arr = new Student[5];//存储学生对象arr[0] = new Student("张三", 23);arr[1] = new Student("李四", 24);arr[2] = new Student("王五", 25)...
C++容器之前向链表(std::forward_list)
flysnow010的博客
05-30 811
前向列表是序列容器，允许在序列中的任何位置进行恒定时间的插入和擦除操作。前向列表被实现为单链表；单链表可以将它们所包含的每个元素存储在不同且不相关的存储位置。通过与序列中下一个元素的链接的每个元素的关联来保持排序。forward_list容器和list容器之间的主要设计区别在于，前者在内部只保留一个到下一个元素的链接，而后者为每个元素保留两个链接：一个指向下一个元件，一个指向前一个元件。这允许在两个方向上进行高效迭代，但每个元件消耗额外的存储空间，插入和删除元件的时间开销略高。
【Java数据结构】详解LinkedList与链表（二)
Easonmax的博客
06-01 906
所以对于这10个面试题我们就讲述清楚了，并且我还把其中的部分题目当作特殊方法加入到模拟的无头单向非循环链表类中。无头单向非循环链表的模拟实现和其具体使用(此外还往模拟的链表内部添加了一些特殊方法)下篇文章将给大家带来LinkedList的模拟实现和具体使用。让我们共同学习，共同进步，为知识的海洋增添更多宝贵的财富！
Day06 创建首页ListBox列表数据
最新发布
码侬人生
06-04 121
​ 完成当前章节后，最终效果图如下 ​​​​ 一.首页汇总方块鼠标悬停阴影效果设计 首先，在上一章节首页设计 的时候，就已经知道当前主界面的汇总方块是使用 Border 来实现的，那么想要实现鼠标悬停时设置阴影的效果，就要在 Border 中进行重写样式。 需要使用 触发器 来实现鼠标悬停时给 Border 设置阴影 的效果 所有的控件，触发器固定写法都差不多是这样，只需要通过 TargetType 来指定目标控件类型即可。例如：当前指定的控件类型是 Border <Border.Styl
0X JavaSE-- 集合框架【Collection（List、Set、Queue）、Map】
m0_46671240的博客
05-31 310
0X JavaSE-- 集合框架【Collection（List、Set、Queue）、Map】
C# WinForm —— 27 28 29 30 ListView 介绍与应用
ChanMon的博客
06-03 700
和ListBox的外观类似，都可以多列显示，但 ListView 功能更强大，提供了5种不同的显示方式。
|-集合 |-Collection接口，对象集合 |-List接口 |-ArrayList |-LinkedList |-Vector |-Stack |-Set接口 |-HashSet |-TreeSet |-Queue接口 |-Map接口，键值对集合 |-HashMap |-Hashtable |-Properties
02-06
ArrayList、LinkedList、Vector、Stack都是实现了List接口的类，它们都是有序的集合，可以使用下标访问元素。其中，ArrayList是实现了动态数组的列表，LinkedList是由链表实现的列表，Vector是线程安全的列表，Stack...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值