Java集合框架，未完

一、集合类

集合的由来：

面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就需要将对象进行存储，集合就是存储对象最常用的一种方式。

集合特点：
1，用于存储对象的容器。（容器本身就是一个对象，存在于堆内存中，里面存的是对象的地址）
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。 （只能存对象）

小问题：想存基本数据类型怎么办？　　装箱、拆箱。例：al.add(5);可以这样写　　 // 相当于al.add(new Integer(5));

集合和数组的区别：

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

集合框架的构成及分类：（虚线为接口）

---

二、 Collection接口

Collection子接口以及常用实现类：

Collection接口
　　|--List接口：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。

　　　　|--Vector:内部是 数组 数据结构，是同步的。增删，查询都很慢！100%延长（几乎不用了）  
　　　　|--ArrayList:内部是 数组 数据结构，是不同步的。替代了Vector，查询的速度快，增删速度慢。50%延长。（查询时是从容器的第一个元素往后找，由于数组的内存空间是连续的，所以查询快；增删的话所有元素内存地址都要改变，所以增删慢。）
　　　　|--LinkedList:内部是 链表 数据结构，是不同步的。增删元素的速度很快。（同理，链表的内存空间是不连续的，所以查询慢；增删时只需改变单个指针的指向，所以快；）

　　|--Set接口：无序，元素不能重复。Set接口中的方法和Collection一致。

　　　　|--HashSet: 内部数据结构是哈希表 ，是不同步的。

　　

List接口：

有一个最大的共性特点就是都可以操作角标，所以LinkedList也是有索引的。list集合可以完成对元素的增删改查。

Set和List的区别：

1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

ArryList和Vector可变长度数组的原理：

当默认长度的数组不够存储时，会建立一个新数组。将原来数组的内容拷贝到新的数组当中，并将新增加的元素追加到拷贝完的数组尾，如果仍然不够重复上述动作。其中,ArryList的增加是以原来50%长度进行增加，而Vector是按照100%延长。

ArryList是线程不安全的，Vector是安全的：

由于是否有锁的判断将影响效率，故Arrylist效率远远高于Vector。而且只要是常用的容器就不是同步的，因为同步效率比较低。

ArryList存取对象的一个小例子：

        Person p1 = new Person("lisi1",21);

        ArrayList al = new ArrayList();
        al.add(p1);
        al.add(new Person("lisi2",22));
        al.add(new Person("lisi3",23));
        al.add(new Person("lisi4",24));

        Iterator it = al.iterator();
        while(it.hasNext()){
//          System.out.println(((Person) it.next()).getName()+"::"+((Person) it.next()).getAge());
　　　　　　　　　　　　//错误方式：不能这样取，next()一次指针会移动一次，会输出“lisi1::22 lisi3::24”
            // 正确方式：拿到一个Person对象，然后取属性。
            Person p = (Person) it.next();
            System.out.println(p.getName()+"--"+p.getAge());
        }　　

---

三、Iterator接口

对 collection 进行迭代的迭代器，即对所有的Collection容器进行元素取出的公共接口。

该迭代器对象必须依赖于具体容器，因为每一个容器的数据结构都不同，所以该迭代器对象是在具体容器中进行内部实现的。（内部类，可以看具体容器的源码）

对于使用容器者而言，具体的实现方法不重要，只要通过具体容器获取到该实现的迭代器的对象即可，也就是iterator方法，而不用new。（Iterator<String> ite=list.iterator();）

小知识点：使用迭代器过程中while和for的区别

 第一种
 Iterator<String> ite=list.iterator();
      while(ite.hasNext())//判断下一个元素之后有值
      {
          System.out.println(ite.next());
      }
 第二种
 Iterator<String> ite=list.iterator();
 for(Iterator it = coll.iterator(); it.hasNext(); ){
             System.out.println(it.next());
         }

第一种方法while循环结束后迭代器对象还在内存中存在，还能继续使用迭代器对象。

第二种方法for循环结束后迭代器对象就消失了，清理了内存，开发中第二种常用。

Iterator的一个子接口

　　|--ListIterator接口（列表迭代器）

适用情况例子：（出现ConcurrentModificationException异常时）

出现异常情况代码：

Iterator it = list.iterator();
        while(it.hasNext()){

            Object obj = it.next();//java.util.ConcurrentModificationException
                            //在使用迭代器的过程中使用集合操作元素，容易出现异常。
                        //可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。 

            if(obj.equals("abc2")){
                list.add("abc9");
            }
            else
                System.out.println("next:"+obj);
        }
        System.out.println(list);　　

解决办法代码：

public static void main(String[] args) {

        List list = new ArrayList();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");

        System.out.println("list:"+list);
        ListIterator it = list.listIterator();//获取列表迭代器对象
        //它可以实现在迭代过程中完成对元素的增删改查。
        //注意：只有list集合具备该迭代功能.

        while(it.hasNext()){
            Object obj = it.next();
            if(obj.equals("abc2")){
                it.add("abc9"); //ListIterator提供了add方法
            }
        }

HashSet之覆盖hashCode方法和equals方法　

如何保证HashSet的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的：
->如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
->如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true:
　　如果为true，视为相同元素，不存；如果为false，那么视为不同元素，就进行存储。

记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法，以建立对象判断是否相同的依据。

例：往HashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人，视为相同元素。

import java.util.HashSet;
import java.util.Iterator;

class Person {

	private String name;
	private int age;

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

	@Override
	public int hashCode() {
		// System.out.println(this+".......hashCode");
		return name.hashCode() + age * 27; // 乘以一个任意数，防止加了年龄以后HashCode仍相同
	}

	@Override
	public boolean equals(Object obj) {
		// 健壮性判断
		if (this == obj)
			return true;
		if (!(obj instanceof Person))
			throw new ClassCastException("类型错误");
		// System.out.println(this+"....equals....."+obj);

		Person p = (Person) obj;
		return this.name.equals(p.name) && this.age == p.age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String toString() {
		return name + ":" + age;
	}
}

public class HashSetTest {

	public static void main(String[] args) {
		HashSet hs = new HashSet();
		/*
		 * HashSet集合数据结构是哈希表，所以存储元素的时候，
		 * 使用的元素的hashCode方法来确定位置，如果位置相同，在通过元素的equals来确定是否相同。
		 *
		 */
		hs.add(new Person("lisi4", 24));
		hs.add(new Person("lisi7", 27));
		hs.add(new Person("lisi1", 21));
		hs.add(new Person("lisi9", 29));
		hs.add(new Person("lisi7", 27));

		Iterator it = hs.iterator();
		while (it.hasNext()) {
			Person p = (Person) it.next();
			System.out.println(p);
		}
	}
}

　　

运行结果：

lisi1:21
lisi9:29
lisi4:24
lisi7:27

四、Map接口

Map：一次添加一对元素。Collection 一次添加一个元素。
　　Map也称为双列集合，Collection集合称为单列集合。
　　其实map集合中存储的就是键值对。
　　map集合中必须保证键的唯一性。

常用方法：
1，添加。
value put(key,value):返回前一个和key关联的值，如果没有返回null.

2，删除。
void clear():清空map集合。
value remove(key):根据指定的key翻出这个键值对。

3，判断。
boolean containsKey(key):是否包含该key
boolean containsValue(value):是否包含该value
boolean isEmpty();是否为空

4，获取。
value get(key):通过键获取值，如果没有该键返回null。当然，可以通过返回null，来判断是否包含指定键。
int size(): 获取键值对的个数。

Map常用的子类：
　　|--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
　　|--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
　　|--HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
　　|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。

Map的迭代方法：

　　Map本身没有迭代器。

　　方法一：利用Map接口的values()方法,返回此映射中包含的值的 Collection （值不唯一），

　　　　　　然后通过Collecion的迭代器进行迭代。（只需要Value，不需要Key的时候）

public class MapDemo {

	public static void main(String[] args) {

		Map<Integer,String> map = new HashMap<Integer,String>();
		method_2(map);
	}

	public static void method_2(Map<Integer,String> map){

		map.put(8,"zhaoliu");
		map.put(2,"zhaoliu");
		map.put(7,"xiaoqiang");
		map.put(6,"wangcai");

		Collection<String> values = map.values();

		Iterator<String> it2 = values.iterator();
		while(it2.hasNext()){
			System.out.println(it2.next());
		}
        }
}　

　　方法二：通过keySet方法获取map中所有的键所在的Set集合（Key和Set的都具有唯一性），

　　　　　　再通过Set的迭代器获取到每一个键，再对每一个键通过Map集合的get方法获取其对应的值即可。（比较好用）

		Set<Integer> keySet = map.keySet();
		Iterator<Integer> it = keySet.iterator();

		while(it.hasNext()){
			Integer key = it.next();
			String value = map.get(key);
			System.out.println(key+":"+value);
		}

　　方法三：利用Map的内部接口Map.Entry<K,V>。

　　　　　　通过Map的entrySet()方法，将键和值的映射关系作为对象存储到Set集合中

　　　　　　这个映射关系的类型就是Map.Entry类型(结婚证)。

　　　　　　再通过Map.Entry对象的getKey和getValue获取其中的键和值。

		Set<Map.Entry<Integer, String>> entrySet = map.entrySet();

		Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();

		while(it.hasNext()){
			Map.Entry<Integer, String> me = it.next();
			Integer key = me.getKey();
			String value = me.getValue();
			System.out.println(key+":"+value);
		}