java集合类学习笔记

    一、集合类的由来：  
        对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。  
        就使用集合容器进行存储。  
          
    二、集合特点：  
    1，用于存储对象的容器。  
    2，集合的长度是可变的。  
    3，集合中不可以存储基本数据类型值。 如果需要存储int类型，需要存储Integer类型，Integer是对象不是基本数据类型  
      
      
      
    三、集合框架： 

    集合容器因为内部的数据结构不同，有多种具体容器。  
    不断的向上抽取，就形成了集合框架。  
      
    框架的顶层是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():将集合转成数组。   
    -------------------------------------------------------------------------------------------------------------------  
    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);      //根据index索引获取集合中的一个元素  
        int indexOf(object);    //返回集合中第一次出现object元素的索引  
        int lastIndexOf(object);//返回集合中最后依次出现object元素的索引  
        List subList(from,to);  //返回集合中索引从from到to的集合的数据  
          
          
    list集合是可以完成对元素的增删改查。  
      
      
    List:  
        |--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！  
        |--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。  
        |--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。  
          
          
          
    LinkedList:  
      
        addFirst(); //在第一个元素位置添加一个元素  
        addLast():  //在集合尾部添加一个元素  
        jdk1.6变更为以下方法，也就是方法名称改了，功能还是没变  
        offerFirst();  
        offetLast();  
          
          
        getFirst();.//获取集合中下标为0的元素但不移除，如果链表为空，抛出NoSuchElementException.  
        getLast();  //获取集合中的最后一个元素但不移除，如果链表为空，抛出NoSuchElementException.  
      
        jdk1.6  
        peekFirst();//获取但不移除，如果链表为空，返回null.  
        peekLast():  
          
        removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.  
        removeLast();  
        jdk1.6  
        pollFirst();//获取并移除，如果链表为空，返回null.  
        pollLast();  
      
    ---------------------------------------------  
      
    Set:元素不可以重复，是无序。  
        Set接口中的方法和Collection一致。  
        |--HashSet: 内部数据结构是哈希表 ，是不同步的。  
            如何保证该集合的元素唯一性呢？  
            是通过对象的hashCode和equals方法来完成对象唯一性的。  
            如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。   
            如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。  
            如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。  
              
            需要记住的是：如果元素要存储到HashSet集合中，必须覆盖元素原有的hashCode方法和equals方法。  
            一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。  

            建立对象判断是否相同的依据。 

            HashSet何时会导致内存泄漏呢？

            所谓内存泄漏，是说数据不用了之后，没有被回收，还不断地占用着内存，这时候就可能出现内存泄漏的情况，

            元素如果添加到HashSet中后，在hashCode中用于计算hashCode的值元素最好就不要再改变了，如果改变了，

            这时候又调用了remove方法删除这个元素，那么这个元素再去找这个需要被删除的对象时，这个对象可能就找不到了，             

            因为原来用于计算hashCode值的那个元素被修改了，再次用相同的元素计算哈希值，就可能导致找不到这个元素了，

            这时候就可能出现内存泄漏的情况。            

              
        |--TreeSet:可以对Set集合中的元素进行排序。是不同步的。   
                    判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。   
                      
                    TreeSet对元素进行排序的方式一：  
                    让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。  
                      
                    如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？  
                    可以使用TreeSet集合第二种排序方式二：  
                    让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。  
                    将该类对象作为参数传递给TreeSet集合的构造函数。  
                      
                      
      
      
    哈希表确定元素是否相同  
    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集合中的键进行排序。   
          
      
      
    四、演示如何给非同步的ArrayList加上同步  
      
    List list = new ArrayList();//非同步的。  
      
    list = MyCollections.synList(list);//返回一个同步的list.  
      
      
      
    演示Demo类如下：  
      
   

class MyCollections{  
      
        public static  List synList(List list){  
              
            return new MyList(list);  
        }  
      
        private class MyList implements List{  
        private List list;  
          
        private static final Object lock = new Object();  
        MyList(List list){    
            this.list = list;     
        }  
          
        public boolean add(Object obj){  
            synchronized(lock)  
            {  
                return list.add(obj);  
            }  
        }  
          
        public boolean remove(Object obj){  
            synchronized(lock)  
            {  
                return list.remove(obj);  
            }  
        }  
      
    }  
    }