集合框架知识详解

# 集合框架
## 出现集合类的原因
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

## 数组和集合类的区别
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的
数组存储的类型必须相同，集合则无此限制
数组中可以存储基本数据类型，集合只能存储对象

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

## 集合框架构成图
![](https://statics.caijw.com/uploads/2014/09/LP98vKYBf5lnVuIAONXs6TJtbc5rt1Gnrr92Wq5F.jpeg)

> 不同的集合的划分依据是数据结构的不同

# 集合框架顶层之Collection
Collection是集合框架中的顶层接口。其下有两个子接口：List（列表），Set（集）

所属关系：

Collection

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

|--Set   元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。

## Collection定义了集合框架的共性功能

1，添加
boolean add(E e)：添加元素

boolean addAll(Collection<? extends E> c)：将c中元素全部添加进this

2，获取
Iteratoriterator()：返回迭代器，下面有迭代器的介绍

int size()：返回集合的元素数目

3，删除
void clear()：清空集合

boolean remove(Object o)：从集合中移除o，如果存在的话

boolean removeAll(Collection<?> c)：移除c和this中相同的元素（去除交集）

4，判断
boolean contains(Object o)：判断o是否在集合中

boolean isEmpty()：判断集合是否为空

5，获取交集
boolean retainAll(Collection<?> c)：保留c和this中相同的元素（获取交集）

6，集合变数组
Object[] toArray()：返回包含此 collection 中所有元素的数组。

T[] toArray(T[] a)：将集合变为指定类型的数组

1、指定类型的数组应该定义的长度

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。

所以创建一个刚刚好的数组最优。

2、为什么要将集合变数组？

为了限定对元素的操作。不需要进行增删了。

注：集合中存储的都是对象的引用（地址）

## 迭代
1、概述
集合中定义了内部类，该内部类的是为了描述集合取出元素的方式，用以对集合中的元素进行判断(判断有没有元素)和取出(如果有，取出),对元素的判断和取出是一种规则，该规则就是Iterator接口，接口中定义了判断和取出的方法，而集合中的内部类实现了该接口，复写了判断和取出方法,将具体的判断取出细节封装成内部类，然后对外提供一个公有的iterator()方法，该方法创建内部类对象并返回，因为内部类实现了Iterator接口，所以iterator()方法的返回值可以用Iterator接口类型来接受（多态）

iterator()方法返回一个Iterator类型的对象，可以用这个对象调用接口(规则)中的判断和取出方法，即next()，hasNext()等...

这些方法都是复写Iterator接口之后的具体实现方式，我们在使用的时候，不需要了解具体实现方式，只要根据接口使用方法即可,这就是内部类的设计应用

迭代器是取出方式，会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述。通过容器的iterator()方法获取该内部类的对象。

2、迭代器的操作
boolean hasNext()：判断是否有下一个元素可以迭代

E next()：返回迭代的下一个元素

void remove()：移除元素

注：在迭代时循环中next调用一次，就要hasNext判断一次。

3、迭代注意事项

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object，所以要记得类型转换。

代码演示
```java
import java.util.*;
class  CollectionDemo
{
    public static void main(String[] args) 
    {}
    public static void method_get()
    {
        ArrayList al = new ArrayList();
 
        //1，添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
 
        //iterator()方法的返回值是一个Iterator类型的接口
        Iterator it = al.iterator();//获取迭代器
         
        //迭代器用于取出集合中的元素。
        while(it.hasNext())//当没有元素时，hasNext返回假，循环结束
        {
            sop(it.next());//返回下一个元素，即对象
        }
 
        //推荐使用for循环，循环结束后it变成垃圾，会被回收清空
        for(Iterator it = al.iterator(); it.hasNext() ; )
        {
            sop(it.next());
        }
    }
 
    public static void base_method()
    {
        //创建一个集合容器。使用Collection接口的子类。ArrayList
        ArrayList al = new ArrayList();
 
        //1，添加元素。
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
         
        //2，获取个数。集合长度。
        sop("size:"+al.size());
 
        //3，删除元素。
        al.remove("java02");
        al.clear();//清空集合。
 
        //4，判断元素。
        sop("java03是否存在:"+al.contains("java03"));
        sop("集合是否为空？"+al.isEmpty());
 
        //打印集合。
        sop("集合:"+al);[对象一一列举]
    }
    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.addAll(al1);//将al1中的所有元素加到al2中
 
        //获取交集，al1中只会保留和al2中相同的元素。
        al1.retainAll(al2);
         
        //去除交集，al1中只会保留和al2中不同的元素。
        al1.removeAll(al2);
 
        sop("al1:"+al1);
        sop("al2:"+al2);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
```
# Collection的子类List
List是Collection的常用子接口之一，元素是有序的，因为该集合体系有索引，所以元素可以重复

所属关系:

List

|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步
    |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步
    |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低

## List中的特有方法
凡是可以操作角标的方法都是该体系特有的方法

1、增加
void add(int index,E element)：在列表的指定位置插入指定元素

boolean addAll(int index,Collection<? extends E> c)：在指定位置增加c集合的所有元素，若省略位置参数，则在当前集合的后面依次添加元素

2、删除
E remove(int index)：删除指定角标的元素，并把该元素返回

3、修改
E set(int index,E element)：把index角标位置元素改成element，并返回该位置的原有值

4、查询
E get(int index)：返回index位置的元素

List<E> subList(int fromIndex,int toIndex)：获取该集合的字迹，包含fromIndex不包含toIndex

5、其他
ListIterator<E> listIterator()：List特有的迭代器

int indexOf(Object o)：返回o第一次出现的角标，不存在则返回-1

注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

上述方法的代码演示
```java
import java.util.*;
class ListDemo 
{
    public static void main(String[] args) 
    {}
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void method()
    {       
        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);
 
        //获取所有元素。除了迭代，还可以用遍历获取，因为有索引
        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());
        }
 
 
        //通过indexOf获取对象的位置。
        sop("index="+al.indexOf("java02"));
 
        List sub = al.subList(1,3);
 
        sop("sub="+sub);
    }
}
```
## ListIterator
1、概述
ListIterator是Iterator的子接口

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

2、ListIterator特有的方法
void add(E e)：将指定的元素插入列表

void set(E e)：用指定元素替换 next 或 previous 返回的最后一个元素

ListIterator的代码演示
```java
import java.util.*;
class ListDemo 
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();
 
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
         
        //在迭代过程中，准备添加或者删除元素。
 
        Iterator it = al.iterator();
        //上面添加了三个元素，此时迭代器只知道集合中有三个元素
        //而在下面迭代过程中，再次添加，迭代不知道取不取
 
        while(it.hasNext())
        {
            Object obj = it.next();
 
            if(obj.equals("java02"))
                //al.add("java008");这个操作会抛出并发修改异常
                //因为有了迭代，现在可以用过迭代和集合方法两种方式操作集合
                //但在迭代过程中，用集合方法操作集合，会产生安全隐患，抛出并发修改异常
                //避免这种异常的方法是，同一时间用用一种方法操作集合
                //要么用迭代要么用集合方法，不要一起使用
                 
                it.remove();
            sop("obj="+obj);//还是会打印java02，因为it.remove()是将java02从集合中移除
            //但java02这个对象还在，并且被obj所指向，所以打印obj会打印java02
 
 
        }
        sop(al);
         
         
        //下面开始演示列表迭代器。
         
        ListIterator li = al.listIterator();
 
         
        //sop("hasPrevious():"+li.hasPrevious());false，判断上一个是不是有元素
 
        while(li.hasNext())
        {
            Object obj = li.next();
 
            if(obj.equals("java02"))
                //li.add("java009");
                li.set("java006");
                //在迭代过程中可以对元素进行增删改查
 
 
        }
        //还可以反向迭代
        while(li.hasPrevious())
        {
            sop("pre::"+li.previous());
        }
        //sop("hasNext():"+li.hasNext());
        //sop("hasPrevious():"+li.hasPrevious());
 
 
        sop(al);
    }
}
```
## 枚举Enumeration
枚举：
就是Vector特有的取出方式。Vector有三种取出方式

其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

特有方法:
boolean hasMoreElements()：相当于Iterator的hasNext()方法

E nextElement()：相当于Iterator的next()方法

枚举的代码演示
```java
import java.util.*;
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
LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

特有方法：

1、增加
void addFirst(E e)：将指定元素插入此列表的开头

void addLast(E e)：将指定元素添加到此列表的结尾

2、获取，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
E getFirst()：返回此列表的第一个元素

E getLast()：返回此列表的最后一个元素

3、删除元素并获取，如果集合中没有元素，会出现NoSuchElementException
E removeFirst()：移除并返回此列表的第一个元素

E removeLast()：移除并返回此列表的最后一个元素

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

1、增加
offerFirst()

offerLast()

2、获取，但不删除元素。如果集合中没有元素，会返回null
peekFirst()

peekLast()

3、删除元素并获取，如果集合中没有元素，会返回null
pollFirst()

pollLast()

## List集合练习代码示例
去除ArrayList集合中的重复元素
```java
import java.util.*;
 
class ArrayListTest 
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    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");
 
 
        /*
        在迭代时循环中next调用一次，就要hasNext判断一次。
        不要在循环体中出现两次next，
        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;
    }
}
```

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如：存人对象。同姓名同年龄，视为同一个人。为重复元素
```java
import java.util.*;
/*
思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。
List集合判断元素是否相同，依据是元素的equals方法。所以要复写Person中的equals方法，确定如何判断重复元素
而List中很多方法都用到了判断元素是否相同，所以在往List集合中存自定义对象时，自定义对象的equals一定要根据需求复写
*/
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;
        //System.out.println(this.name+"....."+p.name);
 
        return this.name.equals(p.name) && this.age == p.age;
        //这里的equals方法是String的方法，和上面的不冲突
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class ArrayListTest2 
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();
 
        al.add(new Demo());
 
        al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
        //al.add(new Person("lisi02",32));
        al.add(new Person("lisi02",32));
        al.add(new Person("lisi04",35));
        al.add(new Person("lisi03",33));
        //al.add(new Person("lisi04",35));
 
         
        //al = singleElement(al);
 
        sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。
 
 
        Iterator it = al.iterator();
 
 
        while(it.hasNext())
        {
            //it.next()是Object类型的，Object中没有getName和getAge方法，所以要向下转型为Person
            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;
    }
}
```
使用LinkedList模拟一个堆栈或者队列数据结构
```java
import java.util.*;
/*
堆栈：先进后出  如同一个杯子。
队列：先进先出 First in First out  FIFO 如同一个水管。
 
*/
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()
    {
        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());
        }
    }
}
```
# Collection的子类Set

Set是Collection的常用子接口之一，元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。

所属关系:

Set

|--HashSet:底层数据结构是哈希表。线程不同步。判断元素是否相同，先依据元素的hashcode方法，在判断equals方法。

|--TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0.

Set集合的功能和Collection是一致的，没有特有方法

注：

Set集合取出只有一种方式，那就是迭代器，取出之后是无序的，因为对象都有地址值，在哈希表中是用地址值进行排序的，取出自然就无序了

add方法的返回值是boolean型，用途在Set集合中，一个元素第一次存入，存成功了，会返回true，如果再存相同元素，就会失败返回false

## Set下的HashSet子类
哈希表介绍，在内存中有一个专门存放地址值的，就是哈希表，哈希表中元素的顺序不是按照存入的顺序，而是按照地址值的顺序，所以在哈希表中的顺序和存入的顺序不一定一致

HashSet会确保元素的唯一性，是通过调用元素的两个方法，hashCode和equals来完成。如果存放的哈希值相同(覆盖了Object中的hashCode可以返回相同的哈希值)才会调用equals是否为true，以判断是否为同一个元素，如果元素的哈希值不同，不会调用equals方法。

## Set下的TreeSet子类
1、概述
a.底层的数据结构为二叉树结构

b.TreeSet是要对元素进行排序的，TreeSet对要添加的元素的要求是，必须具备比较性，否则无法运行，抛出异常

c.保证元素唯一性的依据：compareTo方法的返回值确定较大较小或相等，相等时不予存入

![](https://statics.caijw.com/uploads/2014/09/BLaXPcza5Otgb8yjjvehoi9N0boqdX19jKm7jXr5.jpeg)
排序的两种方式
当主要条件相同时，一定判断一下次要条件。

1）第一种排序方式：自然排序

让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。

代码示例：
```java
import java.util.*;
/*
需求：
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。
*/
class TreeSetDemo 
{
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();
 
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi08",19));
        //ts.add(new Student("lisi007",20));
        //ts.add(new Student("lisi01",40));
 
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}
 
 
class Student implements Comparable//该接口强制让学生具备比较性。
{
    private String name;
    private int age;
 
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
 
    public int compareTo(Object obj)
    {
 
        //return 1;
         
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s = (Student)obj;
 
        System.out.println(this.name+"....compareto....."+s.name);
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
 
    public String getName()
    {
        return name;
 
    }
    public int getAge()
    {
        return age;
    }
}
```
第二种排序方式：比较器

当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器为主

代码示例:

```java
import java.util.*;
//定义一个类，实现Comparator接口，覆盖compare方法。原理还是二叉树，根据返回值进行排序
class Student implements Comparable //该接口强制让学生具备比较性。
{
    private String name;
    private int age;
 
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
 
    public int compareTo(Object obj)//当两种排序都存在时，以比较器为主。
    {   
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s = (Student)obj;
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
        {
            return this.name.compareTo(s.name);
        }
        return -1;
    }
 
    public String getName()
    {
        return name;
 
    }
    public int getAge()
    {
        return age;
    }
}
class TreeSetDemo2 
{
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();
 
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi02",21));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi007",29));
        //ts.add(new Student("lisi007",20));
        //ts.add(new Student("lisi01",40));
 
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}
 
class MyCompare implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        Student s1 = (Student)o1;
        Student s2 = (Student)o2;
 
        int num = s1.getName().compareTo(s2.getName());
        if(num==0)
        {
 
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
            /*
            if(s1.getAge()>s2.getAge())
                return 1;
            if(s1.getAge()==s2.getAge())
                return 0;
            return -1;
            */
        }
 
         
        return num;
 
    }
}
```
# 泛型
## 概述
1、JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
2、格式：通过<>来定义要操作的引用数据类型。
2、好处
a.将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。

b、避免了强制转换的麻烦。

## 什么时候使用泛型
通常在集合框架中很常见，只要见到<>就要定义泛型。

<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
代码示例：
```java
import java.util.*;
class GenericDemo 
{
    public static void main(String[] args) 
    {
 
        ArrayList<String> al = new ArrayList<String>();
 
        al.add("abc01");
        al.add("abc0991");
        al.add("abc014");
 
        //al.add(4);//al.add(new Integer(4));
         
 
        Iterator<String> it = al.iterator();
        while(it.hasNext())
        {
            String s = it.next();
 
            System.out.println(s+":"+s.length());
        }
    }
}
```
## 泛型类的介绍和使用
什么时候定义泛型类？
当类中要操作的引用数据类型(只能是引用数据类型，基本数据类型不确定时不可以使用泛型)不确定的时候，早期定义Object来完成扩展
```java
class Worker
{
}
class Student
{
}
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}
class  GenericDemo3
{
    public static void main(String[] args) 
    {
 
        Tool t = new Tool();
        t.setObject(new Worker());
        //t.setObject(new Student());向里面传入错误的参数时，编译正常，运行时会抛出类型转换异常
        Worker w = (Worker)t.getObject();
    }
}

```

为了提高程序的安全性，出现了泛型，再出现泛型之后，就通过定义泛型来完成扩展

```java
class Worker
{
}
class Student
{
}
class Utils<QQ>
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }
    public QQ getObject()
    {
        return q;
    }
}
class  GenericDemo3
{
    public static void main(String[] args) 
    {
 
        Utilsu = new Utils<Worker>();
        //使用泛型类时，在定义时自己在<>中确定要传入得参数的类型
         
        u.setObject(new Worker());
        //u.setObject(new Student());如果传入错误参数类型，会在编译时期报错
        Worker w = u.getObject();;//不需要强制转换类型
    }
}
```
## 泛型方法的介绍和使用
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有方法要操作的类型就已经固定了。

如下所示：
```java
class Demo<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public void print(T t)
    {
        System.out.println("show:"+t);
    }
 
}
class GenericDemo4 
{
    public static void main(String[] args) 
    {
        Demo<Integer> d = new Demo<Integer>();
        //泛型类在定义时就指定类型，这时类中的方法如果使用的是泛型的参数，那么只能使用指定的类型作为参数
         
        d.show(new Integer(4));
        d.print("hah");//编译报错
         
        //方法想要使用不同类型的参数，就只能在定义一个对象
        //但是在定义一个对象，类型又被指定，还是只能使用指定的类型作为参数
 
        Demo<String> d1 = new Demo<String>();
        d1.print("haha");
        d1.show(5);//编译报错
    }
}
```

这时泛型类就出现了局限性，为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

特殊之处：
静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上
```java
class Demo
{
    public <T> void show(T t)
    {
        System.out.println("show:"+t);
    }
     
    //这里的Q也可以写T，和上面的不冲突，因为泛型定义后有自己的作用范围
    //泛型类是整个类中有效，方法是整个方法有效
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
}
class GenericDemo4 
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();
        d.show("haha");
        d.show(new Integer(4));
        d.print("heihei");//实现了传什么就接受什么，摆脱类一确定类中方法参数类型就确定的局限
    }
}
```

## 泛型类和泛型方法的注意事项

泛型类和方法可以同时定义，但要注意泛型的作用范围,如果使用了泛型类的泛型作为参数类型的函数，参数类型在定义类时已经定义，不能改变

如需定义泛型方法，需注意方法中的类型和类中的类型不能一样，需要定义一个其他类型

```java
class Demo<T>
{
    public  void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)//泛型方法的参数和泛型类不能一样
    {
        System.out.println("print:"+q);
    }
    public  static <W> void method(W t)//静态方法不能调用泛型类的参数，只能自己定义泛型方法
    {
        System.out.println("method:"+t);
    }
}
class GenericDemo4 
{
    public static void main(String[] args) 
    {
        Demo <String> d = new Demo<String>();
        d.show("haha");
        //d.show(4);
        d.print(5);
        d.print("hehe");
 
        Demo.method("hahahahha");
    }
}
```

## 泛型接口的介绍和使用

自定义接口用到泛型的不多，只会用到JAVA提供的泛型接口，只要了解原理就可以,泛型定义在接口上。

接口定义泛型，类在实现的时候有两种实现方法

```java
interface Inter<T>
{
    void show(T t);
}
class InterImpl_1 implements Inter<String>//实现时候可以确定传入类型
{
    public void show(String t)
    {
        System.out.println("show :"+t);
    }
}
class InterImpl_2<T> implements Inter<T>//实现时候不能确定传入类型，此时和泛型类一样
{
    public void show(T t)
    {
        System.out.println("show :"+t);
    }
}
class GenericDemo5 
{
    public static void main(String[] args) 
    {
        InterImpl_1 i = new InterImpl_1();//已经定义好，只能传字符串
        i.show("haha");
 
        InterImpl_2<Integer> i = new InterImpl_2<Integer>();//和泛型类一样
        i.show(4);
 
    }
}
```

## 通配符与泛型限定
1、当传入的类型不确定时，可以使用通配符？。也可以理解为占位符。使用通配符的好处是可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩展性。
2、泛型的限定:
上限:？ extends E: 可以接收E类型或者E的子类型。
下限:？ super E: 可以接收E类型或者E的父类型。

# 集合框架顶层之Map

Map是一个接口，和Collection接口一样同属于集合框架的顶层,该体系存储的是一对数据，键值对，而且要确保键的唯一性

所属关系:

Map

|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。

|--HashMap:底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。

|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

注：Map和Set看上去很像，其实Set在底层就是调用了Map集合的方法

## Map集合中的共性方法
1、增加
V put(K key,V value)：添加元素，如果添加时，存在该键值，那么新键值对会覆盖老键值对，并返回被覆盖的值。

void putAll(Map<? extends K,? extends V> m)：添加一个集合

2、删除
void clear()：清空集合中的所有键值对

V remove(Object key)：删除键为key的映射关系(如果存在，返回key对应的值)，如果不存在返回null

3、判断
boolean containsKey(Object key)：判断该键是否存在

boolean containsValue(Object value)：判断该值是否存在

boolean isEmpty()：判断集合是否为空

4、获取
V get(Object key)：通过键获取值，如果不存在返回null

int size()：获取该集合的长度

Collectionvalues()：获取Map集合中所以得值，返回一个Collection集合

还有两个取出方法，是map集合的重点
Set<K> keySet()：将集合的所有键存储到一个Set集合中，返回该集合

Set<Map.Entry<K,V>> entrySet()：将集合的所有映射关系存储到一个Set集合中，返回该集合

注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。（虽然在hashMap中可以存入null键，会影响正常的判断，但由于大部分开发null键无意义，故而可以使用这种方法进行判断）
上述方法的代码演示：
```java

import java.util.*;
class  MapDemo
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();
 
        //添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
        //并put方法会返回被覆盖的值。
        System.out.println("put:"+map.put("01","zhangsan1"));
        System.out.println("put:"+map.put("01","wnagwu"));
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
 
        System.out.println("containsKey:"+map.containsKey("022"));
        //System.out.println("remove:"+map.remove("02"));
 
        System.out.println("get:"+map.get("023"));
 
        map.put("04",null);
        System.out.println("get:"+map.get("04"));
        //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
 
 
         
        //获取map集合中所有的值。
        Collection<String> coll = map.values();
 
        System.out.println(coll);
        System.out.println(map);
 
 
    }
}
```
## Map集合的两种取出方式
Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。

1、Set<K> keySet()：将集合的所有键存储到一个Set集合中，返回该集合，在通过集合的迭代器获取Set集合中存放的Map集合的键，在用Map集合的get方法获取该键对应的值，从而得到Map集合的所有元素并对其操作
代码示例：

```java
import java.util.*;
class MapDemo2 
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();
 
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        map.put("01","zhangsan1");
        map.put("04","zhangsan4");
 
 
        //先获取map集合的所有键的Set集合,keySet();
        Set<String> keySet = map.keySet();
 
        //有了Set集合。就可以获取其迭代器。
        Iterator<String> it = keySet.iterator();
 
        while(it.hasNext())
        {
            String key = it.next();
            //有了键可以通过map集合的get方法获取其对应的值。
            String value  = map.get(key);
            System.out.println("key:"+key+",value:"+value);
        }
    }
}
```

![](https://statics.caijw.com/uploads/2014/09/El2rxBCcQ30pgpZewJA5uvSF0nLBTLT7h7oJUsCQ.jpeg)

1、Set<Map.Entry<K,V>> entrySet()：将集合的所有映射关系存储到一个Set集合中，返回该集合,而这个映射关系的类型就是Map.Entry
Entry也是一个接口，它是Map接口中的一个内部接口，之所以定义在内部是因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

类似于迭代器，这个接口中定义了获取键和获取值的抽象方法，该接口只能通过entrySet方法创建一个存储着该接口子类类型的Set集合，而Set集合迭代器迭代到的就是Map.Entry的子类对象

代码示例：
```java
import java.util.*;
class MapDemo2 
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();
 
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");
        map.put("01","zhangsan1");
        map.put("04","zhangsan4");
 
        //将Map集合中的映射关系取出。存入到Set集合中。
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
 
        Iterator<Map.Entry<String,String>> it = entrySet.iterator();
 
        while(it.hasNext())
        {
            Map.Entry<String,String> me = it.next();
            String key = me.getKey();
            String value = me.getValue();
 
            System.out.println(key+":"+value);
 
        }
    }
}
```
![](https://statics.caijw.com/uploads/2014/09/gZpxiz2xoHMgwxZsOAkvvFIuKIY2IWHvS9p2aTFt.jpeg)

## Map集合及其子类集合的练习
什么时候使用map集合呢？
当数据之间存在这映射关系时，就要先想map集合。

练习1：
每一个学生都有对应的归属地。学生Student，地址String。

学生类属性：姓名，年龄。

注意：姓名和年龄相同的视为同一个学生,保证学生的唯一性。

```java
/*
思路：
1，描述学生。
2，定义map容器。将学生作为键，地址作为值。存入。
3，获取map集合中的元素。
*/
import java.util.*;
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
     
    public int compareTo(Student s)
    {
        int num = new Integer(this.age).compareTo(new Integer(s.age));
 
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }
 
    public int hashCode()
    {
        return name.hashCode()+age*34;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            throw new ClassCastException("类型不匹配");
 
        Student s = (Student)obj;
 
        return this.name.equals(s.name) && this.age==s.age;
         
 
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public String toString()
    {
        return name+":"+age;
    }
}
class  MapTest
{
    public static void main(String[] args) 
    {
        HashMap<Student,String> hm = new HashMap<Student,String>();
 
        hm.put(new Student("lisi1",21),"beijing");
        hm.put(new Student("lisi1",21),"tianjin");
        hm.put(new Student("lisi2",22),"shanghai");
        hm.put(new Student("lisi3",23),"nanjing");
        hm.put(new Student("lisi4",24),"wuhan");
 
        //第一种取出方式 keySet
 
        Set<Student> keySet = hm.keySet();
 
        Iterator<Student> it = keySet.iterator();
 
        while(it.hasNext())
        {
            Student stu = it.next();
            String addr = hm.get(stu);
            System.out.println(stu+".."+addr);
        }
 
 
        //第二种取出方式 entrySet
        Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
 
        Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
         
        while(iter.hasNext())
        {
            Map.Entry<Student,String> me = iter.next();
            Student stu = me.getKey();
            String addr = me.getValue();
            System.out.println(stu+"........."+addr);
        }
    }
}
```
练习2：
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。希望打印结果：a(1)c(2).....

通过结果发现，每一个字母都有对应的次数,说明字母和次数之间都有映射关系,当发现有映射关系时，可以选择map集合,因为map集合中存放就是映射关系。
```java
/*
思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。
2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。
3，遍历字符数组。
    将每一个字母作为键去查map集合。
    如果返回null，将该字母和1存入到map集合中。
    如果返回不是null，说明该字母在map集合已经存在并有对应次数。
    那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
4，将map集合中的数据变成指定的字符串形式返回。
*/
import java.util.*;
class  MapTest3
{
    public static void main(String[] args) 
    {
        String s= charCount("ak+abAf1c,dCkaAbc-defa");
        System.out.println(s);
    }
     
    public static String charCount(String str)
    {
        char[] chs = str.toCharArray();
 
        TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
 
         
        int count = 0;//虽然定义在for循环中第一行可以不用最后重置为0，但为节省空间考虑。还是定义在外面好
        for(int x=0; x<chs.length; x++)
        {
             
 
            if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
                continue;
 
            Integer value = tm.get(chs[x]);
 
             
            if(value!=null)
                count = value;
            count++;
            tm.put(chs[x],count);//直接往集合中存储字符和数字，为什么可以，因为自动装箱。
 
            count = 0;//每次循环结束都要清为0
 
        }
 
        //System.out.println(tm);
 
        StringBuilder sb = new StringBuilder();
 
        Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
        Iterator<Map.Entry<Character,Integer>>  it = entrySet.iterator();
 
        while(it.hasNext())
        {
            Map.Entry<Character,Integer> me = it.next();
            Character ch = me.getKey();
            Integer value = me.getValue();
            sb.append(ch+"("+value+")");
        }
        return sb.toString();
    }
}
```
## Map扩展知识
在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。

代码示例:
```java
/*  
map集合被使用是因为具备映射关系。 
以下是班级对应学生，而学生中学号对应着姓名的映射关系： 
"yureban"   Student("01" "zhangsan"); 
"yureban" Student("02" "lisi");  
"jiuyeban" "01" "wangwu"; 
"jiuyeban" "02" "zhaoliu"; 
  
就如同一个学校有多个教室。每一个教室都有名称。 
*/ 
import java.util.*;  
   
class MapExpandKnow  
{  
    public static void main(String[] args)   
    {  
        //预热班集合  
        HashMap<String,String> yureban=new HashMap<String,String>();  
        //就业班集合  
        HashMap<String,String> jiuyeban=new HashMap<String,String>();  
        //学校集合  
        HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();  
           
        //学校中班级集合和名称的映射  
        czbk.put("yureban",yureban);  
        czbk.put("jiuyueban",jiuyeban);  
           
        //预热班级中学号与姓名的映射  
        yureban.put("01","zhangsan");  
        yureban.put("02","lisi");  
           
        //就业班级中学号与姓名的映射  
        jiuyeban.put("01","wangwu");  
        jiuyeban.put("02","zhouqi");  
               
            //直接显示全部学生信息  
        getAllStudentInfo(czbk);  
   
    }  
    //定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少  
    public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm)  
    {  
        for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式  
        {  
            String s= it.next();//班级名称  
            System.out.println(s+":");  
            HashMap<String,String> stu=hm.get(s);//班级集合  
   
            getStudentInfo(stu);  
        }  
    }  
       
    //获取班级中学生的信息，包括姓名和学号  
    public static void getStudentInfo(HashMap<String,String> hm)  
    {  
        for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )  
        {  
            String key=it.next();//学号  
            String value=hm.get(key);//姓名  
            System.out.println(key+"..."+value);  
        }  
    }  
}  
```
-separator-