JAVA集合

                         集合框架

一、集合的体系结构
1、Collection 
     |                             |--------ArrayList
     |                             |
     |-----List--------------------|--------LinkedList
     |                             |
     |-----Set---|                 |--------Vector
                 |-----HashSet
                 |
                 |-----TreeSet

(1)集合中存放是对象的引用
2、常见方法
(1)add():添加
(2)size():获取长度
(3)remove():删除
(4)clear():清除
(5)contains()：判断是否存在
(6)isEmpty():判断是否为空
(7)retainAll():取交集
(8)removeAll():去交集

3、迭代器
(1)iterator():返回此集合的迭代器
   Iterator it=a1.iterator();
   Iterator 接口中有三个方法
   a、next():返回下一个元素
   b、hasNext():还有下一个元素吗
   c、remove():删除上一次next()返回的元素
(2)我对迭代器的理解
   将一组通用的从集合取出元素的方法封装成接口。
   然后在每个集合中通过一个内部类还实现这个接口。
   然后通过一个公开的方法返回这个内部类对象，这个对象就是迭代器。
   通个这个思路完全可以自己设计迭代器。
   提供了一个统一操作集合的接口
(3)使用迭代器访问集合里的元素。
   for(Iterator it=a1.iterator();it.hasNext();)
   {
       it.next();
   }

二、List集合

(1)特点
   元素是有序且可以重复的，因为该集合体系是有索引的
(2)提供了一些按索引操作的方法
   增:
      add(index,element);
      add(index, Collection);
   删：
      remove(index);
   改：
      set(index,element);
   查:
      get(index);
      subList(from,to);
      ListIterator();
2、ListIterator 列表迭代器，(继承自Iterator)
(1)List集合特有的迭代器，ListIterator是Iterator的子接口。
   在迭代时，不可以通过集合对象的方法操作集合中的元素，
   因为会发生访问异常。所以在迭代时，只能用迭代器的方式操作元素，
   可是Iterator方法是有限的，只有删除，返回下一个元素.只能通过ListIterator特有的

迭代器

3、List常用的实现类
(1)ArrayList:底层的数据结构是数组:查询速度快，增删较慢。
(2)LinkedList:底层使用的是链表：查询较慢，增删很快。
(3)Vector: 底层是数组结构，线程同步。
    Enumeration en=v.elements();返回此集合的枚举。和迭代器类似.
    Vector特有的取出方式.
(4)LinkedList:特有方法
   addFirst()    getFirst()                     removeLast()
   addLast()     getLast()获取元素不删除        removeFirst()获取元素还删除
   上面方法，如果集合中没有元素会出现NoSuchElement Exception
   offerFirst()  peekFirst()    pollFirst()
   offerLast()   peekLast()     pollLast()
(5)练习
   使用LinkedList模似队列和堆栈
   去除ArrayList中的重复元素
 总结：
  在迭代器循环中next中调用一次，就让hasNext判断一次
  将一个对象放入集合，其类型会丢失
  List集合判断元素是否相同，依据的是equals方法。
  
   
二、Set集合
              |--------HashSet
    Set-------|
              |
              |--------TreeSet

1、特点       
   元素无序且不可以重复。 Set集合的功能和Collection一样
2、HashSet集合
底层数据结构是:哈希表,线程是非同步的。
(1)HashSet集合是如何保证元素的唯一性呢？
  是通过元素的两个方法，hashCode和equals来完成。
  如果hashCode相同，才会判断equals方法是否为true
  如果hasCode不同，不会调用equals方法。
(2)HastSet判断和删除元素的依据
  hashCode()返回的值相同，equals方法比较返回true,HashSet才认为是同一个元素.

3、TreeSet
   底层数据结构是二叉树
   可以对集合中的元素进行排序。(自然排序，定制排序) 
(1)一个对象要能放入TreeSet集合，一定要具备比较性，只要让对象实现Comparable接口即

可。
   该接口强制让对象具备比较性。
   此接口里只有compareTo()方法。
   保证元素唯一性的依据是 ：compareTo()方法return 0;
(2)排序时当主要条件相同时，一定要判断次要条件。
(3)TreeSet排序的第一种方式:让元素自身具备比较性，元素需要实现Comparable接口，
   覆盖compareTo()方法,这种方式也叫自然排序。
(4)TreeSet排序的第二种方式:当元素自身不具备比较性时，或者具备比较性不是所需要的

，这时 需要让集合自身具备比较性。在集合初始化时就定义比较方式，也就是传入一个指

定的比较器。定义一个类实现Comparator接口compare方法。当两种排序都在时，以比较器

为主。

4、泛型
  JDK1.5 版本以后出现的新特性。用于解决安全问题，是一个安全机制。
(1)在定义集合时确定集合能存的对象类型
好处:
   a、将运行时期出现的问题转移到编译时期。方便程序员解决问题减少，安全。
   b、避免了强制转换的麻烦。
(2)泛型的使用
  格式:通过<>来定义要操作的引用数据类型
  通常在集合框架中很常见。只要见<>就要定义泛型。
  其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型做为参数传递到

<>中。
(3)、泛型方法
泛型类的局限性：只要对象一建立要操作的类型就确定了.
为了让不同方法可以操作不同类型，而且类型还不确定。那么可将泛型定义在方法上.格式

如下:
     修饰符 <T,S> 返回值 方法名(T a,Sb){
     
     }

(4)、静态方法泛型
   静态方法不可以访问类上定义的泛型.
   如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上.

(5)、泛型接口
     接口也可以定义为泛型.
(6)、泛型的限定
   a、类型通配符 ?        也可以理解为占位符
   b、上限<? extends E>   可以接收E类型或者E的子类型
   c、下限<? super   E>   可以接收E类型或者E的父类型
   d、用于泛型扩展用的.
  
三、Map
Map----|
       |-------HashMap
       |
       |-------HashTable
       |
       |-------Treemap 
1、Map的集合
(1)、存储的是键值对.而且要保持键的唯一性.
     当数据之间存在映射关系时，就要先想到map集合
(2)、常用操作
    a、添加
          put(K key,V value) 
          putAll(Map<? extends K, ? extends V> m); 
    b、删除
          clear();
          remove(Object key);
    c、判断
          containsValue(Object value);
          containsKey(Object key); 
          isEmpty();
    d、获取
          get(Object key);
          size();
          values();
          entrySet();
          keySet();

(3)Map 的三个常用实现类
   
   Hashtable: 线程安全的，key与value不可以为null;
   HashMap :  线程不安全的,key与value可以为null;
   TreeMap :  可以排序
(4)map集合的两种取出方式
a、Set<k> keySet(): 将map中所有的键存入到Set集合，因为Set集合具备迭代器，
             所以可以通过迭代方式取出所有的键，可以根据get方法，
             获取每一个键对应的值。
   map集合的取出原理:
             将map集合转成set 集合，在通过迭代器取出.
b、Set<Map.Entry<k,v>> entrySet(); 
   将map集合中的映射关系取出来,存入到Set集合中.
   Map.Entry数据结构来存储这种关系就可以通过
   Map.Entry中的getKey和getValue()方法获取键与值.
   其实Entry也是一个接口，它是Map接口中的一个内部接口.
                                    
(5)获取字符串中字符出现的次数
  public static String charCount(String str){
 
    char[] chs=str.toCharArray(); //将字符串转成字符数组
    TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();//定义

一个map来存储这种关系
    for(int x=0;x<chs.length;x++){
       Integer value=tm.get(chs[x]);
          if(value==null){
       tm.put(chs[x],1);  //第一次map没有这个字符
    }else{
                          value=value+1; //以后出现将次数加1
     tm.put(chs[x],value);
    }
    }

 }

四、集合框架工具类
1、Collections
提供了操作集合的一些静态方法
(1)sort();排序
(2)max(); 求最大值
(3)binarySearch();二分法查找
(4)fill();以指定元素填充
(5)replaceAll();替换
(6)reverse();反转
(7)reverseOrder();强行逆转比较器的顺序
(8)synchronizedXXX();将线程不同步的集合变成同步的集合
(9)swap();交换元素
(10)shuffle()；随机置换
2、Arrays
用于操作数组的工具类
(1)asList():将数组变成List集合,可以使用集合的思想和方法来操作数组中的元素,
            不可以使用集合的增删方法，因为数组的长度是固定的，如果你增删会
            发生不支持操作异常。
            如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合

中的元素.
           如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
(2)集合转数组
   Collection中的toArray(T[] a);
   指定类型的数组要定义多长呢？
  a、当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度

为集合的size.
  b、当指定类型的数组长度大于集合的size,不会创建新的数组，而是使用传递进来的数组
  c、为什么要将集合变成数组呢?
     为了限定对元素的操作(不需要进行增删)
(3)增强的for循环
   格式:for(数据类型 变量名:被遍历的集合或者数组)
   a、只能获取集合元素，但是不能对集合进行操作
   b、迭代器除了遍历，还可以remove集合中的元素
   c、如果是List集合，全部操作都可以
(4)可变参数
   a、数组参数的简写形式，不用每一次都手动的建立数组对象
      只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组。
   b、在使用时可变参数一定要定义在参数列表的后面