Java集合框架的学习

本节内容总结来自传智播客毕向东老师的公开课，感谢毕向东老师 ！如有错误之处，欢迎大家指教 ！

Collection集合常用方法：

  增加、删除、大小、包含、为空、清空、迭代、并交差；

  boolean add(E o);  boolean remove(Object o);  int size();  boolean contains(Object o);  boolean isEmpty();  void clear();  Iterator<E> iterator();

  boolean addAll(Collection c);  boolean retainAll(Collection c);  boolean removeAll(Collection c);

Set集合常用的方法：

  与Collection集合拥有的方法一样；

List集合常用的方法：

  List集合的方法中，带索引参数（角标）的都是新增的方法；带角标的操作都是数组原理；

  除了继承Collection集合的方法，还有以下自己独有的方法，都与索引（下标）有关：

  增加、删除、修改（只能是修改，不能是插入）、查找（获取）元素、查找元素所在位置（两种）；

  void add(int index, E e);  E remove(int index);  E set(int index, E e);  E get(int index);  int indexOf(Object o);  int lastIndexOf(Object o);

Map集合常用的方法：

  增加、删除、修改、查找（获取）、大小、包含、为空、清空、迭代

  V put(K k, V v);  V remove(Object k);  put()方法也起到修改功能  V get(Object k);  int size();  boolean containsKey(Object k);

  boolean containsValue(Object v);  boolean isEmpty();  void clear();

为什么会有集合；

为什么会有这么多不同的集合框架；

集合与数组的区别；

集合类的关系图；

集合中存放的是对象实体还是对象的引用（地址），并想一下内存图；

集合中取出元素并操作的常用方法；

集合中获取所有元素的常用方法；

Collection接口的常见两个子接口及比较；

List接口下的常用类及比较；

List集合独有的迭代器；

Vector特有的迭代器（枚举）；

LinkedList中一些方法的版本迭代；

List集合中如何实现去除重复元素；

Set接口下的常用类及比较；

Set集合中，如何实现去除重复元素；

Set集合中，如何实现对元素进行排序；（应该不是只针对TreeSet集合）；

泛型；

Map集合下的常用类；

Map集合取出元素的方法；

集合框架中的工具类；

增强型for循环；

为什么会有集合：

  数据多了，用对象存；对象多了，用集合（和数组）存；

为什么会有这么多不同的集合框架（容器）：

  因为每个容器对数据的存储方式都有不同；存储方式就是指数据结构；

集合与数组的区别：

 数组的长度是固定的，集合的长度是可变的；

 数组只能存储同一类型数据，集合能存储不同类型数据；

 数据可以存基本类型数据，集合只能存对象；

集合框架的关系图：

 

集合中存放的是对象实体还是对象的引用（地址）

  集合中存放的都是对象的引用（地址）；

集合中取出元素并操作的常用方法：

  使用迭代器：就是集合中取出元素的一种方式；

  有的接口（实现类）有专门的取出元素的方法：

  List集合中：get(index)  subList(from,to)  Iterator

集合中获取所有元素的常用方法：

  for循环

  加强型for循环

  迭代器

Collection接口的常见两个子接口及比较：

 List接口：

  元素是有序的，元素可以重复，因为有索引；

 Set接口：

  元素是无序的（存入和取出的顺序不一定一致），元素不可以重复；

List接口下的常用类及比较：

ArrayList：底层的数据结构使用的是数组结构；  特点：查询元素速度很快，但增删稍慢；  线程不同步

LinkedList：底层的数据结构使用的是链表结构；  特点：增删速度很快，但查询稍慢；

Vector：底层的数据结构使用的是数组结构；  特点：查询，增删速度都很慢，被ArrayList替换了；  线程同步

java集合框架还专门提供加锁的功能，把你不安全的给我，我给你安全的，解决线程不同步问题；

List集合独有的迭代器：

  ListIterator（接口），继承自Iterator接口；

  使用迭代器过程中，有两种操作元素的方式：使用集合对象的方法操作元素；使用迭代器的方法操作元素；

  在迭代时，不可以用集合对象的方法操作集合中的元素，因为会发生并发修改异常；要用迭代器自己的方法操作数据；

  Iterator接口只有删除元素的操作，而ListIterator接口有增加、删除、修改等操作；（实例中有疑问）

Vector特有的迭代器（枚举）：

  已经被Iterator替代，因为它的功能和Iterator一样，但它的名称和它的方法名过长，没有Iterator好使；

LinkedList中一些方法的版本迭代：

JDK1.6之前：

  addFirst()、addLast()：添加元素

  getFirst()、getLast()：获取元素，但不删除元素；如果集合中没有元素，会抛出NoSuchElementException

  removsFirst()、removeLast()：获取元素，但同时元素也被删除；如果集合中没有元素，会抛出NoSuchElementException

JDK1.6之后：

  offerFirst()、offerLast()：添加元素

  peekFirst()、peekLast()：获取元素，但不删除元素；如果集合中没有元素，返回null

  pollFirst()、pollLast()：获取元素，但同时元素也被删除；如果集合中没有元素，返回null

获取所有元素并删除的实现：

  使用迭代器；

  使用 pollFirst()、pollLast()方法：

  while( ! link.isEmpty() )

  {

      syso(link.pollFirst());

  }

List集合中判断元素是否相同的问题：

  集合中有自己的判断元素的方法，但不符合需求的话，就要程序员自己定义判断规则；

  集合自身只能判断对象是否相同，用equals()方法来判断:obj1.equals(obj2)；而继承自Object类的equals()方法是判断对象是否相同时判断的是对象的地址是否相同；但如果具体判断对象的属性值是否相同时，equals()方法就相当于判断对象的内容而不是地址是否相同的（其实此时用的是String类中的判断字符串内容是否相同的方法，已经重写的继承自Object类的equals()方法）；

  List集合中的contains()、remove()两个方法底层都是用equals()方法来实现的；

  程序员自己通过修改继承自Object类的equals()方法来自定义判断规则，使自定义类具体可比较性；

Set集合的两个子类：

HashSet：底层的数据结构使用的是Hash表；

TreeSet：底层数据结构是二叉树；可以对Set集合中的元素进行排序，以自然顺序进行排序；

HashSet是如何保证元素唯一性的：

是通过元素的两个方法：hashCode()和equals()；

如果元素的hashCode值相同，才会调用equals()判断是否为true；

如果元素的hashCode值不同，不会调用equals()判断是否为true；

注意：对于判断元素是否存在，以及元素删除等操作，依赖的方法是元素的hashCode()和equals()方法，先使用hashCode()；ArrayList只依赖equals()方法；

所以开发中，往集合中添加元素时，一般都会覆写hashCode()和equals()方法；

TreeSet集合对元素进行排序:

  TreeSet保证元素唯一性：依靠compareTo()方法返回值；

  TreeSet集合本身会对元素进行按自然顺序进行排序，但在实际开发中肯定不满足需求，需要程序员自定义排序规则；

  元素被放入TreeSet集合之前，必须是可以被排序的（告诉TreeSet集合如何排序），不然程序运行时会报错；或者元素不具备比较性，然TreeSet集合本身实现需要的比较规则也可以；

  TreeSet集合的两种排序方式：

    第一种：当元素不具备比较性，强制使元素具备比较性，继承Comparable接口；

    第二种：当元素不具备比较性，或者元素具备的比较性不是所需要的，实现让集合本身具备比较性；实现：在集合初始化时，就具有比较性，所以是对构造函数进行改造；

    注意：

      当两种排序都存在时，以比较器（Comparator）为准；

      排序时，当主要条件相等时，必须要再判断次要条件，直到能排除一个顺序出来；

泛型：

  JDK1.5之后出现的泛型，解决安全问题，是一种安全机制；

  好处：

    将运行时期出现的类型转换异常转移到了编译时期，方便于程序员解决问题，让运行时期出现问题较少；

    避免了强制转换的麻烦；

  什么时候使用泛型：

    通常在集合框架中很常见；

    只要见到<>就要定义泛型；

  其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可；

  什么时候使用泛型类：

    当类中要操作的引用数据类型不确定的时候使用泛型类；

  早期通过定义Object来完成扩展，现在通过定义泛型来完成扩展；

  方法删规定以泛型比类上定义泛型扩展性更好；

  当类上个方法上都定义泛型时，并不冲突，以方法上定义的泛型为准；

  泛型类上定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了；为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上；注意：静态方法不可以访问类上定义的泛型，所以如果静态方法操作的引用数据类型不确定的话，可以将泛型定义在静态方法上；

  泛型的限定：

    ? extends E：可以接收E类型或者E的子类型，上限；

    ? super E：可以接收E类型或者E的父类，下限；

Map集合下的常用类：

HashTable：底层的数据结构使用的是哈希表； 不可以存入null键null值； 该集合是线程同步的；  效率低；

HashMap：底层的数据结构使用的是哈希表； 可以存入null键null值； 该集合不是线程同步的；  效率高；

TreeMap：底层的数据接口使用的是二叉树； 线程不同步； 可以用于给Map集合中的键进行排序；

将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的；

如果数组中的元素都是对象，那么转成集合时，数组中的元素就直接转成集合中的元素；

如果数组中的元素都是基本类型，那么会将该数组作为集合中的元素存在；

集合转成数组时，指定类型的数组要定义成多长：当指定类型数组的长度小于集合的size时，那么该方法的内部会创建一个新的数组，长度为集合的size；当指定类型数组的长度大于集合的size时，该方法不会再创建一个新的数组，而是使用传递过来的数组；所以创建一个刚刚好的数组最优；

为什么要将集合转成数组：

  限定对元素的操作；集合可以增删元素，转成数组之后，就能进行元素增删操作了；

foreach：

只能获取集合中的元素，但不能对集合进行操作；

迭代器：

除了遍历集合元素，还可以进行remove集合中元素的操作；

如果使用ListIterator，还可以在遍历元素时候进行增删改查的动作；

for与foreach的区别：

foreach必须有被遍历的目标；

方法的可变参数一定要定义在参数列表的最后面；

静态导入：

当类重名时，需要指定具体的包名；

当方法重名时，需要制定具体的所属对象或类；

一些实例：

/**
 * 迭代器的使用
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorDemo
{
    public static void main(String[] args)
    {
        iterator();
    }
    
    public static void iterator()
    {
        // 现在集合中添加元素
        ArrayList al = new ArrayList();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        
        // 使用迭代器，可以对每一个元素进行操作
        // 通过iterator()方法获得Iterator接口的子对象
        Iterator it = al.iterator();  
        // 判断后面是否还有元素
        while(it.hasNext())
        {
            // 打印出后面这个元素
            System.out.println(it.next());
        }

         // 另外一种书写方式
        // 使用这种方式，迭代器对象使用完之后就被销毁了
        for(Iterator it2 = al.iterator(); it2.hasNext(); )
        {
            System.out.println(it2.next());
}
    }
}

/**
 * 功能：List集合特有的迭代器
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class IteratorDemo2
{
    public static void main(String[] args)
    {
        // iterator();
        listIterator();
    }
    
    public static void iterator()
    {
        ArrayList al = new ArrayList();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        System.out.println(al);
        
        Iterator it = al.iterator();  
        while(it.hasNext())
        {
            Object obj = it.next();
            if(obj.equals("java2"))
            {
                // 以下写法是错误的，会产生并发异常
                // 对元素操作，要么全用集合的方法，要么全用迭代器的方法
                // al.add("java4");
                
                // 将java2的引用从集合中删掉
                // 迭代器本身只有这个删除元素方法，比较局限
                it.remove();
            }
            
            // 还是能打印出java2，因为obj还在引用它
            System.out.println(obj);
        }
        
        // 打印不出来java2了，因为al对它的引用已经被删掉了
        System.out.println(al);
    }
    
    public static void listIterator()
    {
        ArrayList al = new ArrayList();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        System.out.println(al);
        
        ListIterator lit = al.listIterator();
        while(lit.hasNext())
        {
            Object obj = lit.next();
            if(obj.equals("java2"))
            {
                // 在java2后面添加一个java4
                lit.add("java4");
            }
            System.out.println(obj);
        }
        
        System.out.println(al);
    }
}

/**
 * 功能：Vector特有的迭代器，枚举 
 */
package collection;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo
{
    public static void main(String[] args)
    {
        Vector vt = new Vector();
        vt.add("java1");
        vt.add("java2");
        vt.add("java3");
        
        Enumeration<String> ea = vt.elements();
        while(ea.hasMoreElements())
        {
            System.out.println(ea.nextElement());
        }
    }
}

/**
 * 功能：集合中去除重复元素
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;

public class RevDuplElement
{
    public static void main(String[] args)
    {
        ArrayList list = new ArrayList();
        list.add("one");
        list.add("one");
        list.add("two");
        list.add("two");
        list.add("three");
        list.add("three");
        
        System.out.println(test(list));
    }
    
    public static ArrayList test(ArrayList list)
    {
        ArrayList newList = new ArrayList();
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!newList.contains(obj))
            {
                newList.add(obj);
            }
        }
        return newList;
    }
}

/**
 * 功能：向下转型
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;

public class Convert
{
    public static void main(String[] args)
    {
        ArrayList<Person3> list = new ArrayList<Person3>();
        list.add(new Person3("zhangsan",25));
        // add()方法里面的参数对象是Object，所以上面一句涉及到向上转型，具体如下
        // Object obj = new Person3("zhangsan",25);
         // list.add(obj);
        list.add(new Person3("lisi",26));
        list.add(new Person3("wangwu",27));
        
        // 没有使用泛型
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            // 下面这样写(在没有使用泛型的情况下)是错误的，因为it.next()返回的对象是Object类型，不是Person3类型
            // 所以不会有getName()方法，需要向下转型
            // System.out.println("name" + it.next().getName());
            
            // 正确操作
            Person3 person = (Person3) it.next();
            System.out.println("name:" + person.getName() + ",age:" + person.getAge());
        }
        
        // 使用泛型
        Iterator<Person3> it2 = list.iterator();
        while(it2.hasNext())
        {
            System.out.println("name:" + it2.next().getName());
            // 不能这样写，因为每用一次next()都是找后面一个元素，而不是使用当前元素
            // System.out.println("name:" + it2.next().getName() + ",age:" + it2.next().getAge());
        }
    }
}

class Person3
{
    private String name;
    private int age;
    
    public Person3(String name, int age)
    {
        this.name = name;
        this.age = 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;
    }
    
    @Override
    public String toString()
    {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
}

/**
 * 功能：List集合中，重写equals方法，自定义判断规则
 * 通过比较，去除集合中相同的元素
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;

public class EqualsTest
{
    public static void main(String[] args)
    {
        ArrayList list = new ArrayList();
        list.add(new Student4("lisi01", 25));
        list.add(new Student4("lisi01", 25));
        list.add(new Student4("lisi02", 22));
        list.add(new Student4("lisi03", 23));
        list.add(new Student4("lisi02", 22));
        list.add(new Student4("lisi03", 23));
        
        list = com(list);
        
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            Student4 student = (Student4) it.next();
            System.out.println(student.getName() + "," + student.getAge());
        }
    }
    
    public static ArrayList com(ArrayList list)
    {
        ArrayList newList = new ArrayList();
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            // contains()底层是用equals()方法来实现的
            // 让Studnet4的两个对象使用equals()来比较
            // 所以要修改Studnet4的equals()方法
            if(!newList.contains(obj))
            {
                newList.add(obj);
            }
        }
        
        return newList;
    }
}

class Student4
{
    private String name;
    private int age;
    
    public Student4(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    // 覆盖继承自Object的equals()
    //  形参类型必须是Object，否则不是继承自Object类的方法
    public boolean equals(Object obj)
    {
        // 注意：obj必须放在前面
        if(! (obj instanceof Student4))
        {
            return false;
        }
        
        Student4 student = (Student4) obj;
        if(this.name.equals(student.getName()) && this.age==student.getAge())
        {
            return true;
        }
        else
        {
            return false;
        }
        
    }

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

/**
 * 功能：重写hashCode()方法
 * Set集合中比较元素首先用hashCode()判断地址是否相等
 * 再用equals()判断元素内容是否相等
 */
package collection;

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

public class HashCodeTest
{
    public static void main(String[] args)
    {
        HashSet set = new HashSet();
        set.add(new Student5("lisi01",21));
        set.add(new Student5("lisi02",22));
        set.add(new Student5("lisi03",23));
        set.add(new Student5("lisi02",22));
        
        set = com(set);
        
        Iterator it = set.iterator();
        while(it.hasNext())
        {
            Student5 student = (Student5) it.next();
            System.out.println(student.getName() + "," + student.getAge());
        }
    }
    
    public static HashSet com(HashSet set)
    {
        HashSet newSet = new HashSet();
        Iterator it = set.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!(newSet.contains(obj)))
            {
                newSet.add(obj);
            }
        }
        return newSet;
    }
}

class Student5
{
    private String name;
    private int age;
    
    public Student5(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    // 重写hashCode()方法
    public int hashCode()
    {
        return name.hashCode() + age;
    }
    
    // 重写equals()方法
    public boolean equals(Object obj)
    {
        if(! (obj instanceof Student5))
        {
            return false;
        }
        
        Student5 student = (Student5) obj;
        if(this.name.equals(student.getName()) && this.age == student.getAge())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    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;
    }
    
}

/**
 * 功能：Comparable接口的使用
 */
package collection;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo
{
    public static void main(String[] args)
    {
        treeSetDemo();
    }
    
    public static void treeSetDemo()
    {
        TreeSet ts = new TreeSet();
        ts.add(new Student("t1",11));
        // 如果Student类没有实现Comparable接口，多添加下面一条数据就抛异常
        // 因为这个类中的数据没有可比较性
        ts.add(new Student("t2",12));
        ts.add(new Student("t3",13));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
        }
        
    }
    
}

// 该接口强制让学生具备比较性
class Student implements Comparable
{
    private String name;
    private int age;
    
    public Student(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
        {
            throw new RuntimeException("不是Student类");
        }
        
        Student stu = (Student)obj;
        
        if(this.age > stu.age)
            return 1;  // 只要返回正数即可
        if(this.age == stu.age)
        {
            // String类型本身也实现了Comparable接口
            return this.name.compareTo(stu.name);
        }
            
        return -1;  // 只要返回负数即可
    }

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

/**
 * 功能：Comparator的使用
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo2
{
    public static void main(String[] args)
    {
        treeSerDemo2();
    }
    
    public static void treeSerDemo2()
    {
        TreeSet ts = new TreeSet(new MyComparator());
        ts.add(new Student2("t1",11));
        // 如果Student类没有实现Comparator接口，多添加下面一条数据就抛异常
        // 因为这个类中的数据没有可比较性
        ts.add(new Student2("t2",12));
        ts.add(new Student2("t3",13));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student2 stu = (Student2)it.next();
            System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
        }
    }
}

class MyComparator implements Comparator
{

    @Override
    public int compare(Object o1, Object o2)
    {
       if(!(o1 instanceof Student2) || !(o2 instanceof Student2))
        {
            try
            {
                throw new Exception("传入的比较对象不是要求的比较对象");
            } catch (Exception e)
            {
                e.printStackTrace();
            }
}

        Student2 stu1 = (Student2)o1;
        Student2 stu2 = (Student2)o2;
        
        int num = stu1.getName().compareTo(stu2.getName());
        if(num == 0)
        {
            // int型比较方法一
            // 封装成Interger对象进行比较
            // return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
            
            // int型比较方法二
            if(stu1.getAge() > stu2.getAge())
                return 1;
            if(stu1.getAge() == stu2.getAge())
                return 0;
            return -1;
        }
        
        return num;
    }
    
}

class Student2
{
    private String name;
    private int age;
    
    public Student2(String name, int age)
    {
        this.name = name;
        this.age = 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;
    }
}

/**
 * 功能：比较字符串长度是否相等
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo3
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet(new MyStrComparator());
        ts.add("asd");
        ts.add("wer");
         ts.add("qaz");
        ts.add("qwerty");
        ts.add("df");
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

class MyStrComparator implements Comparator
{
    @Override
    public int compare(Object o1, Object o2)
    {
        String s1 = (String)o1;
        String s2 = (String)o2;
        
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num == 0)
        {
            return s1.compareTo(s2);
        }
        return num;
    }
    
}

/**
 * 功能：匿名内部类的使用
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo4
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet(new Comparator(){
            @Override
            public int compare(Object o1, Object o2)
            {
                String s1 = (String)o1;
                String s2 = (String)o2;
                
                int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
                if(num == 0)
                {
                    return s1.compareTo(s2);
                }
                return num;
            }});
        
        ts.add("asd");
        ts.add("wer");
        ts.add("qwerty");
        ts.add("df");
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

/**
 * 功能：泛型的使用
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo
{
    public static void main(String[] args)
    {
        genericDemo2();
    }
    
    // 没有使用泛型
    public static void genericDemo()
    {
        ArrayList al = new ArrayList();
        al.add("qwe");
        // 上面添加的字符串，下面添加的是int，迭代时肯定会报类型转换异常
        al.add(4);
        
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            // 需要类型转换
            // 此处在运行时会报类型转换异常
            // 在编译时不会报异常
            String s = (String)it.next();
            System.out.println(s + ":" + s.length());
        }
    }
    
    // JDK1.5之后使用泛型
    // 解决安全问题
    public static void genericDemo2()
    {
        // 指定只添加String类型数据
        ArrayList<String> al = new ArrayList<String>();
        al.add("qwe");
        // 编译时下面这条语句就报错了
        // al.add(4);
        
        // 迭代器也通过泛型指定类型
        // 后续就不需要进行内外部转换了
        Iterator<String> it = al.iterator();
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s + ":" + s.length());
        }
    }
}

/**
 * 功能：定义泛型类
 */
package collection;

public class GenericClass
{
    public static void main(String[] args)
    {
        Tool tool = new Tool();
        tool.setObject(new Teacher());
        // 没用泛型之前，需要进行强转
        Teacher teacher = (Teacher) tool.getObject();
        System.out.println(teacher);
        
        Util<Doctor> util = new Util<Doctor>();
        util.setObject(new Doctor());
        // 使用泛型之后，不需要进行强转
        Doctor doctor = util.getObject();
        System.out.println(doctor);
    }
}

// 没用泛型之前
class Tool
{
    private Object object;

    public Object getObject()
    {
        return object;
    }

    public void setObject(Object object)
    {
        this.object = object;
    }
    
}

// 用了泛型之后
class Util<Q>
{
    private Q object;
    
    public void setObject(Q q)
    {
        this.object = q;
    }
    public Q getObject()
    {
        return object;
    }
    
}

class Teacher
{
    
}

class Doctor
{
    
}

/**
 * 功能：将泛型定义在方法上
 */
package collection;

public class GenericDemo2
{
    public static void main(String[] args)
    {
        Utils ut = new Utils();
        // 可以打印字符串
        ut.show("qwe");
        // 可以打印int类型
        ut.show(12);
    }
}

class Utils
{
    public <T> void show(T t)
    {
        System.out.println("show:" + t);
    }
    
    public <Q> void print(Q q)
    {
        System.out.println("print:" + q);
    }
}

/**
 * 功能：类和方法上都定义泛型
 */
package collection;

public class GenericDemo3
{
    public static void main(String[] args)
    {
        Tools<String> tl = new Tools<String>();
        // 只能打印String类型
        tl.show("qwer");
        // 打印其他类型报错
        // tl.show(123);
        
        // 可以打印String类型
        tl.print("qwe");
        // 也可以打印其他类型
        tl.print(123);
        
        Tools.display("qwe");
        Tools.display(123);
    }
}

class Tools<T>
{
    // 这个方法的类型是跟着对象（类型T）走的
    public void show(T t)
    {
        System.out.println("show:" + t);
    }
    
    // 这个方法的类型是跟着Q走的
    public <Q> void print(Q q)
    {
        System.out.println("print:" + q);
    }
    
    // 泛型定义在返回值的前面，修饰符的后面
    public static <W> void display(W w)
    {
        System.out.println("display:" + w);
    }
}

/**
 * 功能：接口上定义泛型
 */
package collection;

public class GenericDemo4
{
    public static void main(String[] args)
    {
        InterImpl ii = new InterImpl();
        ii.show("qwe");
        
        InterImpl2<String> ii2 = new InterImpl2<String>();
        ii2.show("asd");
        
        InterImpl2<Integer> ii3 = new InterImpl2<Integer>();
        ii3.show(123);
    }
}

interface Inter<T>
{
    public void show(T t);
}

class InterImpl implements Inter<String>
{
    @Override
    public void show(String t)
    {
        System.out.println("show:" + t);
    }
}

class InterImpl2<T> implements Inter<T>
{
    @Override
    public void show(T t)
    {
        System.out.println("show:" + t);
    }
}

/**
 * 功能：泛型的高级特性
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo5
{
    public static void main(String[] args)
    {
        ArrayList<String> al1 = new ArrayList<String>();
        al1.add("qwe");
        al1.add("asd");
        al1.add("zxc");
        
        ArrayList<Integer> al2 = new ArrayList<Integer>();
        al2.add(123);
        al2.add(456);
        al2.add(789);
        
        demo(al1);
        demo(al2);
        
        demo2(al1);
        demo2(al2);
    }
    
    // 不清楚是什么类型时候，可以用？代替
    public static void demo(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println("al:" + it.next());
            // 以下使用length()是错误的
            // 因为不知道是什么类型，所以不能使用某一具体类型的特有方法
            // System.out.println(it.next().length());
        }
    }
    
    // 也可以换成T，但T代表了某一个具体类型
    // 操作方面有一点变化
    public static <T> void demo2(ArrayList<T> al)
    {
        Iterator<T> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println("al:" + it.next());
            // 使用了某一具体类型之后
            // 可以用这个具体类型来接收迭代出来的元素，并进行其他具体操作
            // T t = it.next();
            // System.out.println("al:" + t);
        }
    }
}

/**
 * 功能：泛型的高级特性2
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo6
{
    public static void main(String[] args)
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("qwe"));
        al.add(new Person("asd"));
        al.add(new Person("zxc"));
        
        ArrayList<Worker> al2 = new ArrayList<Worker>();
        al2.add(new Worker("qwe"));
        al2.add(new Worker("asd"));
        al2.add(new Worker("zxc"));
        
        ArrayList<Student6> al3 = new ArrayList<Student6>();
        al3.add(new Student6("qwe"));
        al3.add(new Student6("asd"));
        al3.add(new Student6("zxc"));
        
        // 正确
        demo(al);
        // 错误，以下两种情况都是不允许的，左右不匹配
        // ArrayList<Person> al2 = new ArrayList<Student>();
        // ArrayList<Student> al2 = new ArrayList<Person>();
        // demo(al2);
        
        demo3(al2);
        demo3(al);
        // Student6类不是Person类的子类，所以下面写法错误
        // demo3(al3);
        
        demo4(al);
        demo4(al2);
        // Student6类不是Worker类的父类，所以下面写法错误
        // demo4(al3);
    }
    
    public static void demo(ArrayList<Person> al)
    {
        Iterator<Person> it = al.iterator();
        while(it.hasNext())
        {
            Person p = it.next();
            System.out.println("name:" + p.getName());
        }
    }
    
    // 打印出所有类型
    public static void demo2(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
    
    // 打印出指定的范围：泛型限定
    // 只打印Person和它的子类
    public static void demo3(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }
    
    public static void demo4(ArrayList<? super Worker> al)
    {
        Iterator<? super Worker> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

class Person
{
    private String name;
    
    public Person(String name)
    {
        this.name = name;
    }
    
    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }
}

class Worker extends Person
{
    public Worker(String name)
    {
        super(name);
    }
}

class Student6
{
    private String name;
    public Student6(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
}

/**
 * 功能：泛型的高级应用3
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo7
{
    public static void main(String[] args)
    {
        // 使用Studnet3类的构造器
        // TreeSet<Student3> tr = new TreeSet<Student3>(new StuComparator());
        // 使用通用的比较器（父类的比较器）
        TreeSet<Student3> tr = new TreeSet<Student3>(new MyComparator2());
        tr.add(new Student3("stu4"));
        tr.add(new Student3("stu2"));
        tr.add(new Student3("stu3"));
        
        Iterator<Student3> it = tr.iterator();
        while(it.hasNext())
        {
            System.out.println("tr:" + it.next().getName());
        }
        
        // 使用Worker2类的构造器
        // TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new WorComparator());
        // 使用通用的比较器（父类的比较器）
        TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new MyComparator2());
        tr2.add(new Worker2("wor1"));
        tr2.add(new Worker2("wor5"));
        tr2.add(new Worker2("wor3"));
        
        Iterator<Worker2> it2 = tr2.iterator();
        while(it2.hasNext())
        {
            System.out.println("tr:" + it2.next().getName());
        }
    }
}

// Student3类的比较器，分开写很麻烦
class StuComparator implements Comparator<Student3>
{
    @Override
    public int compare(Student3 o1, Student3 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

// Worker2类的比较器，分开写很麻烦
class WorComparator implements Comparator<Worker2>
{
    @Override
    public int compare(Worker2 o1, Worker2 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

// Comparator<? super E>
class MyComparator2 implements Comparator<Person2>
{
    @Override
    public int compare(Person2 o1, Person2 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

class Person2
{
    private String name;
    
    public Person2(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }

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

class Student3 extends Person2
{
    // private String name;
    public Student3(String name)
    {
        super(name);
    }
}

class Worker2 extends Person2
{
    public Worker2(String name)
    {
        super(name);
    }
}

/**
 * 功能：获取Map集合数据的两种方式
 */
package collection;

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)
    {
        keySet();
        entrySet();
    }
    
    // 方法一：通过keySet()来获取
    public static void keySet()
    {
        HashMap<String,String> map = new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("05", "lisi");
        map.put("03", "wangwu");
        
        Set<String> keySet = map.keySet();
        
        Iterator<String> it = keySet.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            String value = map.get(key);
            System.out.println("key:" + key + ",value:" + value);
        }
    }
    
    // 方法二：通过entrySet()来获取
    public static void entrySet()
    {
        HashMap<String,String> map = new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("05", "lisi");
        map.put("03", "wangwu");
        
        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:" + key + ",value:" + value);
        }
    }
}

/**
 * 功能：HashMap集合的扩展
 */
package collection;

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

public class MapDemo2
{
    public static void main(String[] args)
    {
        HashMap<String,String> yure = new HashMap<String,String>();
        yure.put("01", "zhangsan");
        yure.put("02", "lisi");
        
        HashMap<String,String> jiuye = new HashMap<String,String>();
        jiuye.put("03", "wangwu");
        jiuye.put("04", "zhaoliu");
        
        HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
        czbk.put("yure", yure);
        czbk.put("jiuye", jiuye);
        
        Set<String> map = czbk.keySet();
        Iterator<String> it = map.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            HashMap<String,String> values = czbk.get(key);
            System.out.println("key:" + key + "values:" + values);
            getStuInfo(values);
        }
        
        // getStuInfo(jiuye);
    }
    
    public static void getStuInfo(HashMap<String,String> room)
    {
        Set<String> map = room.keySet();
        Iterator<String> it = map.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            String value = room.get(key);
            System.out.println("id:" + key + ",value:" + value);
        }
    }
}

/**
 * 功能：JDK1.5新特性，可变参数
 */
package collection;

public class CollectionDemo
{
    public static void main(String[] args)
    {
        syso(1,2,3,4,5);
        syso(3,4);
    }
    
    public static void syso(int... arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(i);
        }
    }
}

/**
 * 功能：JDK1.5新特性，静态导入
 */
package collection;

import java.util.Arrays;

// 实现静态导入，导入的是Arrays这个类中的所有静态成员
import static java.util.Arrays.*;

public class CollectionDemo2
{
    public static void main(String[] args)
    {
        int[] arr = {6,2,8};
        // 原来是这样写的
        // int index = Arrays.binarySearch(arr, 2);
        // 现在可以这样写
        int index = binarySearch(arr, 2);
        
        System.out.println(index);
        
    }
}