JavaSE-19集合工具类--13-常用对象API(集合框架-工具类-Collections-排序)

package day19;

//Collections 静态方法组合
//根据自然顺序排序
//static <T extends Comparable<? super T>>
//void sort(List<T> list)
//根据其元素的natural ordering对指定的列表进行排序。
//根据 传入比较器 ：例如自定义长度比较器
//static <T> void sort(List<T> list, Comparator<? super T> c)
//        根据指定的比较器引起的顺序对指定的列表进行排序。
// 交换
//static void swap(List<?> list, int i, int j)
//交换指定列表中指定位置的元素。

import java.util.*;

public class CollectionDemo {

    public static void main(String[] args) {

        collections_demo();

    }
    public  static   void  collections_demo(){

        List<String >  list  =new ArrayList<String >() ;
        list.add("aaaa");
        list.add("dddd");
        list.add("sddd");
        list.add("cccc");
        Iterator  iterator  = list.iterator();
        while(iterator.hasNext()){
         System.out.println(iterator.next());
        }
         System.out.println("排序后");
      //  Collections.sort(list);
          // mysort(list);
        compareByLength(list,new CompareByLength());
        Iterator  iterator2  = list.iterator();
        while(iterator2.hasNext()){
            System.out.println(iterator2.next());
        }
    }
    //   T 需要继承  比较类型
    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)//  使用String 的比较器

                 {
                     Collections.swap(list,j,i);//交换
                 }
             }
         }
     }

    }


    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){

//             T temp = list.get(i);
//             list.set(i, list.get(j));
//             list.set(j, temp);
                    Collections.swap(list, i, j);

                }
            }
        }
    }
    //参考 ：public static <T> void sort(List<T> list,
    //                            Comparator<? super T> c)
    public   static <T>  void   compareByLength(List<T>  list, Comparator<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){

//             T temp = list.get(i);
//             list.set(i, list.get(j));
//             list.set(j, temp);
                    Collections.swap(list, i, j);

                }
            }
        }
    }

}

折半查找  & 最值

//public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
//
// T key)使用二叉搜索算法搜索指定对象的指定列表。 该列表必须根据被按升序排列natural ordering元素（如由sort(List)方法）之前使该呼叫。
//
// [要有序 ] 如果没有排序，结果是未定义的。 如果列表包含与指定对象相等的多个元素，则不能保证将找到哪个元素。
//这确保当且仅当找到该键时返回值将为> = 0。
public   static   void   searchdemo(){
    {

        List<String >  list  =new ArrayList<String >() ;
        list.add("aaaa");
        list.add("dddd");
        list.add("sddd");
        list.add("ccccqqqq");
        Iterator  iterator  = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("排序后");
        //先排序
         Collections.sort(list);
        // mysort(list);
        //aaaa
        //cccc
        //dddd
        //sddd

       int   value = Collections.binarySearch(list,"aaaaaaaaa");//返回值是  -2 表示没有找到
       System.out.println("查找结果:"+value);
         value = Collections.binarySearch(list,"aaaa");//返回值是  0 表示有找到  返回插入点index
        System.out.println("查找结果:"+value);
        value = Collections.binarySearch(list,"cccc");//返回值是  1 表示有找到  返回插入点index
        System.out.println("查找结果:"+value);
        Iterator  iterator2  = list.iterator();
        while(iterator2.hasNext()){
            System.out.println(iterator2.next());
        }

        System.out.println("最大值 "+Collections.max(list));//最大值 sddd
        //按照自定义 比较   长度
        System.out.println("长度最大值"+Collections.max(list,new CompareByLength()));//长度最大值ccccqqqq
    }


}

//最大值
//public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
// 根据其元素的自然顺序返回给定集合的最大元素。 集合中的所有元素必须实现Comparable接口。 此外，集合中的所有元素必须相互可比较 （即e1.compareTo(e2)不得为集合中的任何元素e1和e2投掷ClassCastException）。
//该方法遍历整个集合，因此它需要与集合的大小成比例的时间。
}

  自定义长度比较：

import java.util.Comparator;
public class CompareByLength  implements Comparator {
    @Override
    public int compare(Object o, Object t1) {
      String  s1=(String) o;
      String  s2=(String)t1;
      int  temp= s1.length()-s2.length();
        return temp ==0 ? (s1.compareTo(s2)) :temp;//这一一句是 如果字符串长度相同。
    }
}