Java笔记——List下的ArrayList 和 Vector

ArrayList和Vector的区别

初始大小和超过容量时扩容

public class ArrayListAndVector {
	/*
	 * ArrayList 和 Vector 的比较
	 * jdk8.0 中
	 * 1.ArrayList 初始容量为0，加入元素后为10，以后每次在现在容量的基础上添加0.5倍
	 *  Vector 初始容量为10，以后每次在现在容量的基础上添加1倍
	 * 	总结：在存储上ArrayList占用内存更少
	 * 2.ArrayList 线程上是不安全的，Vector是安全的（即在多线程时，只有一个线程能使用该Vector），所以ArrayList存取速度更快
	 */
	
	public static void main(String[] args) throws Exception {
		ArrayList<Object> arrayList = new ArrayList<Object>();
		Vector<Object> vector = new Vector<Object>();
		for (int i = 0; i < 50; i++) {
			print(arrayList);
			arrayList.add(i);
			print(vector);
			// Vector 的  int capacity() 也可以获取当前向量的容量
			vector.add(i);
		}	// 得出结论1
	}
	
	@SuppressWarnings("rawtypes")
	static void print(List list) throws Exception {
		Class c = list.getClass();
		Field elementDataField = c.getDeclaredField("elementData");
		elementDataField.setAccessible(true);
		Object[] arr = (Object[]) elementDataField.get(list);
		System.out.println(c + ".length = " + arr.length);
	}
}

部分代码来源

构造方法

// ArrayList
// 新建一个初始容量为0的ArrayList
ArrayList<Object> arrayList1 = new ArrayList<>();
// 新建一个初始容量为10的ArrayList
ArrayList<Object> arrayList2 = new ArrayList<>(10);
// 新建一个ArrayList，并在里面添加一个集合
ArrayList<Object> arrayList3 = new ArrayList<>(list);

// Vector
// 新建一个初始容量为10的Vector
Vector<Object> vector1 = new Vector<>();
// 新建一个初始容量为15的Vector
Vector<Object> vector2 = new Vector<>(15);
// 新建一个初始容量为20，且每次超出容量时间增长2
Vector<Object> vector3 = new Vector<>(20, 2);
// 新建一个Vector，并在里面添加一个集合
Vector<Object> vector4 = new Vector<>(list);

ArrayList的常用方法

遍历打印ArrayList元素

		String[] strings = new String[] {"first", "second", "third", "fourth"};
		List<String> list = Arrays.asList(strings);
		ArrayList<Object> arrayList = new ArrayList<>(list);
		
		// 使用遍历打印ArrayList元素(4种)
		// 第一种：迭代器遍历
		System.out.println("迭代器遍历：");
		Iterator<Object> iterator = arrayList.iterator();
		while (iterator.hasNext()) {
			System.out.print(iterator.next() + ",");
		}
		System.out.println();
		
		// 第二种：通过索引遍历
		System.out.println("通过索引遍历：");
		for (int i = 0; i < arrayList.size(); i++) {
			System.out.print(arrayList.get(i) + ",");
		}
		System.out.println();
		
		
		// 第三种：for循环遍历
		System.out.println("for循环遍历：");
		for (Object object : arrayList) {
			System.out.print(object + ",");
		}
		System.out.println();
		
		// 第四种：forEach遍历
		System.out.println("forEach遍历：");
		arrayList.forEach(object -> System.out.print(object + ","));
		System.out.println();

添加删除元素

		System.out.println("ArrayList 添加元素方法：");
		// 在指定位置添加元素
		arrayList.add(0, "first element");	// void add(int index, Object element)
		System.out.println("在0号位添加‘first element’：" + arrayList);
		// 在末尾添加元素
		arrayList.add("second element");	// boolean add(Object o)
		System.out.println("在末尾添加‘second element’：" + arrayList);
		// 在指定位置添加集合
		arrayList.addAll(1, list);			// boolean addAll(int index, Collection<? extends E> c)
		System.out.println("在1号位添加list：" + arrayList);
		// 在末尾添加集合
		arrayList.addAll(list);				// boolean addAll(Collection<? extends E> c)
		System.out.println("在末尾添加list：" + arrayList);
		
		
		System.out.println();
		System.out.println("ArrayList 删除元素方法：");
		// 删除指定位置的元素
		arrayList.remove(2);				// E remove(int index)
		System.out.println("删除2号位元素：" + arrayList);
		// 删除指定元素的第一个
		arrayList.remove("first");			// boolean remove(Object o)
		System.out.println("删除第一个‘first’位元素：" + arrayList);
		// 删除集合的元素
		arrayList.removeAll(list);			// boolean removeAll(Collection<?> c)
		System.out.println("删除list中含有的元素：" + arrayList);
		// 删除所有元素
		arrayList.clear();					// void clear()

ArrayList转化为数组的方法

		System.out.println("toArray的使用：");
        // 第一种
        Object[] objects = arrayList.toArray(new Object[0]);
        for (Object object : objects) {
			System.out.print(object + ",");
		}
		System.out.println();
        
        // 第二种
        Object[] objects2 = new Object[arrayList.size()];
        arrayList.toArray(objects2);
        for (Object object : objects2) {
			System.out.print(object + ",");
		}
		System.out.println();

其他方法（取元素、替换元素、排序、判断是否存在、是否为空等）

		// 其他方法
		// 复制，返回一个Object
		System.out.println("复制后生成的Object:" + arrayList.clone());
		
		// 获取元素
		System.out.println("arrayList的第二个元素是：" + arrayList.get(1));
		
		// 获取该元素第一次在ArrayList的位置
		System.out.println("第一个‘second’在arrayList的位置是：" + arrayList.indexOf("second"));		//没找到返回-1
		// 获取该元素最后一次在ArrayList的位置
		System.out.println("最后一个‘second’在arrayList的位置是：" + arrayList.lastIndexOf("second"));	//没找到返回-1
		
		// 仅保留ArrayList中包含在指定集合中的元素
		arrayList.retainAll(list);
		System.out.println("仅保留list中有的元素后：" + arrayList);
		
		// 替换指定位置的元素
		arrayList.set(1, "2");
		System.out.println("替换1号位元素为‘2’后：" + arrayList);
		
		// 获取ArrayList有多少个元素
		System.out.println("ArrayList有" + arrayList.size() + "个元素");
		
		// 按照一定规则排序
		arrayList.sort(new Comparator<Object>() {
			public int compare(Object o1, Object o2) {
				return (o1.toString().charAt(0) - o2.toString().charAt(0));  
			};
		});
		System.out.println("排序后：" + arrayList);
		
		// 判断ArrayList里是否有某个元素
		System.out.println("arrayList里面是否含有'first'：" + arrayList.contains("first"));
		
		// 判断ArrayList是否为空
		System.out.println("arrayList是否为空：" + arrayList.isEmpty());
		
		//返回ArrayList(int start[包括], int stop)的List -->类似于Python的切片
		System.out.println("截取0~2的ArrayList元素：" + arrayList.subList(0, 2));
		
		//修改ArrayList实例的容量是列表的当前大小
		arrayList.trimToSize();

Vector常用方法

遍历打印Vector元素

		Vector<Object> vector = new Vector<>(list);
		
		// 使用遍历打印Vector元素(4种)
		// 第一种：迭代器遍历
		System.out.println("迭代器遍历：");
		Iterator<Object> iterator1 = vector.iterator();
		while (iterator1.hasNext()) {
			System.out.print(iterator1.next() + ",");
		}
		System.out.println();
		
		// 第二种：通过索引遍历
		System.out.println("通过索引遍历：");
		for (int i = 0; i < vector.size(); i++) {
			System.out.print(vector.get(i) + ",");
		}
		System.out.println();
		
		
		// 第三种：for循环遍历
		System.out.println("for循环遍历：");
		for (Object object : vector) {
			System.out.print(object + ",");
		}
		System.out.println();

		// 第四种：forEach遍历
		System.out.println("forEach遍历：");
		vector.forEach(object -> System.out.print(object + ","));
		System.out.println();
		

添加删除插入元素

		System.out.println("Vector 添加元素方法：");
		// 在指定位置添加元素
		vector.add(0, "first element");	// void add(int index, Object element) 
		System.out.println("在0号位添加‘first element’：" + vector);
		// 在末尾添加元素(不同在于是否有返回值)
		vector.add("second element");	// boolean add(Object o)
		System.out.println("在末尾添加‘second element’：" + vector);
		vector.addElement("addElement");// void addElement(Object obj)
		System.out.println("用addElement方法：" + vector);
		// 在指定位置添加集合
		vector.addAll(1, list);			// boolean addAll(int index, Collection<? extends E> c)
		System.out.println("在1号位添加list：" + vector);
		// 在末尾添加集合
		vector.addAll(list);				// boolean addAll(Collection<? extends E> c)
		System.out.println("在末尾添加list：" + vector);
		
		System.out.println();
		System.out.println("Vector 插入元素方法：");
		vector.insertElementAt("这是插入的元素", 1);
		System.out.println("在1号位插入元素：" + vector);
		
		System.out.println();
		System.out.println("vector 删除元素方法：");
		// 删除指定位置的元素(不同在于是否有返回值)
		vector.remove(2);				// E remove(int index)
		vector.removeElementAt(2);		// void removeElementAt(int index)
		System.out.println("删除2号位元素：" + vector);
		// 删除指定元素的第一个(没有区别)
		vector.remove("first");			// boolean remove(Object o)
		vector.removeElement("first");	// boolean removeElement(Object obj) 
		System.out.println("删除第一个‘first’位元素：" + vector);
		// 删除集合的元素
		vector.removeAll(list);			// boolean removeAll(Collection<?> c)
		System.out.println("删除list中含有的元素：" + vector);
		// 删除所有元素(没有区别)
		vector.clear();					// void clear()
		vector.removeAllElements();		// void removeAllElements()

Vector转化为数组的方法

		// toArray Vector转化为数组的方法
		System.out.println("toArray的使用：");
        // 第一种
        Object[] objects3 = arrayList.toArray(new Object[0]);
        for (Object object : objects3) {
			System.out.print(object + ",");
		}
		System.out.println();
        
        // 第二种
        Object[] objects4 = new Object[arrayList.size()];
        arrayList.toArray(objects4);
        for (Object object : objects4) {
			System.out.print(object + ",");
		}
		System.out.println();

其他方法(取元素、替换元素、索引等)

		// 其他方法
		// 返回容量
		vector.capacity();	// void addElement(Object obj)
		
		// 获取元素
		vector.get(1);		// Object get(int index)
		vector.elementAt(1);	// Object elementAt(int index)
		
		// 获取第一个、最后一个元素
		vector.firstElement();	// Object firstElement()
		vector.lastElement();	// Object lastElement()
		
		// 获取元素个数
		vector.size();		// int size()
		
		// 设置Vector的大小
		vector.setSize(10);	// void setSize(int newSize)
		
		// 返回元素的索引,第一次,找不到返回-1
		vector.indexOf("first");
		// 返回元素的索引,第一次,从index开始找,找不到返回-1
		vector.indexOf("first", 2);
		// 返回元素的索引,最后一次
		vector.lastIndexOf("last");
		// 返回元素的索引,最后一次,从index开始找,找不到返回-1
		vector.lastIndexOf("last", 2);
		
		// 替换元素(区别在于返回值)
		vector.set(1, "这是一号位");			// Object set(int index, Object element)
		vector.setElementAt("这是一号位", 1);	// void setElementAt(Object obj, int index)
		
		// 判断包含关系
		vector.contains("first");		// boolean contains(Object elem)
		vector.containsAll(list);		// boolean containsAll(Collection<?> c)
		
		// 比较指定对象与此向量的相等性
		vector.equals(new Vector<>());	// boolean equals(Object o)
		
		// 仅保留集合内元素
		vector.retainAll(list);		// boolean retainAll(Collection<?> c)
		
		// 返回vector一部分，类似于Python的切片
		vector.subList(2, 3);	// List<E> subList(int fromIndex, int toIndex)
		
		// 返回一个复制值 Object
		vector.clone();		// Object clone()
		
		// 将此向量的元素复制到指定的数组中（类似于toArray(Object obj)）
		vector.copyInto(new Object[0]);
		
		// 返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式
		vector.toString();			// String toString()
		
		// 判断是否为空
		vector.isEmpty();			// boolean isEmpty()
		
		// 调整容量为当前元素大小
		vector.trimToSize();		// void trimToSize()