Java List 子类详解-优快云博客

本文详细介绍了 Java 中 List 接口的三个子类：ArrayList、Vector 和 LinkedList 的特点及应用场景，并提供了示例代码，同时讲解了如何在 ArrayList 中去除重复元素的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前面我们提到了list总共有三个子集合，分别是：ArrayList、Vector、LinkedList，这节我们就来具体的学习一下它们。

一、ArrayList

ArrayList是List接口中常用的一个子实现类

遍历功能:

1)一个是Collection的iterator()

2)size()和get(int index)普通for循环

需求：存储字符串并遍历元素

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(int x = 0 ; x < list.size() ; x ++) {
			String s = (String) list.get(x) ;
			System.out.println(s);
		}
		
	}
}

需求2：ArrayList集合存储自定义对象并遍历

学生类大家自己创建，这里就不再赘述。

测试类：

public class ArrayListDemo2 {
	
	public static void main(String[] args) {
		
		//创建集合对象
		ArrayList  array = new ArrayList();
		
		//创建学生对象
		Student s1 = new Student("鲁智深", 30) ;
		Student s2 = new Student("武松", 40) ;
		Student s3 = new Student("宋江", 50) ;
		Student s4 = new Student("杨志", 25) ;
		
		//添加
		array.add(s1) ;
		array.add(s2) ;
		array.add(s3) ;
		array.add(s4) ;
		
		//迭代器方式
		Iterator it = array.iterator() ;
		while(it.hasNext()) {
			Student s = (Student)it.next() ;
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
		System.out.println("--------------------");
		
		for(int x = 0 ; x <array.size() ; x ++) {
			Student s = (Student)array.get(x) ;
			System.out.println(s.getName()+"----"+s.getAge());
		}
	}
}

二、Vector

Vector集合
底层是一种可增长对象数组,查询快,增删慢
线程安全,同步,执行效率低

特有功能:
public void addElement(Object obj)------->add(Object obj)
public Enumeration elements():返回此向量的枚举--->相当于:public Iterator iterator()
boolean hasMoreElements() --->boolean hasNext() ;

Object nextElement() --->Object next() ;

public class VectorDemo {
	
	public static void main(String[] args) {
		
		//创建集合对象
		Vector v = new Vector() ;
		
		//添加元素
		v.addElement("hello"); 
		v.addElement("world");
		v.addElement("java");
		
		//遍历
		//获取Enumeration :向量的枚举
		Enumeration en = v.elements() ;
		while(en.hasMoreElements()) {
			String s = (String)en.nextElement() ;
			System.out.println(s);
		}
	}
}

三、LinkedList

LinkedList集合的特点:
底层是一种链表实现,查询慢,增删快
线程不安全的,不同步,执行效率高

特有功能:
添加功能
addFirst(Object e):将指定的元素插入到列表的开头
addLast(object e):将指定的元素添加到列表末尾
获取功能:
getFirst():获取列表第一个元素
getLast():获取列表第二个元素
删除功能
public Object removeFirst()移除并返回此列表的第一个元素。

public Object removeLast()

public class LinkedListDemo {
	
	public static void main(String[] args) {
		
		//创建LinkedList集合对象
		LinkedList link = new LinkedList() ;
		
		//添加元素
		link.add("hello"); 
		link.add("world"); 
		link.add("java"); 
		System.out.println("link:"+link);
		
		//addFirst(Object e):将指定的元素插入到列表的开头
		link.addFirst("android");
		System.out.println("link:"+link);
		//addLast(object e):将指定的元素添加到列表末尾
		link.addLast("mysql");
		System.out.println(link);
		
		//getFirst():获取列表第一个元素
		System.out.println(link.getFirst());
		//getLast():获取列表末尾的元素
		System.out.println(link.getLast());
		
		//public Object removeFirst()移除并返回此列表的第一个元素。 
		System.out.println("removeFirst():"+link.removeFirst());
		System.out.println(link);
		//public Object removeLast()
		System.out.println(link.removeLast());
	}
}

在添加元素时发现：

public class LinkedListDemo {
	
	public static void main(String[] args) {
		
		//创建linkedList集合对象
		LinkedList link = new LinkedList() ;
		
		//添加元素
		//符合栈结构的特点:先进后出
		link.addFirst("hello");
		link.addFirst("world");
		link.addFirst("java");
		
		Iterator it = link.iterator() ;
		while(it.hasNext()) {
			String s = (String)it.next();
			System.out.println("s:"+s);
		}
	}
}

运行结果：

s:java
s:world

s:hello

与栈的特点类似：先进后出

所以有如下需求：利用LinkedList模拟栈结构的特点,先进后出

分析：需要自定义一个类,在这个类中使用LinkedList集合的特有功能进行操作

自定义的栈集合类，在这个MyStack中使用LinkedList的特有功能：

public class MyStack {
	
	private LinkedList link ;
		
	/**
	 * 执行MyStack的无参构造实际是构造了个LinkedList对象
	 */
	public MyStack() {
		link = new LinkedList() ;
	}
	
	//添加元素
	public void add(Object obj) {
		link.addFirst(obj);
	}
	
	//获取元素
	public Object get() {
		return link.removeFirst() ;
	}
	
	//判断功能
	public boolean isEmpty() {
		return link.isEmpty();
	}
}

综合的测试类：

public class MyStackDemo {
	
	public static void main(String[] args) {
		
		//创建自定义的MyStack的栈集合的对象
		MyStack my = new MyStack() ;	//LinkedList list = new LinkedList();
		
		//添加元素
		my.add("hello");		//LinkedList ["java","world","hello"]
		my.add("world");
		my.add("java");
		
		//获取元素
		//System.out.println(my.get());
		//System.out.println(my.get());
		//System.out.println(my.get());
		//java.util.NoSuchElementException :已经没有元素了,但是还要对集合信息操作,就报这个异常
		//System.out.println(my.get());
		
		//想办法给MyStack这个类中提供一个判断功能
		
		while(!my.isEmpty()) {
			System.out.println(my.get());
		}
	}
}

由于之前没有加判断方法，获取元素时可能会出现java.util.NoSuchElementException这个异常：已经没有元素了,但是还要对集合信息操作，所以利用LinkedList的isEmpty方法来进行判断就会有效的避免。

四、集合中去除重复元素的方法

需求:给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉!

方式一：利用新集合

思路:
1)创建一个旧集合,添加重复元素
2)创建一个新集合
3)遍历旧集合中的元素获取到每一个元素
在旧集合中判断新集合中是否包含旧集合中的元素
包含,不处理
不包含,添加到新集合中

4)遍历新集合

public class ArrayListTest {
	
	public static void main(String[] args) {
		
		//创建一个集合
		ArrayList list = new ArrayList() ;
		
		//添加元素
		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("python") ;
		list.add("php") ;
		list.add("php") ;
		
		//创建一个新的集合
		ArrayList newList = new ArrayList() ;
		
		//遍历旧集合
		Iterator it = list.iterator() ;
		while(it.hasNext()) {
			String s = (String) it.next() ;
			
			//判断新集合中是否包含旧集合中的元素
			if(!newList.contains(s)) {
				newList.add(s) ;
			}
		}
		
		//遍历新集合
		Iterator it2 = newList.iterator() ;
		while(it2.hasNext()) {
			String s = (String) it2.next() ;
			System.out.println(s);
		}
	}
}

方式二：利用集合本身进行判断

思路：

引入选择排序,
用0索引对应的元素依次和后面索引对应的元素进行比较
如果前面的元素和后面的元素重复了,把后面元素删除掉（remove方法）

依次1索引....

public class ArrayListTest2 {
	
	public static void main(String[] args) {
		
		//创建ArrayList集合对象
		ArrayList  array = new ArrayList() ;
		
		//添加元素
		array.add("hello") ;
		array.add("world") ;
		array.add("java") ;
		array.add("javaee") ;
		array.add("hello") ;
		array.add("world") ;
		array.add("hello") ;
		array.add("javaee") ;
		//引入选择排序的思想
		for(int x = 0 ; x < array.size()-1 ; x ++) {
			for(int y = x +1 ; y < array.size() ; y ++) {
				//判断,前面的索引对应的元素和后面索引对应的元素进行比较,如果相等就干掉后面重复的
				if(array.get(x).equals(array.get(y))) {
					array.remove(y) ;
					y-- ;
				}
			}
		}
		
		//遍历集合
		Iterator it = array.iterator() ;
		while(it.hasNext()) {
			String s = (String) it.next() ;
			System.out.println(s);
		}
	}
}

需求：使用集合ArrayList存储自定义对象(Student),去除重复的对象(成员变量的值一样,看成一个人)

public class ArrayListTest3 {

	public static void main(String[] args) {
		
		//创建一个ArrayList集合
		ArrayList array = new ArrayList() ;
		
		//创建4个学锁对象
		Student s1 = new Student("高圆圆", 27);
		Student s2 = new Student("文章", 29);
		Student s3 = new Student("王力宏", 30);
		Student s4 = new Student("高圆圆", 27);
		Student s5 = new Student("高圆圆", 29);
		
		array.add(s1) ;
		array.add(s2) ;
		array.add(s3) ;
		array.add(s4) ;
		array.add(s5) ;
		
		//创建一个新集合
		ArrayList newArray = new ArrayList() ;
		
		//遍历旧集合
		Iterator it = array.iterator() ;
		while(it.hasNext()) {
			Student s = (Student)it.next() ;
			
			//判断,新集合中是否包含
			if(!newArray.contains(s)) {
				newArray.add(s) ;
			}
		}
		
		//遍历新集合
		Iterator it2 = newArray.iterator() ;
		while(it2.hasNext()) {
			Student s= (Student)it2.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

运行结果发现出现了问题，集合中并没有将重复元素进行删除，这是因为contains方法底层依赖于equals方法， equals方法默认比较的是地址值，如果想让equals()方法比较他们的内容是否相同,需要重写equals(),也就意味着存储自定义类,必须重写equals()方法,这样才能比较的是这些对象的内容是否相同，所以在Student类中重写equals方法后，问题解决。

Student类：

public class Student {
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}


	@Override
	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;
	}
}