Java List 接口一共有三个实现类，分别是 Vector、ArrayList、LinkedList

List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。

三个具体实现类的相关区别如下：

1. Vector与ArrayList一样，也是通过数组实现的，不同的是Vector支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。

2. ArrayList是最常用的List实现类，内部是通过数组实现，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。

3. LinkedList是用链表结构存储数据，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

查看Java源代码，发现当数组的大小不够的时候，需要重新建立数组，然后将元素拷贝到新的数组内，ArrayList和Vector的扩展数组的大小不同。ArrayList默认大小是16，Vector默认大小是10

1. Vector

// Vector
public static void TestVector() {
	Vector<String> vector = new Vector<String>();
	vector.add("list11");
	vector.add("list22");
	vector.add("list44");
	vector.add("list33");
	System.out.println("TestVector - vector.size : " + vector.size());	// 4
	System.out.println("TestVector - vector : " + vector.toString());	// [list11, list22, list44, list33]
	
	vector.remove(0);			// 按索引移除元素
	vector.remove("list22");	// 按对象移除元素
	System.out.println("TestVector - vector.size2 : " + vector.size());	// 2
	System.out.println("TestVector - vector2 : " + vector.toString());	// [list44, list33]
}

2. ArrayList

// ArrayList
public static void TestArrayList() {
	List<String> list = new ArrayList<String>();
	list.add("list11");
	list.add("list22");
	list.add("list44");
	list.add("list33");
	System.out.println("TestArrayList - list.size : " + list.size());	// 4
	System.out.println("TestArrayList - list : " + list.toString());	// [list11, list22, list44, list33]
	
	list.remove(0);			// 按索引移除元素
	list.remove("list22");	// 按对象移除元素
	System.out.println("TestArrayList - list.size2 : " + list.size());	// 2
	System.out.println("TestArrayList - list2 : " + list.toString());	// [list44, list33]
}

3. LinkedList

// LinkedList
public static void TestLinkedList() {
	LinkedList<String> list = new LinkedList<String>();
	list.add("list11");
	list.add("list22");
	list.addFirst("list44");	// 在链表头插入元素
	list.addLast("list33");		// 在链表尾插入元素
	System.out.println("TestLinkedList - list.size : " + list.size());	// 4
	System.out.println("TestLinkedList - list : " + list.toString());	// [list44, list11, list22, list33]
	
	list.remove(0);			// 按索引移除元素
	list.remove("list22");	// 按对象移除元素
	System.out.println("TestLinkedList - list.size2 : " + list.size());	// 2
	System.out.println("TestLinkedList - list2 : " + list.toString());	// [list11, list33]
}

4. 数字排序

// numberSort
public static void TestNumSort() {
	List<Integer> list = new LinkedList<Integer>();
	list.add(2);
	list.add(5);
	list.add(1);
	list.add(3);
	list.add(4);
	Collections.sort(list);		// 默认升序
	System.out.println("TestNumSort -- list : " + list.toString());		// [1, 2, 3, 4, 5]

	// 函数降序
	Collections.sort(list, Collections.reverseOrder());		
	System.out.println("TestNumSort -- list2 : " + list.toString());	// [5, 4, 3, 2, 1]
	
	// 自定义降序
	Collections.sort(list, new Comparator<Integer>() {
		public int compare(Integer a, Integer b) {
			return b > a ? 1 : (b < a) ? -1 : 0;
		}
	});
	System.out.println("TestNumSort -- list3 : " + list.toString());	// [5, 4, 3, 2, 1]
}

5. 中文排序

// ChineseSort
public static void TestChineseSort() {
	List<String> list = new ArrayList<String>();
	list.add("米扑代理");
	list.add("米扑支付");
	list.add("米扑博客");
	list.add("米扑域名");
	list.add("米扑财富");
	Collections.sort(list);		// 直接采用默认排序函数，对中文是乱序的
	System.out.println("TestChineseSort -- list : " + list.toString());		// [米扑代理, 米扑博客, 米扑域名, 米扑支付, 米扑财富]
	
	Comparator<Object> cmp = Collator.getInstance(java.util.Locale.CHINESE);
	Collections.sort(list, cmp);
	System.out.println("TestChineseSort -- list2 : " + list.toString());	// [米扑博客, 米扑财富, 米扑代理, 米扑域名, 米扑支付]
}

6. 对象排序

// ObjectSort
public static void TestObjectSort() {
	List<User> list = new ArrayList<User>();
	list.add(new User("杨小欢", 20));
	list.add(new User("杨大亮", 20));
	
	Comparator<User> cmp = new ComparatorUser();
	Collections.sort(list, cmp);
	System.out.println("TestObjectSort -- list : " + list.toString());	// [杨大亮:20, 杨小欢:20]
}

对象类 User

class User {
	private String name;
	private Integer age;
	
	public User(String name, Integer age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return this.name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return this.age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return this.name + ":" + this.age;
	}
}

比较器类 ComparatorUser

class ComparatorUser implements Comparator<User> {
	@Override
	public int compare(User u1, User u2) {
		int result = u1.getAge().compareTo(u2.getAge());
		if(0 == result) {
			result = u1.getName().compareTo(u2.getName());
		}
		return result;
	}
}

7. List 遍历

// TestLoop
public static void TestLoop() {
	List<String> list = new ArrayList<String>();
	list.add("list11");
	list.add("list22");
	list.add("list44");
	list.add("list33");
	
	System.out.println("TestLoop - loop1 : ");
	for(String str : list) {
		System.out.println(str);
	}

	System.out.println("TestLoop - loop2 : ");
	for(int i=0; i<list.size(); i++) {
		System.out.println(list.get(i));
	}

	System.out.println("TestLoop - loop3 : ");
	Iterator<String> iterator = list.iterator();
	while(iterator.hasNext()) {
		System.out.println(iterator.next());
	}
}

8. List 移除

// TestRemove
public static void TestRemove() {
	List<String> list = new ArrayList<String>();
	list.add("list11");
	list.add("list22");
	list.add("list44");
	list.add("list33");
	
	List<String> list1 = new ArrayList<String>(list);
	for(String str : list1) {
		if("list44".equals(str)) {
			list1.remove(str);
		}
	}
	System.out.println("TestRemove - list1 : " + list1.toString());		// [list11, list22, list33]
	
	List<String> list2 = new ArrayList<String>(list);
	for(int i=list.size()-1; i>=0; i--) {
		if("list44".equals(list2.get(i))) {
			list2.remove(list2.get(i));
		}
	}
	System.out.println("TestRemove - list2 : " + list2.toString());		// [list11, list22, list33]
	
	List<String> list3 = new ArrayList<String>(list);
	Iterator<String> iterator = list3.iterator();
	while(iterator.hasNext()) {
		if("list44".equals(iterator.next())) {
			iterator.remove();
		}
	}
	System.out.println("TestRemove - list3 : " + list3.toString());		// [list11, list22, list33]
}

参考推荐：

Java 几种常见的比较器实现

Java 泛型中 ? 和 T 区别

Java 7种枚举用法