Java中List集合的三个子类ArrayList、Vector、LinkedList

区别

List集合和Set集合的区别

	ArrayList	Vector	LinkedList
底层结构	数组结构	数组结构	链表结构
空间占用	存储区间连续 占用空间大，空间复杂度大	存储区间连续 占用空间大，空间复杂度大	存储区间离散 占用宽松，空间复杂度小
特点	查询快，增删慢	查询块,增删慢	查询慢，增删块
安全性	不安全，不同步，效率高	安全的，同步的，效率低	不安全，不同步，效率高

ArrayList

底层通过数组的方式存储元素，不同步、不安全、效率高、查询快、增删慢。

使用的方法都是Collection集合和List集合里面继承的方法。

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo {

	public static void main(String[] args) {

		// 创建集合对象
		ArrayList list = new ArrayList();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// 遍历
		// 获取迭代器
		Iterator it = list.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			System.out.println(s);
		}
		System.out.println();
		// 普通for循环遍历
		for (int x = 0; x < list.size(); x++) {
			String s = (String) list.get(x);
			System.out.println(s);
		}

	}
}

构造方法

    ArrayList()

构造一个初始容量为十的空列表。根据需要自动增加容量。每次添加都会先检查是否需要扩容。

    ArrayList(int initialCapacity）

构造具有指定初始容量的空列表。

注意：

     对于底层实现方式为数组的如：ArrayList、StringBuffer、HashMap。在构造方法中都有指定容量创建对象的方法。

因为数组的空间复杂度高，占用空间大，增删困难。使用默认大小创建时候每次添加元素都会先检查是否需要扩容。

并且扩容占用资源高，如果事先知道容量的话优先使用指定容量的方式创建对象。

Vector

和ArrayList类似，也是通过数组实现元素的存储，长度可变，更安全，保证同步，效率低。

    特有方法

        void addElement(Object obj)

将指定的元素添加到此向量的末尾，相当于add(Object obj)

        Enumeration elements()

返回此向量的枚举，结合Enumeration接口使用，相当于迭代器。

        boolean hasMoreElements()

相当于迭代器里面的hasNext()。

        Object nextElement()

相当于next()方法。

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {

	public static void main(String[] args) {

		// 创建集合对象
		Vector<String> v = new Vector<String>();

		// 添加元素
		v.addElement("hello");
		v.addElement("world");
		v.addElement("java");

		// 遍历
		// 获取Enumeration :向量的枚举
		Enumeration<String> e = v.elements();
		while (e.hasMoreElements()) {
			String s = e.nextElement();
			System.out.println(s);
		}
	}
}
/***
hello
world
java
 */

LinkedList

底层通过链表实现、查询慢、增删快、不安全、不同步、执行效率高。

    特有方法

        添加功能

addFirst(Object e)

    将指定的元素插入到列表的开头

addLast(object e)

    将指定的元素添加到列表末尾

        获取功能

getFirst()

    获取列表第一个元素

getLast()

    获取列表最后一个元素

        删除功能

public Object removeFirst( )

    移除并返回此列表的第一个元素。     

public Object removeLast( )

    移除并返回此列表的最后一个元素。    

import java.util.LinkedList;

public class test {
	public static void main(String[] args) {
		LinkedList<String> li = new LinkedList<String>();
		li.add("java");
		li.add("word");
		li.add("hello");
		System.out.println(li);// [java, word, hello]
		// addFirst(Object e)将指定的元素插入到列表的开头
		li.addFirst("android");
		System.out.println(li);// [android, java, word, hello]
		// addLast(object e)将指定的元素添加到列表末尾
		li.addLast("google");
		System.out.println(li);// [android, java, word, hello, google]
		// getFirst():获取列表第一个元素
		System.out.println(li.getFirst());// android
		// getLast():获取列表最后一个元素
		System.out.println(li.getLast());// google
		// Object removeFirst()移除并返回此列表的第一个元素。
		System.out.println(li.removeFirst());// android
		System.out.println(li);// [java, word, hello, google]
		// Object removeLast()移除并返回此列表的最后一个元素。
		System.out.println(li.removeLast());// google
		System.out.println(li);// [java, word, hello]
	}
}

应用

    去除重复的元素

        通过一个新的集合来去重复

import java.util.ArrayList;
import java.util.Iterator;

public class test {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("javaee");
		list.add("hello");
		list.add("world");
		list.add("hello");
		list.add("javaee");
		list.add("android");
		list.add("php");
		list.add("php");
		// 通过一个新集合来去除重复
		ArrayList<String> nlist = new ArrayList<String>();
		Iterator<String> it = list.iterator();// 创建旧集合的迭代器
		while (it.hasNext()) {// 遍历旧集合
			String s = it.next();
			if (!nlist.contains(s)) {// 如果新集合中不包含该元素则添加该元素
				nlist.add(s);
			}
		}
		System.out.println(list);
		// [hello, world, java, javaee, hello, world, hello, javaee, android, php, php]
		System.out.println(nlist);
		// [hello, world, java, javaee, android, php]
	}
}

        利用选择排序的方式，不创建新集合

import java.util.ArrayList;

public class test {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("javaee");
		list.add("hello");
		list.add("world");
		list.add("hello");
		list.add("javaee");
		list.add("php");
		list.add("php");
		System.out.println(list);
		// [hello, world, java, javaee, hello, world, hello, javaee, php, php]
		for (int x = 0; x < list.size() - 1; x++) {
			// 抽取一个元素和后面的元素进行对比
			for (int y = x + 1; y < list.size(); y++) {
				// 从抽取元素的下一个元素开始依次和抽取的元素进行对比
				if (list.get(x).equals(list.get(y))) {// 如果抽取的元素和对比的元素相同则执行
					list.remove(y);// 删除重复的元素
					y--;// 删除一个元素后索引发生了变化，y也要向右移动一位
				}
			}
		}
		System.out.println(list);
		// [hello, world, java, javaee, php]
	}
}

        存储自定义对象的集合去除重复对象

import java.util.ArrayList;
import java.util.Iterator;

class Student {
	private String name;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getage() {
		return age;
	}

	public void setage(int age) {
		this.age = age;
	}

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	// contains方法底层依赖于equals方法，所以需要在自定义对象中重写equals方法，否则比较的是地址值。
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

}

public class test {
	public static void main(String[] args) {
		ArrayList<Student> list = new ArrayList<Student>();
		Student s1 = new Student("张三", 18);
		Student s2 = new Student("张三", 18);
		Student s3 = new Student("李四", 21);
		Student s4 = new Student("李四", 23);
		Student s5 = new Student("王五", 18);
		Student s6 = new Student("王五", 18);
		list.add(s1);
		list.add(s2);
		list.add(s3);
		list.add(s4);
		list.add(s5);
		list.add(s6);
		// 创建新集合
		ArrayList<Student> neli = new ArrayList<Student>();
		// 遍历旧集合
		Iterator<Student> it = list.iterator();
		while (it.hasNext()) {
			Student s = it.next();
			if (!neli.contains(s)) {// 如果新集合不包含该对象则添加该对象
				neli.add(s);
			}
		}
		// 遍历新集合
		Iterator<Student> nit = neli.iterator();
		while (nit.hasNext()) {
			Student s = nit.next();
			System.out.println(s.getName() + "---" + s.getage());
		}
	}
}
/**
张三---18
李四---21
李四---23
王五---18
 */