黑马程序员 java基础之集合框架List

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

List的基类接口是Collection,List集合有三个常见子类ArrayList ,LinkedList, Vector；

ArrayList底层的数据结构式数组结构。特点在于查询速度很快，线程不同步。

Vector底层的数据结构式数组结构。线程时安全的，出现在jdk1.2版本，增删改查速度都很慢，已被ArrayList替代。

LinkedList的底层的数据结构式链表结构。增加，修改，删除元素的速度也是很快的。

List集合特点是：元素时有序的，同时元素是可以重复的，因为该集合体系时有索引。

List集合中的特有方法

void add(int index, Ojbect b) 向指定集合的位置中添加添加元素；

void addAll(int index,Collection c) 向集合中添加集合c

void remove(int index) 删除集合指定位置处的元素

E get(int index) 获取指定位置处的元素

int   indexOf(Object o) 返回集合中第一次出现该元素的索引下标

int  lastIndexOf(Object o) 返回集合中最后一次出现该元素的索引下标，如果集合中没有出现该元素，那么返回-1；

E  set(int index ,Object o) 用指定的元素替换集合指定位置的元素。

ListIterator listIterator() 返回集合中的一个迭代器。

通过上面的方法我们可以发现，List集合中都可以操作索引下标。

/*
List接口中特有的方法
增
add(int index ,Object obj)
addAll(Collection c)
删
remove(int index);
removeAll(Collection c)
改
set(int index,Object obj)
查
get(int index);
subList(int start,int from)
listIterator();

*/
import java.util.*;
class JavaCollection1_2 
{
	public static void main(String[] args) 
	{
		//创建list接口下的一个子类ArrayList对象。
		ArrayList al=new ArrayList();
		al.add("java_1");
		al.add("java_2");
		al.add("java_3");
		al.add("java_4");
		sop("原集合："+al);
		//1 在指定的位置添加元素
		al.add(1,"java_5");
		sop(al);
		// 2删除指定位置的元素。
		al.remove(3);
		sop(al);
		//3修改指定位置的元素。
		al.set(0,"java_10");
		sop(al);
		//4获取所有的元素
		//使用List集合的get()方法。使用角标进行遍历。
		for(int i=0;i<al.size();i++)
		{
			sop("al("+i+")="+al.get(i));
		}
		//5使用迭代器
		for(ListIterator lit=al.listIterator();lit.hasNext();)
		{
			sop(lit.next());
		}

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

List集合中Vector的特性用法：

import java.util.*;
/*
ArrayList，LinkedList不支持枚举，统一使用迭代器。
枚举就是Vector特有的取出方式。
枚举和迭代的方式是类似的。
因为枚举的方法名过长，因此被迭代器取代。
*/
class JavaCollection1_3 
{
	public static void main(String[] args) 
	{
		Vector v=new Vector();
		v.add("java_1");
		v.add("java_2");
		v.add("java_3");
		v.add("java_4");
		Enumeration e=v.elements();//使用枚举。
		while(e.hasMoreElements())
		{
			sop(e.nextElement());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

List集合中LinkedList的特性用法：

/*
LinkedList特有的方法：
addFirst();向头部添加元素
addLast();向尾部添加元素
getFirst();获取LinkedList集合中头部的元素 
getLast();获取LinkedList集合中尾部的元素
这里的getFirst()和getLast()方法都是获取元素，但是不删除元素。
removeFirst();
removeLast();
这里的removeFirst和removeLast方法也可以获取元素，但是元素也同时被删除了

注意事项；
使用上面的方法，如果集合中没有元素，那么就会抛出NoSuchElementException异常
在jdk1.6的版本中出现了替代了方法

offerFirst()
offerLast()

peekFirst()
peekLast()
--获取元素，但是不删除元素，如果集合中没有该元素，那么就会返回null,不会抛出异常

pollFirst()
pollLast()
--返回元素，并且也回删除元素，如果集合中没有该元素，那么也就返回Null，不会抛出异常
*/
import java.util.*;
class JavaCollection1_4 
{
	public static void main(String[] args) 
	{
		LinkedList ll=new LinkedList();
		ll.addFirst("java_1");
		ll.addFirst("java_2");
		ll.addFirst("java_3");
		ll.addFirst("java_4");
		sop(ll);
		sop(ll.getFirst());
		sop(ll.getLast());
		//sop(ll.removeFirst());
		//sop(ll.removeLast());
		//sop(ll);

		//不用迭代器使用removeFirst方法也可以取出LinkedList集合中的元素
		while(!ll.isEmpty())
		{
			sop(ll.removeFirst());
		}
		sop("**************************");
		method1();
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void method1()
	{
		LinkedList ll=new LinkedList();
		ll.offerFirst("java01");
		ll.offerFirst("java02");
		ll.offerLast("java03");
		ll.offerLast("java04");
		sop(ll);
		sop(ll.peekFirst());
		sop(ll.peekLast());
		sop(ll.pollFirst());
		sop(ll.pollLast());
		sop(ll);
	}
}

LinkedList练习：

/*
使用一个LinkedList来简单的模拟堆栈数据结构。
堆栈：先进后出
队列：先进先出
*/
import java.util.*;
class JavaCollection1_5 
{
	public static void main(String[] args) 
	{
		QueueDemo q=new QueueDemo();
		q.add("java_1");
		q.add("java_2");
		q.add("java_3");
		q.add("java_4");
		//sop(q.get());
		while(!q.Null())
		{
			sop(q.get());
		}

		StackDemo s=new StackDemo();
		s.add("java_1");
		s.add("java_2");
		s.add("java_3");
		s.add("java_4");
		while(!s.Null())
		{
			sop(s.get());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
/*模拟队列*/
class QueueDemo
{
	private LinkedList link;
	QueueDemo()
	{
		link=new LinkedList();
	}
	public void add(Object obj)
	{
		link.offerFirst(obj);
	}
	public Object get()
	{
		 return link.pollLast();
	}
	public boolean Null()
	{
		return link.isEmpty();
	}
}
/*模拟堆栈*/
class StackDemo
{
	private LinkedList link;
	StackDemo()
	{
		link=new LinkedList();
	}
	public void add(Object obj)
	{
		link.offerFirst(obj);
	}
	public Object get()
	{
		 return link.pollFirst();
	}
	public boolean Null()
	{
		return link.isEmpty();
	} 
}

ArrayList集合练习：

/*
去除ArrayList中重复的元素。
思路：
创建一个新的ArrayList，然后在遍历需要除重的老集合，然后在判断新集合中是否存在当前遍历的元素，如果不存在，就添加到新的集合中，如果存在，那么当前元素就不用添加到新集合中。
遍历结束后，那么新集合就是去重后的集合
*/
import java.util.*;
class JavaCollection1_6 
{
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		al.add(1);
		al.add(2);
		al.add(3);
		al.add(4);
		al.add(4);
		al.add(3);
		al.add(2);
		List list=getSingleArrayList(al);
		sop(list);
	}
	public static List getSingleArrayList(ArrayList al)
	{
		 ArrayList temp_al=new ArrayList();
		for(ListIterator it=al.listIterator();it.hasNext();)
		{
			Object obj=it.next();//注意在循环中it.next()只能使用一次，马上it.hasNext()判断一次，不然就有可能报异常。
		    if(!temp_al.contains(obj))//如果新集合中不存在该元素，那么便添加该元素。
			{
				temp_al.add(obj);
			}
		}
		return temp_al;
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}