集合类 迭代器iterator List：ListIterator ArrayList Vector()elements LinkedList equals应用

集合类

 面向对象语言中，事物都是以对象的形式体现的，所以为了方便对象的操作，就要对对象进行存储，集合就是存储对象的最常见方法之一。

数组和集合类有何不同！

虽然数组和集合都是容器，都可以用于存储数据，但是

数组的长度是固定的，数组中可以存储基本数据类型。

集合长度是可变的，集合只能存放对象。

集合框架

因为java中有很多不同类型的集合，用于存储不同类型的对象。

当我们对着写集合进行共性抽取的时候，会产生一个体系，这个体系就是集合框架。

为什么会有这么多的容器？

因为每一个容器对数据的存储方式各有不同。

这个存储方式称之为：数据结构。

collection接口

|--List ：元素是有序的，元素可以重复，因为该集合体系有索引。

   |--ArrayList:底层的数据结构使用的是数组结构

   |--LinkedList

底层使用的链表数据结构

   |--Vector:

|--Set：元素是无序的，元素不可以重复。该集合当中没有索引。

   |--HashSet

   |--TreeSet

Collection集合中的共性方法：

1，add方法的参数类型是Object，以便于接受任意类型的对象。

2，集合中存储的都是对象的引用，就是地址。

add remove  clear

contains isEmpty    size

import java.util.*;
class  Test
{		
	public static void main(String[] args) 
	{	
		//创建一个集合容器，使用Collection接口的子类。ArrayList
		ArrayList al = new ArrayList();
		
		//1 添加元素
		al.add("java01");//add(Object obj)
		al.add("java02");
		al.add("java03");
		al.add("java04");
		
		//打印集合
		sop(al);	//[java01, java02, java03, java04]
		//2 获取个数，集合长度
		sop("size="+al.size());	//size=4
		
		//3删除元素
		al.remove("java02");
		sop(al);	//打印改编后的集合。 [java01, java03, java04]
		//al.clear(); // 清空集合。

		//4判断元素
		sop("java03是否存在:"+al.contains("java03"));
		//判断集合是否为空
		sop("集合是否为空："+al.isEmpty());

	}

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

retainAll 和 removeAll

a1.retainAll(a2);

取交集， a1 中只会保留和 a2 中相同的元素

a1.removeAll(a2);

a1 中只保留与 a2 不同的元素

import java.util.*;
class  Test
{		
	public static void main(String[] args) 
	{	
		ArrayList a1 = new ArrayList();
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");	

		ArrayList a2 = new ArrayList();
		a2.add("java01");
		a2.add("java02");
		a2.add("java05");
		a2.add("java06");

		a1.retainAll(a2); //取交集，a1中只会保留和a2中相同的元素
		sop(a1);	//[java01, java02]
		sop(a2);	//[java01, java02, java05, java06]
		
		a1.removeAll(a2);	//a1中只保留与a2不同的元素
		sop(a1);	//[java03, java04]
		sop(a2);	//[java01, java02, java05, java06]
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

迭代器   Iterator(接口)

举例子：电玩城的夹娃娃，夹娃娃机器有很多种，都是一个透明的箱子，里面放着不同的娃娃。就如同集合容器，不同的容器装着不同的内容。但每个夹娃娃的机器中，都有一个夹子，而且都是在透明箱子的内部。但是每种机器里的夹子也有不同，有2个抓的，有三个抓的，因为容器中的娃娃不同，也有所不同。但是，每个机器外面都有一个操纵杆，通过这个杆可以操控夹子，让架子前后移动，上下移动，看准后，按下操纵杆，去抓娃娃。迭代器就列斯这个操纵杆，每个集合容器中，都有自己的迭代器，根据容器内对象的不同，迭代器的实现也不同，但是都可以通过迭代器的接口去获取内容。

迭代器（iterator）其实就是集合的取出元素的方式。

就是把取出方式定义在集合的内部

这样取出方式就可以直接访问集合内容的元素

那么取出方式就被定义成了内部类

而每一个容器的数据结构不同，

所以取出的 动作细节也不一样。但是都是共性内容

判断  和  取出。那么可以将这些共性抽取。

那么这些内部类都符合一个规则。该规则是Iterator。

通过 iterator(); 提供外部访问方法。

hasNext（），判断集合中是否还有元素。有就返true，没有就返回false。

next（），取出集合中元素。

for循环结束，it1释放，节省内存
        for (Iterator it1 =a1.iterator();it1.hasNext() ;)
        {
                sop(it1.next());
        }

import java.util.*;
class  Test
{		
	public static void main(String[] args) 
	{	
		ArrayList a1 = new ArrayList();
		a1.add("java01");
		a1.add("java02");
		a1.add("java03");
		a1.add("java04");	
		
		Iterator it = a1.iterator();  //获取迭代器，用于取去集合中的元素
		while (it.hasNext())
		{
			sop(it.next());

		}
		//for循环结束，it1释放，节省内存
		for (Iterator it1 = a1.iterator();it1.hasNext() ; )
		{
			sop(it1.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

List：

|--List ：元素是有序的，元素可以重复，因为该集合体系有索引。

|--Set：元素是无序的，元素不可以重复。该集合当中没有索引。

list方法

凡是可以操作脚标的方法，都是该体系特有的方法。

增

add（index，element）;

addAll（index，collection）;

删

remove（index）;

改 

set(indxe,element);

查 

get(index);

subList(from,to);

listIterator();

import java.util.*;
class ListDemo
{	
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");

		sop(al);	//[java01, java02, java03]		
		//在角标1处添加java09
		al.add(1,"java09");
		sop(al);		//[java01, java09, java02, java03]		
		//删除2角标元素
		al.remove(2);	
		sop(al);		//[java01, java09, java03]		
		//修改2脚标元素为java10
		al.set(2,"java10");	
		sop(al);		//[java01, java09, java10]		
		//查询1角标元素
		sop("get[1]="+al.get(1));		
		//获取所有元素
		for (int x =0;x<al.size() ;x++ )	
		{
			System.out.println("al["+x+"]="+al.get(x));
		}		
		//获取所有元素
		for (Iterator it = al.iterator();it.hasNext() ; )
		{
			sop("next:"+it.next());
		}	Iterator ite= al.iterator();	
		while (ite.hasNext())
		{
			sop("next="+ite.next());
		}	
		//通过indexOf获取对象的位置
		sop("index="+al.indexOf("java01"));

		//获取指定位置的元素
		List sub = al.subList(1,3);
		sop("sub="+sub);
	}

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

ListIterator

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

在迭代式，不可以通过集合对象的方法操作集合中的元素。

因为会发生 java.util.ConcurrentModificationException异常

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。

只能对元素进行判断，取出，删除的操作。

如果想要其他的额操作如添加，修改等，就需要使用其子接口listIterator。

该接口只能通过List集合的ListIterator方法获取。

import java.util.*;
class ListDemo
{	
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();

		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		sop(al);

		ListIterator li = al.listIterator();

		while (li.hasNext())
		{
			Object obj = li.next();
			if (obj.equals("java02"))
			{
				li.set("java10"); //修改元素
				li.add("java002"); //添加元素
			}
		}
		sop(al);

		//反向遍历
		while (li.hasPrevious())
		{
			sop("hasPrevious:"+ li.previous());
		}
	}

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

|--List ：元素是有序的，元素可以重复，因为该集合体系有索引。

|--ArrayList:底层的是数组结构

（默认长度是10，当超过，new+50%的新数组，将原数组搬过来，在把包超过的搬进来）  

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

|--LinkedList :底层使用的链表数据结构

特点：增删速度很快，查询稍慢。

|--Vector ：底层是数组数据结构

（默认长度是10，当超过，new+100%的新数组，将原数组搬过来，在把包超过的搬进来）  

特点：线程同步。增删都很慢，被ArrayList替代了。

Vector()  的 elements

Enumeration枚举（类似Iterator）

枚举就是Vertor特有的取出方式。

发现枚举和迭代很像，

其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称过长。

所以被迭代器取代了。

枚举郁郁而终了

import java.util.*;
class ListDemo
{	
	public static void main(String[] args)
	{
		Vector v = new Vector();

		v.add("java01");
		v.add("java02");
		v.add("java03");

		Enumeration en = v.elements();

		while(en.hasMoreElements())
		{
			sop(en.nextElement());
		}
	}

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

LinkedList 

特有方法

LinkedList	链表结构
addFirst( );	在头部添加，因为结构，所以往后推着加入元素
addLast( );	在尾部添加，因为结构，所以可以从尾部添加元素
getFirst( );	获取头部值，获取第一个元素。
getLast( );	获取尾部值，获取最后一个元素。
removeFirst( );	获取头部值，并移除头部值
removeLast( );	获取尾部值，并移除尾部值

当集合中没有元素，为空时提示NoSuchElementException

在 JDK1.6出现了代替方法。

addFirst( ); 在头部添加 offerFirts（）

addLast( ); 在尾部添加 offerLast（）

getFirst( ); 获取头部值 peekFirst（）

getLast( ); 获取尾部值 peekLast（）

removeFirst( ); 获取头部值，并移除头部值  pollFirst（）

removeLast( ); 获取尾部值，并移除尾部值 pollLast（）

import java.util.*;
class test 
{
	public static void main(String[] args)
	{
		LinkedList link = new LinkedList();

		link.add("java01");
		link.add("java02");
		link.add("java03");
		link.add("java04");
		
		addFirst("javafirst");// 在头部添加
		addLast("javalast"); //在尾部添加

		getFirst(); //获取头部值
		getLast(); //获取尾部值

		removeFirst();	//获取头部值，并移除头部值
		removeLast();	//获取尾部值，并移除尾部值
		
		//清空
		while(!link.isEmpty())		
		{
			sop(link.removeLast());
		}
	}

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

练习

/*
使用LinkedList模拟一个堆栈或者队列数据结构

堆栈：先进后出。	如同杯子。
队列：先进先出。First in first 如同水管，

*/
import java.util.*;
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 inNull()
	{
		return link.isEmpty();
	}

}
	
class Test
{
	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);
	}
}

/*
去除ArrayList中的重复元素。
*/
import java.util.*;
class Test
{
	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 main(String[] args)
	{
		ArrayList al = new ArrayList();

		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java03");
		sop(al);

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

超重点 equals应用

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素
比如：存人对象，同姓名，同年龄，视为同一个人，为重复元素。
思路
1对人描述，将数据封装进人对象
2定义容器，将人存入
3取出

结论
List集合判断元素是否相同该，依据的是元素的equals方法。
*/
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name= name;
		this.age= age;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;

		Person p= (Person)obj;
		return this.name.equals(p.name)&& this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class Test
{
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();

		al.add(new Person("lisi01",30));
		al.add(new Person("lisi02",35));
		al.add(new Person("lisi03",32));
		al.add(new Person("lisi02",35));
		al.add(new Person("lisi03",32));
		al.add(new Person("lisi04",31));

		al=singleElement(al);

		Iterator it = al.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);
	}
}