集合List, 比较，and 泛型

一、集合框架:
    1：集合框架  
         1)集合用来存数据，比数组方便；
         2)可以存不同的数据，但是不建议，因此用泛型来约束；
         3)利用泛型，好处:编译器就可检查元素类型是否匹配，
                            避免在运行出现错误；
     2：父接口Collection
        常用的子接口
            1) List:  有序，可重复(元素之间调用equals比较)
             2)Set：无序，不可重复(元素之间调用eqauls比较)
     3：List子接口的实现类
        1)ArrayList：
             内部是一个动态数组，查找速度快，增删慢
         2)LinkedList:
              内部是一个链表，查找速度慢，增删快
二、详解：
    1:父接口Collection
      常用方法：
         1)add(Object e):增加元素
         2)remove(Object obj):移除
         3) addAll(Collection c):两个集合合并
         4)removeAll(Collection c):移除两个集合的交集
         5)retainAll(Collection c):保留交集
         6)clear():清空集合
         7)isEmpty():判断是否是空
         8)size():返回集合元素的个数。
         9)toArray()：将集合对象转换成数组
     2:List子接口----线性表 Set
        常用的实现类：
             1)ArrayList:
                 是线性结构内部封装的是动态的数组。长度的增加和减少已经被封装。
                 可以理解为自动的。
                 查找快，增删慢
                 线程不安全，效率高
            2)LinkedList：
                               是链表结构。一个元素里存了前一个元素的地址和后一个元素的地址。
                              连到一起很像一链条。
                增加删除快，查找慢            
                3)Vector: 线程安全，效率低。
    3.  List接口提供的方法：
        1) add(int index,Object obj):插入元素
         2)add(Object obj);
         3)get(int index):获取元素
         4)remove(int index)
         5)int   indexOf(Object obj):返回元素的下标，返回-1说明没有此元素
         6)lastIndexOf(Object obj):
             7)contains(Object obj)--boolean:判断是否包含元素obj
         8)toArry():将集合转换成数组-
            注意：要用Object[]接收，
              String[]数组是Object类型
                  Object[]数组转换成String[]会出现
                  类造型异常ClassCastException
             9)Arrays.asList(str):将数组str转换成集合，转换后的集合不能增删
            否则会出现异常。
        10)   subList(int fromIndex,int toIndex);：是获取集合的子集合。

        集合对象里存的就是这些元素的地址信息

    4.:    增强for循环,作用是用来遍历集合或者是数组。
        是迭代的另外一种写法，不是新语言。
         编译器会将此循环编译成迭代写法。
        结构:
              for(元素类型  变量名:集合或数组的变量){
                    //
             }
        /*还可以：利用迭代遍历
         * 迭代器Iterator,是一个接口，作用是用
         * 来遍历集合元素。List接口提供iterator方法
         * 来获取迭代器实现类对象。
        /
        reg:
            //使用迭代器遍历集合a
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object obj = it.next();//获取下一个对象    
            if((Integer)obj==6){
                it.remove();
                //绝对不能使用list.remove(6);
            }
            System.out.println(obj);
        }
        5.:泛型机制。
                 5.1：泛型机制的本质是参数化类型。
                         在类，接口和方法的定义过程中，可以进行指定参数类型名。
                         在集合框架中，所有的集合类型都使用泛型机制。
            好处:是在进行参数化类型后，就可以限制集合元素
               的类型，编译器会通过指定的泛型进行检查。
               减少代码在运行时的错误。
                public class ArrayList<E>{
                     ………………
                     public boolean add(E e);
                 public E get(int index);
                ………………
                           }
         ArrayList使用泛型机制，E就是类型参数。
          在具体使用时，得给E赋值，赋的值是类型名。
        List<String>  list = new ArrayList<String>();
       注意： 泛型机制不能使用八大基本数据类型,只能用引用类型

       6.:集合的存储：
         集合元素都是引用类型。集合对象内 存的是元素的地址信息，
        不是元素本身。
      7.：集合工具类：Collections(注意与Collection-的区别)
            方法：sort(list):对集合进行排序；
                    Collections.sort(list);//直接对list对象排序；
        总结：
            1)集合有sort()方法，说明集合元素是可排序；
            2)如何实现sort()方法？  --方法1
                1.实现Comparable接口；
                2.重写compareTo(Object  obj)方法；
             3) compareTo(Object obj)方法: 就是用来进行元素之间的比较的 。
                   this>obj,返回>0的数
                   this<obj,返回<0的数
                   this=obj,返回 0的数
            4)调用sort(p1);方法    
            5)Comparable:接口也是有泛型的，传参为实现类类型；
    8) Comparable与Comparator的作用与区别
           Comparable(adj.)---compareTo(Object a)
           Comparator(n.)---compare(Object a,Object b)
        1)作用：都是用来排序的；
        2) Comparator：在原有排序规则上，临时改变排序规则时，
                使用的比较器接口。 调用集合的sort(p1,p2)方法
        3)如何实现？
            1.实现Comparator接口；
            2.重写compare(Object ob1,Object ob2)方法；
        4)调用sort(Collection coll,Comparator com);
        5)使用：Collections.sort(coll,com);
 例如：
        List<Cell> list = new ArrayList<Cell>();
        list.add(new Cell(1,2));
        Collections.sort(list);

        使用Comparator接口实现排序：
        Comparator my = new MyComparator();   --方法1
            Collections.sort(list, my);

          /*
         * 使用匿名内部类的写法创建比较器对象
         */
        Comparator<Point>  my = new Comparator<Point>(){   --方法2
            public int compare(Point p1, Point p2) {
                int dis1 = p1.getX()*p1.getX()+p1.getY()*p1.getY();
                int dis2 =  p2.getX()*p2.getX()+p2.getY()*p2.getY();
                return dis2-dis1;
            }
        };
        Collections.sort(list,my);
        System.out.println(list);