java容器--List集合中的体系结构分析（一）

Collection

 |--List:元素之间有序，且可以重复。
   |--ArrayList: 使用数组存储的数据结构。增删慢，查询快。注意：此实现不是同步的
   |--LinkedList: 使用链表存储的数据结构。增删快，查询慢。
   |--Vector:  使用数组存储的数据结构。是同步到，访问速度较慢，被ArrayList所替代。
 |--Set:元素之间无序，不可以重复。

List集合提供的方法

增
 add(index,element)//在指定位置插入指定元素
 addAll(index,Collection)//指定位置插入集合
删
remove(int index)
          移除列表中指定位置的元素（可选操作）。
改
set(int index, E element)
          用指定元素替换列表中指定位置的元素（可选操作）。
查
iterator() 查找元素
listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
subList(int fromIndex, int toIndex)
          返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
          
          
List集合特有的迭代器：ListIterator迭代器。
---listIterator是Iterator的子类接口。可以允许程序员按照任意方向遍历数据、修改数据、添加数据。
---Iterator迭代器只能够向下遍历数据，删除数据。如果要修改数据会出现ConcurrentModificationException异常
ListIterator提供的方法：
    -->hasPrevious() 是否有前一个元素
    -->previous()获取前一个元素
    -->void remove()
          从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
    -->void set(E e)
          用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

    -->add()添加元素

import java.util.*;
public class ListDemo{
	public static void main(String []args){
		//List list = method_Add();
		//method_it(list);
		//sop(list);
		method_ArrayList();
	}
	public static void method_ArrayList(){
		ArrayList al = new ArrayList();
		sop(al.size());
	}
	public static List method_Add(){
		List list = new ArrayList();
		list.add("java1--->name");
		list.add("java2--->name");
		list.add("java3--->name");
		list.add(2,"java4--->name");  //在制定位置插入
		return list;
	}
	public static void method_it(List list){
		//通过iteraror遍历元素
		ListIterator li = list.listIterator();
		while(li.hasNext()){
			Object obj = li.next();
			if(obj.equals("java3--->name"))
				li.add("i love xy");
			sop(obj);
		}
		while(li.hasPrevious()){
				Object obj1 = li.previous();
				sop("逆序--"+obj1);
		}
		/**此处会抛出ConcurrentModificationException异常
		Iterator it = list.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			if(obj.equals("java3--->name")){
				list.add("i love xuYan");
			}
			sop(obj);
		}**/
		
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

 ArrayList和Vector的异同：

  1、相同点：两者都是使用数组存储的数据结构。
  2、不同点：
             2.1 ArrayList是1.1版本以后出现的，其执行效率高于Vector。
             2.2 Vector是线程同步的，ArrayList是线程不同步的。
             2.3 ArrayList和Vector默认初始容量是10，扩充容量时，ArrayList以50%扩充，而Vector以100%扩充。
             2.4 Vector支持枚举类型。ArrayList不支持枚举。
枚举(Enumeration)其实和迭代器(Iterator)类似。
不过在1.1版本以后，Iterator中的方法名比较短，代替了枚举的方法。

import java.util.*;
public class VectorDemo{
	public static void main(String args[]){
		Vector v = new Vector();
		v.add("hello");
		v.add("world");
		v.add("hi");
		v.add("java");
		Enumeration en = v.elements();  //获取枚举类型的数据
		while(en.hasMoreElements()){
			System.out.println("遍历枚举类型的数据："en.nextElement());
		}
	}
}

LinkedList提供的方法：

JDK1.6以后提供的方法
增
  offerFirst(E e)
          在此列表的开头插入指定的元素。
  offerLast(E e)
          在此列表末尾插入指定的元素。
删
  pollFirst()
          获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
  pollLast()
          获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

改
  set(int index, E element)
          将此列表中指定位置的元素替换为指定的元素。
查
  peekFirst()
          获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
  peekLast()
          获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

import java.util.*;
public class LinkedListDemo{
	public static void main(String args[]){
		LinkedList ll = new LinkedList();
		ll.offerFirst("java1");
		ll.offerFirst("java2");
		ll.offerFirst("java3");
		ll.offerFirst("java4");
		sop(ll);
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

练习：在LinkedList的基础上封装一个自己使用的堆栈和队列的数据结构
堆栈特征--->先进后出
队列特征--->先进先出

import java.util.*;
class DuiLie{
	LinkedList link;
	public DuiLie(){
		link = new LinkedList();
	}
	/*
	添加队列中的数据。
	*/
	public void myAdd(Object obj){
		link.offerFirst(obj);
	}
	/*
	获取队列中的数据。以link链表中的最后一个数据取出
	*/
	public Object myGet(){
		return link.pollLast();
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
class Zhan{
	LinkedList link;
	public Zhan(){
		link = new LinkedList();
	}
	/*
	添加队列中的数据。
	*/
	public void myAdd(Object obj){
		link.offerFirst(obj);
	}
	/*
	获取队列中的数据。以link链表中的最后一个数据取出
	*/
	public Object myGet(){
		return link.pollFirst();
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
public class LinkedListDemo{
	public static void main(String args[]){
		Zhan dl = new Zhan();
		dl.myAdd("java1");
		dl.myAdd("java2");
		dl.myAdd("java3");
		dl.myAdd("java4");
		while(!dl.isNull()){
			sop(dl.myGet());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

练习：去除ArrayList中的相同对象元素。即：姓名和年龄相同的
    步骤：
    1、构造Person类，定义姓名、年龄两个属性，重写equals方法。
    2、将Person对象存储到ArrayList集合中。
    3、将对象一个个的取出。

   4、定义一个新的集合，将就集合中的数据放入新集合，在此之前先判断新集合中是否存在该数据。

import java.util.*;
class Person{
	private String name ;
	private int age;
	public Person(){
		
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	public String getName(){
		return this.name;
	}
	//因为要比较的是Person类中的name和age值，所以重写Object类的equals方法，
	public boolean equals(Object obj){
		//如果传入的对象不是Person类，直接返回false
		if(!(obj instanceof Person))
			return false;
		//否则强转成Person类
		Person p = (Person)obj;  
		//返回name和age的比较值。
		return this.name.equals(p.getName()) && this.age == p.getAge();
	}
}
public class ArrayListDemo{
	public static void main(String args[]){
		ArrayList al = new ArrayList();
		//Person p = new Person();
		al.add(new Person("lzl",18));
		al.add(new Person("lzl1",18));
		al.add(new Person("lzl2",18));
		al.add(new Person("lzl3",18));
		al.add(new Person("lzl",18));
		al = sigleElements(al);
		Iterator it = al.iterator();
		while(it.hasNext()){
			Person p = (Person)it.next();
			sop(p.getName()+"---"+p.getAge());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
	/*
		去除相同的元素
	*/
	public static ArrayList sigleElements(ArrayList al){
		ArrayList newAl = new ArrayList();
		Iterator it = al.iterator();
		while((it.hasNext())){
			Object obj = it.next();
			//如果新链表中不存在P对象的元素，则添加。
			if(!newAl.contains(obj)){
				sop("---");
				newAl.add(obj);
			}
		}
		return newAl;
	}
}