类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);  //2
        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);   //交换两个元素
            }
    }

}