集合和集合框架

1、对象的可以通过数组和集合来存储，对象最常用的存储方式是集合。数组是固定长度的，集合的可变长度的。数组存放一种基本数据类型并且只能存一次，集合只适合于存储对象并且是不同的对象。容器的抽取形成集合框架体系。集合框架的最顶层是Collection。Collection下有List和Set，List，Set下也有很多常见的容器。出现这么多的容器的原因是每一个容器对数据的存储方式都有不同，这个存储方式成为数据结构。

2、java.util包中的Collection接口ArrayList类的使用  。

3、Collection集合基类有add，remove，contains,clear，iterator等方法，其子类List和Set继承此些方法。重点是Iterator迭代器和ListIterator列表迭代器(List集合特有的迭代器)。

　　Collection
　　　　 |--List:元素是有序(元素存入和取出的顺序一致)的，元素可以重复，因为该集合体系有索引

　　　　　　|--ArrayList：底层数据结构是数组，查询速度快，线程不同步。

　　　　　　|--LinkedList：底层数据结构是链表，增删速度快，查询速度稍慢

　　　　　　|--Vector：底层是数组数据结构，和ArrayList功能一样，线程同步，一般不使用了。
　　　　 |--Set:元素是无序的，元素不可以重复

　　　　　　|--HashSet：底层数据结构是哈希表，按哈希值的顺序存储，线程是非同步的。保证元素唯一性的是判断哈希值，如果相同还会判断equals方法是否为真。

　　　　　　|--TreeSet：可以对Set集合中的元素进行排序，可以默认按ACCII码表排序。底层数据结构是二叉树，保证元素唯一性的依据是compareTo方法返回0。TreeSet排　　　　　　　　序的的第一种方式是使其具有比较性，需要实现Comparable接口，覆盖compareTo方法，是自然排序法。当元素自身不具有比较性时，让集合具有比较性，集合在初始化时就具备了比较方式，此时要定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。当两种比较方式都存在时，以比较器为主。

4、泛型：泛型是jdk1.5之后出现的新特性，为了解决安全问题。我们在定义数组的时候会定义不可更改的数据类型，而定义集合的时候就不会了，任何类型都可以存入集合，这就引发了安全问题。泛型就是解决这个安全问题。任何类型存入集合中都会在编译的时候通过，运行时输出结果后才提示异常。给集合加一个中括号，放入需要装入的数据类型，则可以在编译时就提示类型错误。泛型还避免了强制类型转换。

package test;
import java.util.*;
public class ListSet 
{
    public static void main(String[] args) 
    {
        ArrayList<Integer> arr=new ArrayList<Integer>();
        arr.add(3);
        arr.add(4);
        Iterator<Integer> it=arr.iterator();//迭代器
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

5、泛型格式：通过<>来定义要操作的引用数据类型；

　　写泛型的条件：出现<>，就需要定义泛型，<>就是用来接收类型的。

6、泛型类：早期在没有泛型的时候是利用Object基类来设置类似于泛型的机制，完成可扩展性特性。有了泛型后，用泛型类扩展程序功能。

package test;
public class ListSet 
{
    public static void main(String[] args) 
    {
        //早期用Object完成扩展的做法
        /*
        Tool t=new Tool();
        t.setObject(new Worker());
        Worker worker=(Worker)t.getObject();
        */
        //现在的泛型类做法
        Utility<Worker> w=new Utility<Worker>();
        w.setCla(new Worker());
        Worker worker=w.getCla();
    }
}
class Student
{}
class Worker
{}
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj=obj;
    }
    public Object getObject()
    {
        return obj;
    }
}
//T为要传入泛型类的引用类型参数
class Utility<T>
{
    private T t;
    public void setCla(T t)
    {
        this.t=t;
    }
    public T getCla()
    {
        return t;
    }
}

7、泛型方法和静态泛型方法

package test;
//泛型方法
public class FanXing
{
    public static void main(String[] args) 
    {
        S s=new S();
        s.show(4);
        s.show(new Integer(2));
        s.show("sdfsdf");
        
        S1<TT> s1=new S1<TT>();
        s1.show(new TT());
        s1.print("dfsf");
    }
}
//泛型方法
class S
{
    public <T> void show(T t)
    {
        System.out.println(t);
    }
}
//泛型方法和泛型类
class S1<TT>
{
    public void show(TT t)
    {
        System.out.println(t);
    }
    public <Q> void print(Q q)
    {
        System.out.println(q);
    }
    //静态泛型方法，不能调用类的泛型方法
    public static <P> void show1(P p)
    {
        System.out.println(p);
    }
}
class TT
{}

8、泛型接口极其应用

package test;
//泛型接口极其使用
public class FanXing
{
    public static void main(String[] args) 
    {
        InterImplement i=new InterImplement();
        i.function("sfdf");
        
        InterImp1<String> ii=new InterImp1<String>();
        ii.function("我是好人,不要杀我！");
    }
}
interface Inter<T>
{
    void function(T t);
}
class InterImplement implements Inter<String>
{
    public void function(String s)
    {
        System.out.println(s);
    }
}
class InterImp1<T> implements Inter<T>
{
    public void function(T t)
    {
        System.out.println(t);
    }
}

9、泛型限定

package test;
import java.util.*;
//泛型限定
/*
 * ?是通配符也是占位符；
 * ? extends E:可以接收E类型或者E的子类型，是类型的上限
 * ? super E:可以接收E类型或者E的父类型，是下限
 */
public class FXXD 
{
    public static void main(String[] args)
    {
        ArrayList<String> a=new ArrayList<String>();
        a.add("a");
        a.add("b");
        
        ArrayList<Integer> a1=new ArrayList<Integer>();
        a1.add(1);
        a1.add(2);
        
        printfx(a);
        printfx(a1);
        
        ArrayList<Person> p=new ArrayList<Person>();
        p.add(new Person("aaaa"));
        p.add(new Person("bbbb"));
        p.add(new Person("cccc"));
        printt(p);

        ArrayList<Student> s=new ArrayList<Student>();
        s.add(new Student("aaaa"));
        s.add(new Student("bbbb"));
        s.add(new Student("cccc"));
        //printt(s); //error，因为ArrayList<Person> s=new ArrayList<Student>是不成立的
        printl(s);
        printll(s);
    }
    public static void printfx(ArrayList<?> a)//?是未限定引用数据类型
    {
        Iterator<?> i=a.iterator();
        while(i.hasNext())
        {
            System.out.println(i.next());
            //System.out.println(i.next().length());//error,因为不确定类
        }
    }
    public static void printt(ArrayList<Person> p)
    {
        Iterator<Person> i=p.iterator();
        while(i.hasNext())
        {
            System.out.println(i.next().getName());
        }
    }
    //泛型限定上限
    public static void printl(ArrayList<? extends Person> p)
    {
        Iterator<? extends Person> i=p.iterator();
        while(i.hasNext())
        {
            System.out.println(i.next().getName());
        }
    }
    //泛型限定下限
    public static void printll(ArrayList<? super Student> p)
    {
        Iterator<? super Student> i=p.iterator();
        while(i.hasNext())
        {
            System.out.println(i.next());
        }
    }
}
//定义一个Person类
class Person
{
    private String name;
    Person(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

10、Map集合

　　Map

　　　|--Hashtable：底层是哈希表数据结构，不可以存入空键值，该集合是线程同步的，在jdk1.0中。

　　　|--HashMap：底层是哈希表数据结构，允许使用空键值和空值，该集合是不同步的，在jdk1.2中,效率高。

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

　　实质上，Set集合底层就是使用了Map集合。

11、Collections集合：均是静态的方法。

12、Arrays集合：用于操作数组的工具类，方法均是静态的。