类Collections的静态方法的使用（代码）

 package cn.itcast.p2.toolclass.collections.demo;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.TreeSet;

 import cn.itcast.p2.comparator.ComparatorByLength;

 public class CollectionsDemo {

     public static void main(String[] args) {
         /*
          * Collections:是集合框架的工具类。
          * 里面的方法都是静态的。
          */

         demo_4();

     }

     public static void demo_4() {
         List<String> list = new ArrayList<String>();

         list.add("abcde");
         list.add("cba");
         list.add("aa");
         list.add("zz");
         list.add("cba");
         list.add("nbaa");
         Collections.sort(list);
         System.out.println(list);

         /*
          * 替换
          * static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
          * 使用另一个值替换列表中出现的所有某一指定值。
          *
          * 随机置换
          * static void shuffle(List<?> list)
          * 使用默认随机源对指定列表进行置换。
          * static void shuffle(List<?> list, Random rnd)
          * 使用指定的随机源对指定列表进行置换。
          *
          * 替换
          * static <T> void fill(List<? super T> list, T obj)
          *  使用指定元素替换指定列表中的所有元素。
          */
         Collections.replaceAll(list, "cba", "nba");
         System.out.println(list);

         Collections.shuffle(list);
         System.out.println(list);

         Collections.fill(list, "ccc");
         System.out.println(list);

     }
     /*
      * demo_4结果：[aa, abcde, cba, cba, nbaa, zz]
                  [aa, abcde, nba, nba, nbaa, zz]
                  [abcde, zz, nba, aa, nbaa, nba]  每次运行结果都不同
                   [ccc, ccc, ccc, ccc, ccc, ccc]

      */

     public static void demo_3() {
         /*
          * 反转顺序
          * static <T> Comparator<T> reverseOrder()
          * 返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
          * static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
          * 返回一个比较器，它强行逆转指定比较器的顺序。
          */
         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));

         ts.add("abc");
         ts.add("cba");
         ts.add("hahaha");
         ts.add("aa");
         ts.add("zzz");

         System.out.println(ts);
     }
     /*
      * demo_3运行结果：  [hahaha, zzz, cba, abc, aa]
      */

     public static void demo_2() {
         List<String> list = new ArrayList<String>();

         list.add("abcde");
         list.add("cba");
         list.add("aa");
         list.add("zz");
         list.add("cba");
         list.add("nbaa");
         Collections.sort(list);
         System.out.println(list);

         /*
          * 二分搜索法
          * static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
          *  static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
          */
         int index = Collections.binarySearch(list, "cba");
         System.out.println("index:"+index);  //
         int index2 = Collections.binarySearch(list, "aaa");
         System.out.println("index:"+index2);  //-2    如果没有所要搜寻的key存在，则返回（-（插入点）-1）

         /*
          * 获取最大值
          * static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
          *  根据元素的自然顺序，返回给定 collection 的最大元素。
          * static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
          * 根据指定比较器产生的顺序，返回给定 collection 的最大元素。
          *
          * 获取最小值  类似上面
          */
         String max = Collections.max(list, new ComparatorByLength());
         System.out.println("max:"+max);

     }

     public static void demo_1() {
         List<String> list = new ArrayList<String>();

         list.add("abcde");
         list.add("cba");
         list.add("aa");
         list.add("zz");
         list.add("cba");
         list.add("nbaa");

         System.out.println(list);

         /*
          * 两种比较方式
          */

         //对list集合进行指定顺序的排序。
         //static <T extends Comparable<? super T>> void sort(List<T> list)
         Collections.sort(list);
 //        mySort(list);               //sort的执行原理
         System.out.println(list);

         //static <T> void sort(List<T> list, Comparator<? super T> c)
         Collections.sort(list, new ComparatorByLength());
 //        mySort(list , new ComparatorByLength());  // 上一条代码的执行原理
         System.out.println(list);
     }

     //sort(List<T> list, Comparator<? super T> c)  执行原理
     public static <T> void mySort(List<T> list, Comparator<? super T> comp) {
         for (int i=0; i<list.size()-1; i++)
             for (int j=i+1; j<list.size(); j++)
             {
                 if (comp.compare(list.get(i), list.get(j)) > 0)
                     Collections.swap(list, i, j);
             }
     }

     //sort(List<T> list)的执行原理
     public static <T extends Comparable<? super T>> void mySort(List<T> list) {

         for (int i=0; i<list.size()-1; i++)
             for (int j=i+1; j<list.size(); j++)
             {
                 if (list.get(i).compareTo(list.get(j)) > 0)
                     Collections.swap(list, i, j);   //交换两个元素
             }
     }

 }