集合框架中的工具类

-

 

      Collections 是集合框架的工具类

         里面的方法都是静态的，

         对集合进行指定顺序的排序

         可以用Colections.sort(list);

         具体实现,

         该集合的中的元素必须具备排序功能，所有元素必须实现comparable接口

         排序时，用于接收数据的comparaTo()方法，参数为T或者T的父类

         Collections.sort(list)具体解释如下

         publicstatic <T extends Comparable<? super T) void mySort(List<T> list){

        

                   for(inti = 0;i< list.size();i++){

                            for(intj = i+1; j< list.size();j++){

                                     if(list.get(i).comparaTo(list.get(j))>0){

                                    

                                               Ttemp = list.get(i);

                                               list.set(i,list.get(j));

                                               list.get(j,temp);

                                               //Collections.swap(list,i,j);

                                     }

                            }

                   }

                  

         }

         可以按照自己的需要的进行排序,定义一个比较器

         Collections.sort(list,newComparatorByLength());

         具体解释：

         publicstatic <T>  void mySort(List<T>list,Comparator<? super T> comp){

        

                   for(inti = 0;i< list.size();i++){

                            for(intj = i+1; j< list.size();j++){

                                     if(list.get(i).comparaTo(list.get(j))>0){

                                    

                                               Ttemp = list.get(i);

                                               list.set(i,list.get(j));

                                               list.get(j,temp);

                                              //Collections.swap(list,i,j);

                                     }

                            }

                   }

                  

         }

      根据二分法查找

         Collections.binarySearch(list,"dbds");

         获取最大值

         Collections.max(list)  Collections.max(list,newComparatorBylength())

        

      逆转排序

        

         Collections.reverseOrder()用于返回一个逆序的比较器

          TreeSet<String> ts = nweTreeSet(Collections.reverseOrder());

          

          可以将一个已有比较器逆转：

           Collections.reverseOrder(newcomparatorByLength())

          reverse(List<T>list)

       集合元素的替换

          Collections.replaceAll(List<T> list , ToldVal,T newVal);

          

          Collections.fill(List<T>list,"bs")；全部替换

          

          Collections.shuffle(list);随机排序。

          

          将一个非同步的集合变为同步的集合原理

          

          

          Class MyCollections{

          

                   publicstatic List synList(List list){

                  

                            returnnew MyList(list);

                   }

                  

                   privateclass MyList implements List{

                            privateList list;

                            privatestatic final Object obj = new Object();

                           

                            MyList(Listlist){

                            this.list= list;

                            }

                            publicboolean add(Object obj){

                                     synchronized(obj){

                                               returnlist.add(obj);

                                     }

                            }

                            publicboolean remove(Object obj){

                                     synchronized(obj){

                                               returnlist.remove(obj);

                                     }

                            }

                   }

          }

          可以使用Collections的方法可以将非同步的集合转为同步的集合

          

          Collections.synchronizedSortedMap(SortedMap<K,V>m)

          

Arrays工具类，里面的方法都是静态的。

      asList(数组)将数组转为集合。

         List<String>list = Arrays.asList(arr);

         list.contains("ds");

         可以使用list中的方法

         注意：

                   数组的长度是固定的，所以对于集合的增删方法是不可以使用的

                   否则会发生UnsupportOperationException

                  

                   如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素

                   如果数组中的元素师基本数据类型，那么转为集合时，那么会将该数组作为集合中的元素进行存储

                  

         Collection接口中的toArray()方法。将一个集合变为数组

                   可以对集合中元素操作方法的限定，不需要对其增删

                   list.toArray(newString[list.size()]);

foreach语句：

                   格式：

                            for(类型变量： Collection集合|数组)

                            for(Strings: list){}

                   只能遍历，不能操作。但是Iterator是一个对象

                   增强性的for循环只能操作单列集合，如果是map集合的话，需要将map集合转为

                   单列集合

 

参数的另一种写法：

         publicstatic int newAdd(int... arr){}此时的arr也是一个数组，是一个简化的数组，

         是一个可变的数组，只是将实参自动转为数组

         注意：可变参数类型，必须定义在参数列表末尾

         newAdd(1,2,3,4,5,6,7);

      静态导入包

         格式：

         importstatic java.util.collections.*;

         其实导入的是静态成员