集合总结

Iterator：迭代器。
	用来取出Collection集合中的元素。
	每一个集合都在内部根据自己的特有数据结构对该结构通过内部类完成出去动作的实现。
	并通过iterator()可以获取到迭代器对象。
	通过该对象hasNext()判断集合中是否有下一个元素。在通过next方法取出元素。
	注意：next()方法每调用一次，内部指针就会向下偏移。next在迭代过程被调用多次，有可能发生NoSuchElementException.

	迭代器就像大型游戏中的抓布娃娃的游戏中的夹子。

	通过AbstractList的源码可以查看内部类的具体实现。


	在使用Iterator的时候，迭代元素的过程中，如果有对元素的操作，只可以使用remove方法。
	不可以直接在迭代时使用集合对象的操作方法操作正在被迭代的数据，因为会发生ConcurrentModificationException。

	如果想要对迭代中的元素进行增删操作，需要使用ListIterator这个Iterator的子接口。

	注意：ListIterator只能对List集合有效。参考day12\IteratorDemo.java.


	JDK1.5以后，将Collection中的方法，抽取到了一个父接口中，Iterable该接口的出现，提供了增强型的for循环。

---------------------
List集合中有一个Vector子类，该子类是jdk1.0出现的，该子类中有自己独特的获取元素的方式：枚举Enumeration。
	枚举和迭代功能是一致的，很遗憾，因为名称过长，建议使用迭代。

	枚举中的方法：hasMoreElements()  nextElement().

	ArrayList有两种取出方式：1，迭代。2，get(index).
	Vector有四种方式：1，迭代。2，get(index).3，elementAt(index) 4,枚举。


	Vector的特点：1，数组数据结构，2，线程安全，3，自动延长通过100%方式。

	因为Vector的低效被ArrayList取代。


-------------------------------------

LinkedList：
	特点：1，链表数据结构，2，线程是不安全。3，对元素增删速度很快。

	与ArrayList的不同的是，ArrayList查询速度很快。

	特有方法：
	addFirst():
	addLast();
	jdk1.6出现新的方法：
	offsetFirst();
	offsetLast();

	
	getFirst():获取元素，但不删除，
	getLast();
	jdk1.6出现新的方法：
	peekFirst();
	peekLast();

	removeFirst()：获取元素，但删除。
	removeLast();
	jdk1.6出现新的方法：
	pollFirst();
	pollLast();


--------------------------------
Example：
	1，如果通过枚举取出ArrayList中的元素。
		public void getElmementByEnumeration()
		{
			ArrayList al =new ArrayList();
			al.add("abc1");

			final Iterator it = al.iterator();

			Enumeration en = new Enumeration()
			{
				public boolean hasMoreElements()
				{
					return it.hasNext();
				}
				public Object nextElement()
				{
					return it.next();
				}
			};

			while(en.hasMoreElements())
			{
				System.out.println(en.nextElement());
			}
		}

	2，去除ArrayList中重复元素。
		
		public List getSingleElementList(List list)
		{
			List l = new ArrayList();
			Iterator it = list.iterator();

			while(it.hasNext())
			{
				Object obj = it.next();
				if(!l.contains(obj))
					l.add(obj);	
			}
			return l;
		}

	3，模拟一个队列或者堆栈数据结构，通过LinkedList完成。
		队列：先进先出。
		堆栈：先进后出。
		class DuiLie
		{
			private LinkedList ll;
			DuiLie()
			{
				ll = new LinkedList();
			}

			public void myAdd(Object obj)
			{
				ll.addFirst(obj);
			}
			public Object myGet()
			{
				ll.removeLast();
			}
			public boolean isNull()
			{
				return ll.isEmpty();
			}
		}
		main()
		{
			DuiLie dl = new DieLie();
			dl.myAdd("abc1");
			dl.myAdd("abc3");

			while(!dl.isNull())
			{
				System.out.println(dl.myGet());
			}
		}


---------------------------------------------
Set:无序，不可以重复元素。方法和Collection一致。
    取出方法只有一个就是迭代器。而且set集合不可以修改元素。
    |--HashSet:底层数据结果是哈希表，如何保证元素唯一性的呢？
		通过每一个元素的hashCode方法返回值相同，并equals方法返回true来判断元素唯一性。
		如果hashCode值相等，才会判断equals方法。

	class Demo
	{
		public static void main(String[] args)
		{
			HashSet hs = new HashSet();
			//hs.add("abc1");
			//hs.add("abc2");
			//hs.add("abc1");//返回值是false。因为String有自己的hashCode和equals方法。

			
			hs.add(new Student("lisi1",20));
			hs.add(new Student("lisi2",20));
			hs.add(new Student("lisi3",20));
			hs.add(new Student("lisi1",20));
			
			System.out.println(hs.size());//4,对于同名同年龄的学生被视为相同对象，但已经存入。
							//原因：因为在进行hashCode方法和equals方法判断的时候使用的是、、//Object类中的方法。

							//为了保证符合自定义条件的对象相同。需要复写hashCode和equals方法。
		}
	}
	

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

		public boolean equals(Object obj)
		{
			
			if(this==obj)
				return true;
			if(!(obj instanceOf Student))
				return false;
			Student s = (Student)obj;
			//System.out.println(this.name+"..."+s.name);
			return this.name.equals(s.name) && this.age == s.age;
		}
		public int hashCode()
		{
			return name.hashCode()+age*27;
		}
		public String getName()
		{
			return name;
		}
		public String getAge()
		{
			return age;
		}
	}

	在HashSet判断是否包含指定元素时，使用Contains方法判断，依据哪些方法：
		hashCode(),,equals();
		一看hash，就要想到hash表，想到hash表，就必须要覆盖hashCode和equals方法。

	在ArrayList判断是否包含指定元素，使用Contains方法判断依据是：equals。


------------------------------------------------

Map集合：
	特点：一次存入一对元素（key Value）一定要保证键的唯一性。

	添加：v put(k,v):返回去k关联的前一个值，如果没有，返回null。
	删除：v remove(k);
	获取: v get(k):好处，可以判断某一个键是否存在。但是注意。有null的值情况。
	判断：containsKey(k).containsValue(v);

	获取所有：
		Set<K> keySet():将map集合中的所有键取出存入到Set集合中。在通过迭代器取出所欲的键，
			并通过map的get方法获取键所对应的值。

		Set<Map.Entry<K,V>> entrySet()：将map集合中的所有键值关系封装成Map.Entry类型的对象，存入到Set集合中。
						该关系的类型为Map.Entry.通过迭代器取出Map.Entry对象并通过getKey。
						getValue方法获取所有元素。

		原理：就是将Map集合转成Set集合。在进行迭代。

	获取所有值：Collection<V> values();

	|--HashMap：底层是哈希表，线程不同步，可以存入null键null值。
	|--Hashtable：底层也是哈希表，线程是安全的，不可以存入null键null值。
	|--TreeMap：可以对map集合中的键进行排序。线程不安全的。


	什么时候使用Map集合呢？
	当对象键有映射关系时。。

评论

1 楼 来这里学java 2012-02-13