Java------集合

Collection:是一个集合接口,有两个子接口List和set.和Map接口并列,无构造器，定义为抽象方法。
    |------List:可以存放任意数据，元素有序排列，元素可以重复。对文件进行简单的增add()、删remove()、改set()、查get()、插add()操作
             |-------ArrayList:(主要实现类、非线程安全) 多态性-- 
List list = new ArrayList();
  list.add()
             |-------LinkedList:(频繁插入、删除元素）
             |-------Vector:（线程安全）
    |------Set:可以存放任意数据，元素无序排列，元素不可以重复，
             |-------Hashset: 无序性！=随机性-------》指的是元素在底层存储的位置是无序的
                                               不可重复性-------》若添加类对象时必须重写Hashcore()和equals()方法
                                                                          -------》添加相同元素时后面的不可以添加进去。
            |-------Linkedhashset:使用链表维护添加进set中的顺序，故遍历set时是按照添加进去的顺序进行遍历的。
             |-------Treeset:①向其添加元素时必须是同一个类的（相同的数据类型）
                                            ②可以按照添加进的元素的指定顺序遍历（string类、包装类按默认从小到大的顺序遍历）
                                            ③当向其添加自定义类的对象时，有两种排序方法：
                                           
13c2b
    ①自然排序：要求添加的自定义类要实现comparable接口 重写compare
to（）方法
                                                                 格式：public class personimplements comparable{
                                                                                             @override

                                                                            public void compareto(object o1){

                                                                             if (o1 instanceof  **)
                                                                               强制转换；
                                                                                                 排序条件；
                                                                                                   遍历  }}
                                                        compare
to（）、Hashcore()和equals()三者一致         
                                                ②定制排序：要求创建一个comparator的对象，重写compare(）方法。             
                                                                   格式：Comparatorcom
= new  Comparator();
                                                                                           @override  
                                                                                              publicint 
compare(object o1,object o2){
                                                                                                if(o1instanceof
**  && o2 instanceof**)  
                                                                                                                           强制转换；
                                                                                                                            排序条件 }
                                                                                                TreeMap 
map = new TreeMap(com);
                                                                                                       map.put();
                                                                                                           遍历
                                            ④向其添加元素时首先按照compareto()方法比较，一旦返回0，虽然仅是两个对象的此属性值相同，但程序会认为          
                                                  这两个对象是相同的，进而后一个对象不能添加进来。
    |------Queue: 很少用到

          
Map: 是一个接口与collection接口并列，可以存放任意数据，无构造器，方法定义为抽象方法   
map.put()添加任何类型元素
          ①key是用set存放的，不可重复  
          ②value是用collection存放的，可以重复
          ③entry即key-value对也是用set存放的，不可以重复
    |-------HashMap: 向其添加元素时，会调用key所在类的equals()方法，判断两个key是否相同，若相同则只能添加后面进                              
                                      去的元素。
    |-------LinkedHashMap: 使用链表维护添加进map中的顺序，故遍历map时是按照添加进去的顺序进行遍历的。
    |-------TreeMap:   ①按照先添加进map中的元素的key的指定属性进行排序，要求key必须是同一个类的对象。
                                      ②针对key的自然排序：要求key所在的类要实现comparable接口 重写compare
to(指定按key的某个属 
                                           性进行排序)方法。格式：public
class personimplements comparable{
                                                                                             @override

                                                                            public void compareto(object o1){

                                                                             if (o1 instanceof  **)
                                                                               强制转换；
                                                                                                 排序条件；
                                                                                                   遍历  }}
                                      ③针对key的定制排序:要求创建一个comparator的对象，重写compare(指定按key的某个属性进行排序 
                                           )方法。格式：Comparator
com = new  Comparator();
                                                                       @override  
                                                                        publicint  compare(object o1,object
o2){
                                                                        if(o1instanceof **  && o2 instanceof**) 
                                                                          强制转换；
                                                                           排序条件 }
                                                                        TreeMap 
map = new TreeMap(com);

                                                             map.put();
                                                             遍历
    |-------Hashtable:（线程安全）古老的实现类 不允许有null作为key-value,不建议使用。
              |------Property:常用来处理属性文件  键和值均为string类型
集合的遍历：①增强for循环for(object
obj: set)
                     ②迭代器 Iterator 
iterator = coll.iterator(); while(iterator.hasNext()){system.out.println(iterator.next());}  
                           Map：1、遍历keyset()                             
2、遍历values()

                                   Set set = map.keyset();                 Collection coll = map.values();
                                   for(object
obj : set){                        Iterator  i =  coll.iterator();

                                   system.out.println(obj);}                  while(i.hasNext()){system.out.println(i.next());}
                                3、遍历Entry() 方法一、                                         方法二、
                                      Set set =map.keyset();                                      Set
set = map.entry();
                                      for(object obj : set){                                     Iterator 
i =  set.iterator();                           

                                      system.out.println(obj + map.get(obj))}       while(i.hasNext()){system.out.println(i);}
Collections工具类：操作collection以及map的工具类。reverse(List)：反转list中元素的顺序      shuffle(List):对list集合元素进行随机排序
                                                                                                         sort(List):根据元素的自然顺序对指定list集合元素按升序排序
                                                                                                          sort(List.comparator):根据指定的comparator产生的顺序对list集合元素进行排序
                                                                                                          swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换
                                                                                                         objectmax(collection):根据元素的自然排序，返回给指定集合中的最大元素
                                                                               objectmax(collection，comparator):根据comparator指定的排序，返回给指定集合中的最大元素
                                                                                                         objectmin(collection):根据元素的自然排序，返回给指定集合中的最小元素
                                                                                                          int 
frequency(collection,object):返回指定集合中指定元素的出现次数
                                                                                                          void 
copy(List dest,List src):将src中的内容复制到dest
                                                                                      boolean  replaceall(List  list,object oldval, object  newval):使用新值替换list旧值
                                                                                                          Enumeration接口是Iterator迭代器的“古老版本”
集合中的泛型：