Java基础-集合框架-Collection-List-Vector API及常用方法

Vector

Vector API

Modifier and Type	Method	Description
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。
int	capacity()	返回此向量的当前容量。
void	clear()	从此Vector中删除所有元素。
Object	clone()	返回此向量的克隆。
boolean	contains(Object o)	如果此向量包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c)	如果此向量包含指定集合中的所有元素，则返回true。
void	copyInto(Object[] anArray)	将此向量的组件复制到指定的数组中。
E	elementAt(int index)	返回指定索引处的组件。
Enumeration	elements()	返回此向量的组件的枚举。
void	ensureCapacity(int minCapacity)	如果需要，增加此向量的容量，以确保它可以至少保存最小容量参数指定的组件数。
boolean	equals(Object o)	将指定的对象与此向量进行比较以获得相等性。
E	firstElement()	返回此向量的第一个组件（索引号为 0的项目）。
void	forEach(Consumer<? super E> action)	对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
E	get(int index)	返回此向量中指定位置的元素。
int	hashCode()	返回此Vector的哈希码值。
int	indexOf(Object o)	返回此向量中指定元素的第一次出现的索引，如果此向量不包含元素，则返回-1。
int	indexOf(Object o, int index)	返回此向量中指定元素的第一次出现的索引，从 index向前 index ，如果未找到该元素，则返回-1。
void	insertElementAt(E obj, int index)	在指定的index插入指定对象作为该向量中的一个 index 。
boolean	isEmpty()	测试此矢量是否没有组件。
Iterator	iterator()	以正确的顺序返回该列表中的元素的迭代器。
E	lastElement()	返回向量的最后一个组件。
int	lastIndexOf(Object o)	返回此向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则返回-1。
int	lastIndexOf(Object o, int index)	返回此向量中指定元素的最后一次出现的索引，从 index ，如果未找到元素，则返回-1。
ListIterator	listIterator()	返回列表中的列表迭代器（按适当的顺序）。
ListIterator	listIterator(int index)	从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
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之间的元素。
void	replaceAll(UnaryOperator operator)	将该列表的每个元素替换为将该运算符应用于该元素的结果。
boolean	retainAll(Collection<?> c)	仅保留此向量中包含在指定集合中的元素。
E	set(int index, E element)	用指定的元素替换此Vector中指定位置的元素。
void	setElementAt(E obj, int index)	设置在指定的组件 index此向量的要指定的对象。
void	setSize(int newSize)	设置此向量的大小。
int	size()	返回此向量中的组件数。
void	sort(Comparator<? super E> c)	使用提供的 Comparator对此列表进行排序以比较元素。
Spliterator	spliterator()	在此列表中的元素上创建late-binding和故障切换 Spliterator 。
List	subList(int fromIndex, int toIndex)	返回此列表之间的fromIndex（包括）和toIndex之间的独占视图。
T[]	toArray(T[] a)	以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
void	trimToSize()	修改该向量的容量成为向量的当前大小。

Sample Code

package com.sijing.reflect_demo;

import java.util.Vector;

public class VectorDemo {

	public static void main(String[] args) {

		Vector<String> vecStr = new Vector<String>();

		Vector<String> vecNum = new Vector<String>();

		/**
		 * 列表末尾增加一个元素
		 */
		vecStr.add("A");

		/**
		 * 在指定位置增加一个元素
		 */
		vecStr.add(0, "A");

		/**
		 * 末尾增加一个列表中的所有元素
		 */
		vecStr.addAll(vecNum);

		/**
		 * 从指定位置增加一个列表中的所有元素
		 */
		vecStr.addAll(0, vecNum);

		/**
		 * 列表末尾增加一个元素
		 */
		vecStr.addElement("A");

		/**
		 * 返回当前列表的容量
		 */
		vecStr.capacity();

		/**
		 * 清除所有元素
		 */
		vecStr.clear();

		/**
		 * 浅复制
		 */
		vecStr.clone();

		/**
		 * 判断当前列表是否包含指定元素
		 */
		vecStr.contains("A");

		/**
		 * 判断当前列表是否包含另一列表的所有元素
		 */
		vecStr.containsAll(vecNum);

		/**
		 * 将列表中的元素复制到指定数组中
		 */
		String[] vecAry1 = new String[vecNum.size()];
		vecStr.copyInto(vecAry1);

		/**
		 * 返回指定位置的元素
		 */
		vecStr.elementAt(0);

		/**
		 * 返回此列表的枚举
		 */
		vecStr.elements();

		/**
		 * 增加该列表的容量至指定大小
		 */
		vecStr.ensureCapacity(1);


		/**
		 * 返回第一个元素
		 */
		vecStr.firstElement();

		/**
		 * 遍历列表
		 */
		vecStr.forEach(
				x -> {
					System.out.println(x);
				}
				);

		/**
		 * 获取指定位置元素
		 */
		vecStr.get(0);

		/**
		 * 获取指定元素第一次出现的位置
		 */
		vecStr.indexOf("A");

		/**
		 * 获取指定元素在某个位置后第一次出现的位置
		 */
		vecStr.indexOf("A", 1);

		/**
		 * 在指定位置插入一个元素
		 */
		vecStr.insertElementAt("0", 0);

		/**
		 * 返回最后一个元素
		 */
		vecStr.lastElement();

		/**
		 * 获取指定元素最后一次出现的位置
		 */
		vecStr.lastIndexOf("A");

		/**
		 * 获取指定元素在某个位置后最后一次出现的位置
		 */
		vecStr.lastIndexOf("A", 1);

		/**
		 * 判断列表是否为null
		 */
		vecStr.isEmpty();

		/**
		 * 返回此列表的迭代器
		 */
		vecStr.iterator();

		/**
		 * 返回此列表的高级迭代器
		 */
		vecStr.listIterator();

		/**
		 * 返回此列表的高级迭代器，从指定位置开始
		 */
		vecStr.listIterator(0);

		/**
		 * 移除指定位置的元素
		 */
		vecStr.remove(0);

		/**
		 * 移除指定元素
		 */
		vecStr.remove("A");

		/**
		 * 从此列表中移除另一个列表中包含的所有元素
		 */
		vecStr.removeAll(vecNum);

		/**
		 * 删除所有元素，并将容量设置为0
		 */
		vecStr.removeAllElements();

		/**
		 * 删除目标元素第一个相同元素
		 */
		vecStr.removeElement("A");

		/**
		 * 删除指定位置的元素
		 */
		vecStr.removeElementAt(0);

		/**
		 * 
		 */
		vecStr.removeIf(
				x -> x.equals("A")
				);

		/**
		 * 
		 */
		vecStr.replaceAll(
				str -> {
					if(str.equals("A")) {
						return "a";
					}else {
						return "B";
					}
				}
				);

		/**
		 * 只保留两个列表的共有元素
		 */
		vecStr.retainAll(vecNum);

		/**
		 * 替换指定位置的元素
		 */
		vecStr.set(0, "A");

		/**
		 * 设置指定位置元素
		 */
		vecStr.setElementAt("A", 0);

		/**
		 * 设置此列表的容量大小
		 */
		vecStr.setSize(1000);

		/**
		 * 返回此列表包含元素的数量
		 */
		vecStr.size();

		/**
		 * 
		 */
//		vecStr.sort(c);

		/**
		 *  Spliterator就是为了并行遍历元素而设计的一个迭代器，jdk1.8中的集合框架中的数据结构都默认实现了spliterator
		 */
		vecStr.spliterator();

		/**
		 * 截取列表
		 */
		vecStr.subList(0, 5);

		/**
		 * 列表 -> 数组
		 */
		String[] strAry = new String[vecStr.size()];
		strAry = vecStr.toArray(strAry);

	}

}