JAVA--List集合详解

 

目录

List集合常用共有方法

增

删

改

查

ArrayList

例：去除ArrayList中的重复元素

例：去除ArrayList中的重复对象元素

LinkedList

特有方法

在JDK1.6出现了上述方法的替代方法

使用LinkedList模拟仿写堆栈与队列数据结构

Vector

Vector特有取出方式：枚举

---

特点：元素是有序的，元素可以重复，因为该体系中有索引。

特有方法：凡是可以操作索引（角标）的方法都是该体系特有的方法。

List集合常用共有方法

增

void add(int index, E element)：在集合指定位置插入指定元素

boolean addAll(int index, Collection<? extends E> c)：在集合指定位置插入指定集合中所有元素。

删

E remove(int index)：删除集合中指定位置上的元素。

改

E set(int index, E element)：用指定元素替换集合中指定位置上的元素。

查

E get(int index)：返回集合中指定位置上的元素。

List<E> subList(int fromIndex, int toIndex)：返回集合中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分集合。 

ListIterator<E> listIterator()：返回此集合元素的迭代器。

int indexOf(Object o)：返回此集合中第一次出现的指定元素的索引位置；如果此列表不包含该元素，则返回 -1。   

扩展：

List集合特有的迭代器：ListIterator，ListIterator是Iterator的子接口。

 

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException（并发修改异常）。

所以，在使用迭代器时，只能使用迭代器的方法操作元素，可是Iterator中方法是有限的，只能对元素进行判断、取出、删除的操作。

如果想要其他的操作，比如添加、修改等，就需要使用其子接口：ListIterator，该接口只能通过List集合的listIterator（）方法获取。

ArrayList

底层是数组数据结构。

特点：查询速度很快，但是增删稍慢，线程不同步。

例：去除ArrayList中的重复元素

import java.util.*;
/*去除ArrayList集合中的重复元素*/
class ArrayListTest{
	public static void main(String[] args){
		
		ArrayList a1=new ArrayList();
		
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java02");
		a1.add("java04");
		a1.add("java04");
		
		/*
		// 在迭代时循环中next()调用一次，就要hasNext()判断一次
		Iterator it=a1.iterator();
		while(it.hasNext()){
			sop(it.next()+"……"+it.next());	// 这种写法不可以
		}*/
		
		sop("原集合:"+a1);
		
		sop("不会重复的集合："+singleElement(a1));
	}
	
	public static ArrayList singleElement(ArrayList al){
		
		// 定义一个临时容器存储不会重复的集合元素
		ArrayList newAl=new ArrayList();
		
		Iterator it=al.iterator();
		
		while(it.hasNext()){
			Object obj=it.next();
			// 原集合不会重复的元素才会存储到新集合中，保证新集合不会出现重复元素
			if(!newAl.contains(obj)){
				newAl.add(obj);
			}
		}
		return newAl;
	}
	
	// 打印方法
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

例：去除ArrayList中的重复对象元素

目标：

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

例：存储人对象，同姓名同年龄，即视为同一个人，为重复元素。

思路：

1.对人描述，将数据封装进人对象。

2.定义容器，将人存入。

3.取出。

     List集合判断元素是否包含或相同，依据的是元素的equals()方法。

     List集合删除元素，依据的也是元素的equals()方法。

class ArrayListTest2{
	public static void main(String[] args){
		ArrayList a1=new ArrayList();
		a1.add(new Person("lisi01",30));	// => Object obj=new Person("lisi01",30);
		a1.add(new Person("lisi02",32));
		a1.add(new Person("lisi03",33));
		a1.add(new Person("lisi03",33));
		a1.add(new Person("lisi04",35));
		a1.add(new Person("lisi04",35));
		
		a1=singleElement(a1);	// 去除重复元素
		
		// sop("remove 03:"+a1.remove(new Person("lisi03",33)));	// 删除也依据元素的equals()方法
		
		Iterator it=a1.iterator();
		
		while(it.hasNext()){
			Person p=(Person)it.next();
			sop(p.getName()+"……"+p.getAge());
		}
		
	}
	
	public static ArrayList singleElement(ArrayList al){
		
		// 定义一个临时容器存储不会重复的集合元素
		ArrayList newAl=new ArrayList();
		
		Iterator it=al.iterator();
		
		while(it.hasNext()){
			Object obj=it.next();
			// 原集合不会重复的元素才会存储到新集合中，保证新集合不会出现重复元素
			if(!newAl.contains(obj)){
				newAl.add(obj);
			}
		}
		return newAl;
	}
	
	// 打印方法
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

class Person{
	private String name;
	private int age;
	
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	// 按照需求重写类的equals()方法
	public boolean equals(Object obj){
		// 判断传入的对象是否为Person实例
		if(!(obj instanceof Person))
			return false;
		// 向下转型
		Person p=(Person)obj;
		// System.out.println(this.name+"……"+p.name);	// 元素中的比较过程
		// 返回比较结果
		return this.name.equals(p.name) && this.age==p.age;
		
	}
	
	public String getName(){
		return name;
	}
	
	public int getAge(){
		return age;
	}
}

LinkedList

底层是链表数据结构。

特点：增删速度很快，但是查询稍慢，线程不同步。

特有方法

增

void addFirst(E e)：将指定元素插入此列表的开头。

void addLast (E e)：将指定元素添加到此列表的结尾。

查

E getFirst()：返回此列表的第一个元素。

E getLast()：返回此列表的最后一个元素。

获取元素，但是不删除元素，如果集合中没有元素，会出现NoSuchElementException（没有该元素异常）

删

E removeFirst()：移除并返回此列表的第一个元素。

E removeLast()：移除并返回此列表的最后一个元素。

获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementException（没有该元素异常）

在JDK1.6出现了上述方法的替代方法

增

boolean offerFirst(E e)：在此列表的开头插入指定的元素。

boolean offerLast(E e)：在此列表末尾插入指定的元素。

查

E peekFirst()：获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

E peekLast()：获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

获取元素，但是不删除元素，如果集合中没有元素，会返回null

删

E pollFirst()：获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

E pollLast()：获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

获取元素，但是元素被删除，如果集合中没有元素，会返回null

使用LinkedList模拟仿写堆栈与队列数据结构

堆栈：先进后出 First in Last out FILO 如同一个杯子。

队列：先进先出 First in First out FIFO 如同一个水管。

class DuiLie{
	
	private LinkedList link;
	
	DuiLie(){
		link=new LinkedList();
	}
	
	// 添加
	public void myAdd(Object obj){
		link.addFirst(obj);
	}
	
	// 获取
	public Object myGet(){
		// return link.removeLast();	// 先进先出--队列
		return link.removeFirst();	// 先进后出--堆栈
	}
	
	// 判断是否为空
	public boolean isNull(){
		return link.isEmpty();
	}
	
}

class LinkedListDemo2{
	
	public static void main(String[] args){
		DuiLie dl=new DuiLie();
		dl.myAdd("java01");
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");
		
		while(!dl.isNull()){
			sop(dl.myGet());
		}
	}
	
	// 打印方法
	public static void sop(Object obj){
		System.out.println(obj);
	}
	
}

Vector

底层是数组数据结构。

特点：查询速度很快，但是增删稍慢，线程同步。被ArrayList替代了。

Vector特有取出方式：枚举

枚举就是Vector特有的取出方式，枚举和迭代器很像，其实枚举和迭代器是一样的。

因为枚举的名称以及相关方法的名称都过长，所以就被迭代器取代了。

class VectorDemo{
	public static void main(String[] args){
		Vector v=new Vector();
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		
		Enumeration en=v.elements();	// 返回此向量的组件的枚举,类似于迭代器
		while(en.hasMoreElements()){	// 类似迭代器hasNext()
			sop(en.nextElement());		// 类似迭代器next()
		}
		
		/*Iterator i=v.iterator();
		while(i.hasNext()){
			sop(i.next());
		}*/
	}
	
	// 打印方法
	public static void sop(Object obj){
		System.out.println(obj);
	}
}