day14集合类，迭代器。List,列表迭代器,vector,LinkedList。Set，HashSet

/*
集合类，迭代器。List,列表迭代器,vector,LinkedList。Set，HashSet
*/


/*
集合类：
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象
的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的，
集合长度是可变的，
数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

集合框架：先看顶层，所有的共性。

                  (接口)collection

			List                         Set

ArrayList    linkedList Vector        HashSet   TreeSet

为什么会出现这么多容器？
因为每个容器对数据的存储方式都有不同。
这个存储方式称之为：数据结构。
*/
/*
add方法的参数类型是Object,以便于接收任意类型对象
集合中不可能存放对象实体，都是对象的引用（地址）.

什么是迭代器呢？
其实就是集合的取出元素的方式。

把取出方式定义在集合的内部，内部类。
这样取出方式就可以直接访问集合内的元素
那么取出方式就被定义成了内部类
而每一个容器的数据结构不同
所以取出的动作细节也不一样。但是都有共性内容
判断和取出，那么可以将共性抽取。

那么这些内部类都符合一个规则，该规则是Iterator
如何获取集合的取出对象呢？
通过一个对外提供的方法：iterator();
*/
class  CollectionDemo
{
	public static void main(String[] args) 
	{
		method_get();
	}

	public static void method_get()
	{
		List al = new ArrayList();

		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
	
		//获取迭代器，用于取出集合中的元素。
		Iterator it = al.iterator();
		while(it.hasNext())//for循环可以更省内存
		{
			sop(it.next());
		}

	}

	public static void method_2()
	{
		ArrayList al1 = new ArrayList();

		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");

		ArrayList al2 = new ArrayList();

		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");

		al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素

		//al1.removeAll(al2);去掉一堆相同的元素
		sop("al1:"+al1);
		sop("al2:"+al2);
	}

	public static void base_method()
	{ 
		//创建一个集合容器，使用Collection接口的子类，ArrayList
		ArrayList al = new ArrayList();

		//加元素
		al.add("java01");//add(Object obj)任意类型的对象
		al.add("java02");
		al.add("java03");
		al.add("java04");
			//打印原集合
			sop("old"+al);

		//3删除元素
		//al.remove("java02");
		//al.clear();//清空集合

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

		//2获取个数，集合长度
		sop("size:"+al.size());

		//打印改变后的集合
		sop(al);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

/*
Collection
	List:元素是有序的，元素可以重复。因为该集合体系有索引
		
		|--Arraylist：底层的数据结构使用数组结构。特点：读（查询）（修改）快，改（增删）慢。
							一个改动，所有的编号都要动。线程不同步。
							默认长度为10，超出时，50%延长空间
		|--LinkedList：底层使用链表数据结构。查询慢，改（增删）快。
		|--Vector：底层是数组数据结构，1.2以后才出现其他的集合框架。
				Vector是线程同步的。被ArrayList替代了。默认长度为10，超出时100%延长空间

	Set:元素是无序的，元素不可重复。

	List集合:
		特有方法。凡是可以操作角标的方法
		都是该体系特有的方法

		使用Iterator可以迭代元素，但是在迭代过程中不允许进行增删操作。
		
		ListIterator可以在迭代过程中对元素进行修改操作。
		在ListIterator中提供了比Iterator更多的操作方法，
		如add和set方法，从后向前遍历，其余的跟Iterator没什么区别.

		增
			add(int index, E element) 
			在列表的指定位置插入指定元素（可选操作）。

			addAll(int index, Collection<? extends E> c) 
			将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

		删
			remove(index);

		改
			set(index,element)

		查
			get(index);
			subList(from,to);
			listIterator();

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

	在迭代时，不可以通过集合对象的方法操作集合中的元素，
	因为会发生并发操作异常，所以在迭代时，只能用迭代器的方法操作
	元素，可是Iterator方法是有限的
	只能对元素进行判断，取出，删除操作。
	如果想要其他操作如添加，修改等，就要使用其子接口。ListIterator。

	逆向遍历：
	hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。

		sop(al);
		ListIterator li = al.listIterator();
		while(li.hasNext())
		{
			Object obj = li.next();

			if(obj.equals("java02"))
				
				li.remove();//add(),set().

				sop("obj="+obj);//这个为什么移除了还打印所有？
				li.next()，object指向java02，
				remove移除了元素在集合中的引用，元素还在内存当中。
				元素还被object使用，所以被打印。
		}
		sop("al="+al);

		打印结果：010203		
				010203
				0103
*/

import java.util.*;
class  ListDemo
{
	//listIterator() 
          //返回此列表元素的列表迭代器（按适当顺序）。

	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");

		ListIterator li = al.listIterator();
		while(li.hasNext())
		{
			Object obj = li.next();
			if(obj.equals("java02"))
				//li.add("java009");
				li.set("java0006");
		}
		sop("al="+al);
		/*
		//在迭代过程中，准备添加或者删除元素
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();

			if(obj.equals("java02"))
				//al.add("java008");
				//会出现并发操作异常，在迭代器操作时，不可以用集合方法同时操作。
				
				//it.remove();//迭代器方法，将java02在集合中移除

			sop("obj="+obj);
		}
		*/
	}

	public static void listDemo() 
	{
		ArrayList al = new ArrayList();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		sop("原集合是："+al);

		//在指定位置添加元素

		al.add(1,"java09");

		//删除指定位置的元素
		//al.remove(2);

		//修改元素
		//al.set(2,"java007");

		//通过角标获取元素
		//sop("get(1)"+al.get(1));

		//sop(al);

		//get()获取所有元素
		for(int x = 0;x<al.size();x++)
		{
			//System.out.println("al("+x+")="+al.get(x));
		}

		Iterator it = al.iterator();
		while(it.hasNext())
		{
			sop("next:"+it.next());
		}
		
		sop("index="+al.indexof("java02"));//获取位置

		List sub = al.subList(1,3);//子集合
		sop("sub="+sub);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}		
/*vector:
		elements() 
				  返回此向量的组件的枚举。

		枚举就是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())
				{
					System.out.println(en.nextElement());
					//迭代，记住这种写法,合并流要用到枚举。
				}
			}
		}
		/*
	LinkedList特有方法
		addFirst();将指定元素插入此列表的开头。
		addLast();将指定元素添加到此列表的结尾。

		getFirst(); 返回此列表的第一个元素。
		getLast(); 返回此列表的最后一个元素。
		获取元素，但不删除元素。

		removeFirst(); 移除并返回此列表的第一个元素。
		removeLast();移除并返回此列表的最后一个元素。
		获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementsException

		因为会有异常，所以1.6版本后出现如下替代方法。
		获取元素，但是元素被删除。如果集合中没有元素，返回null.
		offerFirst(E e) 
				  在此列表的开头插入指定的元素。
		offerLast(E e) 
				  在此列表末尾插入指定的元素。

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

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

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

		*/

		class LinkedListDemo 
		{
			public static void main(String[] args) 
			{
				LinkedList link = new LinkedList();

				link.addFirst("java01");
				link.addFirst("java02");
				link.addFirst("java03");
				link.addFirst("java04");

				sop(link);
			
				//取出元素另一种方法
				while(!link.isEmpty())
				{
					sop(link.removeFirst());
				}
			}
			public static void sop(Object obj)
			{
				System.out.println(obj);
			}
		}
		/*
	LinkedList模拟一个堆栈或者队列数据结构

	堆栈：先进后出，如同一个杯子
	队列：先进先出，如同一个水管
	*/
	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.removeFirst();
		}
		public boolean isNull()//其实都是把LinkedList方法封装。
		{
			return link.isEmpty();
		}
	}

	class  LinkedListTest
	{
		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())
			System.out.println(dl.myGet());
		}
	}
//二个ArrayList练习。

/*
去除arraylist中的重复元素

思路：
定义一个新的容器，向容器中添加元素，添加之前先
判断里面有没有要添加的元素。
*/
import java.util.*;

class ArrayListTest 
{
	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");
		al.add("java01");
		al.add("java03");

		/*
		在迭代时循环中next调用一次，就要hasNext判断一次，
		指针向下走一次。
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			sop(it.next()+"..."+it.next());//不可取的写法。

		}
		*/
		sop(al);
		al = singleElement(al);
		sop(al);
	}
	//包装成方法。
	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集合中，并去除重复元素。
比如：存人对象，同姓名年龄，视为同一个人，为重复元素。。

思路：
1对人描述，将数据封装进入对象Person

2定义容器，将人存入

3取出。

List集合判断元素是否相同，依据就是元素的equals方法,
无论是包含，还是删除。
*/

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public  String getName()
	{
		return name;
	}
	public  int getAge()
	{
		return age;
	}

	public boolean equals(Object obj)//复写
	{
		if(!(obj instanceof Person))
			return false;
		//先判断是否包含，更严谨的话，这里直接抛异常。我不传person，传DEMO，没意义
		Person p = (Person)(obj);
		return this.name.equals(p.name) && this.age==p.age;
	}
}

class  ArrayListTest2
{
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();

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

		al = singleElement(al);//为什么这里调用了比较方法，可以还是加入了相同的呢？
			//因为此处调用了object的equals方法，而我们是new的对象，地址是不同的。
			//应该重写自己的equals方法。判断方法不同，ArrayList只判断对象是否相同。

		Iterator it = al.iterator();
		while(it.hasNext())
		{
			//sop(it.next().getName());//这里是不行的，al.add(Object obj),it.next()是Object,
			//而object里面没有getName方法，必须转换成Person。

			Person p = (Person)(it.next());//Object转换成了Person，所以就有了getName方法
						
			sop(p.getName()+"::"+p.getAge());
		}
	}

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

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

/*
|--Set:元素是无序的（存入和取出的顺序不一定一致），元素不可重复。
	|--HashSet:底层数据结构是哈希表。线程是非同步的。
		是如何保证元素的唯一性的呢？(依据)
		判断是通过元素的两个方法，hashCode和equals来完成。
		如果元素HashCode一样，才会再去判断equals是否为真。
		如果元素的HashCode不同，不会去调用equals().

		注意，对于判断元素是否存在，以及删除等操作，依赖hashCode和equals方法来完成

	|--TreeSet:

Set集合的功能和Collect是一致的，
哈希表存对象。
-HashSet先比较哈希值，如果相同，再比较对象equals()。

*/
import java.util.*;
class HashSetDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		sop(hs.add("java01"));
		sop(hs.add("java01"));//HashSet返回的是boolean，无序的，先看有没有。
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");

		Iterator it = hs.iterator();
		while(it.hasNext())
		{
				sop(it.next());
		}
	}
}
import java.util.*;
/*
往hashSet集合中存入自定义对象
姓名和年龄相同为同一个人，重复元素。
*/
class  HashSetTest
{
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a3",13));
		//hs.add(new Demo());
		//hs.add(new Person("a2",12));
		//hs.add(new Person("a2",12));
		//hs.add(new Person("a2",12));

		Iterator it = hs.iterator();
		
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			
			sop(p.getName()+"..."+p.getAge());
		}
	}

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

class Demo
{

}

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int hashCode()
	{
		//System.out.println(this.name+"...hash");
		//return 60;//如果哈希地址一样，再调用equals。
		return name.hashCode()+age*39;//*39，这是为了尽量保证唯一。
		
	}
	public  String getName()
	{
		return name;
	}
	public  int getAge()
	{
		return age;
	}

	public boolean equals(Object obj)//注意复写一定是object参数
	{
		if(!(obj instanceof Person))
			return false;
		//先判断是否包含，更严谨的话，这里直接抛异常。我不传person，传DEMO，没意义
		Person p = (Person)(obj);
		System.out.println(this.name+"..."+p.name);//如果此处没有打印，没有调用，
		//因为地址不同，不再比较equals
		return this.name.equals(p.name) && this.age==p.age;
	}
}