黑马程序员----集合框架

集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
就使用集合容器进行存储。

集合特点：
1，用于存储对象的容器。（数组也可以存，但是数组长度是确定的，几个长度是可变的！）
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。 (其实就是和数组的区别)

框架的顶层Collection接口：


Collection的常见方法：


1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):



2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();

3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。 


4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！


5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。 

package cn.itcast.p3.collection.demo;

import java.util.ArrayList;
import java.util.Collection;



/*
 * 集合方法演示
 */
public class collectionDemo {

	public static void main(String[] args) {
		
		Collection coll = new ArrayList(); //CTRL+Shift+O，自动导入包。ArrayList()是随便找的一个类。只为演示方法。
		
		show(coll);

	}

	private static void show(Collection coll) {//传入一个集合
		
		
		coll.add("abcd1");//直接调用集合方法，添加一个字符串对象。
		coll.add("abcd2");
		coll.add("abcd3");
		coll.add("abcd4");
		
		
		
		System.out.println(coll.add("abcd1"));//返回布尔型，添加成功返回true
		System.out.println(coll);//直接打印集合会输出里面的元素。
		
		coll.remove("abcd1");// 会改变集合长度
		System.out.println(coll);//直接打印集合会输出里面的元素。
		
		coll.clear();//清空集合
		System.out.println(coll);//直接打印集合会输出里面的元素。
		
		System.out.println(coll.contains("abcd2"));//是否包含abcd2
		
		System.out.println(coll.size());// 获取集合长度
		
		
		
	}

}

运行结果：

package cn.itcast.p3.collection.demo;

import java.util.ArrayList;
import java.util.Collection;

public class collectionDemo2 {

	public static void main(String[] args) {
		
		Collection coll1 = new ArrayList();
		Collection coll2 = new ArrayList();
		
		show(coll1,coll2);
		
	}

	private static void show(Collection coll1, Collection coll2) {
		
		coll1.add("abcd1");
		coll1.add("abcd2");
		coll1.add("abcd3");
		coll1.add("abcd4");
		
		coll2.add("abcd2");
		coll2.add("abcd5");
		coll2.add("abcd6");
		
		System.out.println("添加前的两个集合");
		System.out.println("coll1:"+coll1);
		System.out.println("coll2:"+coll2);
		//演示addAll
		coll1.addAll(coll2); //将coll2中的元素添加到coll1中
		System.out.println("coll2添加到coll1后的两个集合");
		System.out.println("coll1:"+coll1);
		System.out.println("coll2:"+coll2);
		
		//演示removeAll
		boolean b = coll1.removeAll(coll2);//将两个集合中相同元素从调用removeAll的集合中删除。
		System.out.println("removeAll return:"+b);
		System.out.println("删除括号内的相同元素后");
		System.out.println("coll1:"+coll1);
		System.out.println("coll2:"+coll2);
		
	}

}

运行结果：

 对比记忆

迭代器的使用：

返回的是一个接口！

先会用，原理再搞懂。

迭代器方法：

next()方法中有一指针，使用后会自动指向下一个。

next（）找不到元素后的异常。

取出集合中全部元素方法！

节省内存的写法，如果取完元素后还想用迭代器对象，那就用while吧！

iterator迭代器的原理：
就是一个接口，然后每一个容器都用自己的内部结构去实现iterator接口。

List和Set的特点：

Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。（二叉树算有序的了！）

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1，添加
void add(index,element);
void add(index,collection);

2，删除；
Object remove(index):

3，修改：
Object set(index,element);

4，获取：
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);

list集合是可以完成对元素的增删改查。




List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

插入元素，后面顺延

注意看返回值！ 删除对象的时候返回真假，删除元素的时候返回元素。

collection都不具备修改！list具备，来一个：

获取元素：

获取子列表：

ListIterator接口：

list有自己的特有获取方法get：

学会查API文档异常！

迭代的时候用集合方法就会并发出异常来，解决办法，要么就迭代，要么就集合方法，一起用会出问题，但是迭代器就只有三个方法。。。

ListIterator里面有实现：

List里面提供了获取方法!

然后这样就获取到了list的迭代器：

可以了：

说明：

简单的区别图：

ArryList数组结构，查询快，增删慢。（跟Linkedlist角标区别就是ArrayList空间连着！）

LinkedList链表结构，查询慢，增删快。选择这用吧！（链表那元素的内存空间地址有可能还离得很远）（链表其实也带着编号，就空间不连着）

Vector：

带elements都是特有的方法。

就因为名字太长了，后来淘汰了!（当然还有其它原因）

跟迭代器功能一样：

枚举：把元素一枚一枚的取出来！

LInkedList：

addFirst();    （LinkedList特有方法，想想有一条链子）
addLast():
jdk1.6
offerFirst();
offetLast();


getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():

removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();

演示：

取出的顺序注意观察！

获取但是不删除

获取并且删除，会改变长度！

remove和get的区别！

练习：

借助以有容器创建：

package cn.itcast.p1.vector.demo;

import java.util.LinkedList;

public class Duilie
{
	private LinkedList link ;
	
	public Duilie()
	{
		link = new LinkedList();
	}
	
	//添加功能
	public void myAdd(Object obj)
	{
		link.addLast(obj);
	}
	
	// 删除
	public Object myGet()
	{
		return link.removeFirst();
	}
	
	public boolean isNull()
	{
		return link.isEmpty();
	}
}

ArrayList集合存储自定对象：

调用一个对象中的两个方法，要取个名字（主要是next()它有个指针，用了以后它就指向下一个！那对象角标就错啦。）

这样搞就对了！

自动装箱和拆箱理解：

JDK1.5版本后a1.add(5)，就会自动装箱，JDK1.5以前都是a1.add(new Integer(5))这样表达才行。

int x =  num + 8;运算的时候才拆箱！

集合框架-HashSet集合)：

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。 
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

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

恒久不变的原因：底层是通过算法实现的，算法有可能会改变。

Hash是一种算法。

创建了字符串对象放进Hashset容器中，字符串的hashcode就会覆盖，同时也覆盖了equlas。

明明说hashset是保证唯一的，为什么会有重复？

原因：person继承了object，用的是object的equals，所以对象比较地址值不一样，就算是两个对象了，所以我们应该创建person类的hashcode 和equals。

LinkedHashSet：

package cn.itcast.p1.ArrayListTest.Test;

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

public class LinkedHashSetDemo {

	public static void main(String[] args) 
	{
		
		HashSet hs = new LinkedHashSet();
		
		hs.add("abcd1");
		hs.add("abcd2");
		hs.add("abcd3");
		hs.add("abcd4");
		hs.add("abcd5");
		hs.add("abcd6");
		
		
		Iterator it = hs.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
			
		}
	}

}

运行：

abcd1
abcd2
abcd3
abcd4
abcd5
abcd6

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

package cn.itcast.p2.Map.Demo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Map<Integer,String> p = new HashMap<Integer,String>();

		
		System.out.println(p);
		
		p.put(8, "zhangsan");
		p.put(9, "zhangsan2");
		p.put(10, "zhangsan3");
		p.put(11, "zhangsan4");
		p.put(12, "zhangsan5");
		
		Set <Map.Entry<Integer,String>> entrySet = p.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:"+key+"value:"+value);
			
			
		}
		
		
//			
//		/*
//		 * 使用keySet()取出Map所有元素
//		 */
//		Set<Integer> keySet = p.keySet();
//		/*
//		 * 拿到迭代器
//		 */
//		Iterator<Integer> it = keySet.iterator();
//		
//		while(it.hasNext())
//		{
//			Integer key = it.next();//拿到键值，类型Integer
//			String value = p.get(key);
//			
//			System.out.println("name:"+value);
//		}
//		
	}

}

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。 
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

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




|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。 
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。 

TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。






if(this.hashCode()== obj.hashCode() && this.equals(obj))






哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。


2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。


注意：如果哈希值不同，是不需要判断equals。






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


泛型：
jdk1.5出现的安全机制。

好处：
1，将运行时期的问题ClassCastException转到了编译时期。
2，避免了强制转换的麻烦。

<>:什么时候用？当操作的引用数据类型不确定的时候。就使用<>。将要操作的引用数据类型传入即可.
   其实<>就是一个用于接收具体引用数据类型的参数范围。
   
在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型 。


泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。


运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。
为什么擦除呢？因为为了兼容运行的类加载器。


泛型的补偿：在运行时，通过获取元素的类型进行转换动作。不用使用者在强制转换了。




泛型的通配符：? 未知类型。 


泛型的限定：
? extends E: 接收E类型或者E的子类型对象。上限
一般存储对象的时候用。比如 添加元素 addAll.


? super E: 接收E类型或者E的父类型对象。 下限。
一般取出对象的时候用。比如比较器。


===========================================================


集合的一些技巧：


需要唯一吗？
需要：Set
需要制定顺序： 
需要： TreeSet
不需要：HashSet
但是想要一个和存储一致的顺序(有序):LinkedHashSet
不需要：List
需要频繁增删吗？
需要：LinkedList
不需要：ArrayList

如何记录每一个容器的结构和所属体系呢？


看名字！




List
|--ArrayList
|--LinkedList


Set
|--HashSet
|--TreeSet


后缀名就是该集合所属的体系。


前缀名就是该集合的数据结构。


看到array：就要想到数组，就要想到查询快，有角标.
看到link：就要想到链表，就要想到增删快，就要想要 add get remove+frist last的方法 
看到hash:就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcode方法和equals方法。 
看到tree：就要想到二叉树，就要想要排序，就要想到两个接口Comparable，Comparator 。


而且通常这些常用的集合容器都是不同步的。 




============================================


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):
boolean containsValue(value):
boolean isEmpty();


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



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

|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。