黑马程序员_日记62_Collections工具类方法

——- android培训、java培训、期待与您交流！ ———-

import java.util.*;
public class CollectionsDemo 
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

    public static void main(String[] args) 
    {
        //建立一个字符串集合
        List<String> list = new ArrayList<String>();

        //添加字符串
        list.add("qbcdef");
        list.add("cef");
        list.add("af");
        list.add("ab");
        list.add("wbf");
        list.add("b");
        list.add("k");

        //sortDemo(list);//字典序排序
        lenSortDemo(list);//字符串长度排序
        //maxDemo(list);//最大字典序字符串
        //maxLenDemo(list);//最大长度字符串
        //binarySearchDemo(list,"af");//二分查找返回指定元素角标
        //注意：如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
        //binarySearchDemo(list,"aaaaaa");
        sop(Collections.binarySearch(list,"k",new StrLenComparator()));
        //sop(halfSearch(list,"af"));//折半原理测试，返回指定元素角标
        //sop(halfSearch(list,"ac"));//折半原理测试，返回插入点的相反数-1
        //sop(halfSearch_2(list,"c",new StrLenComparator()));//折半自定义比较器查找原理
        //sop(halfSearch_2(list,"k",new StrLenComparator()));//折半自定义比较器查找原理

    }

    //sort
    public static void sortDemo(List<String> list)
    {
        //打印原集合
        sop(list);
        //排序
        Collections.sort(list);
        //打印排序后集合
        sop(list);      
    }

    //sort字符串长度
    public static void lenSortDemo(List<String> list)
    {
        //打印原集合
        sop(list);
        //按字符串长度排序
        Collections.sort(list,new StrLenComparator());
        //打印排序后集合
        sop(list);          
    }

    //max字典序字符串
    public static void maxDemo(List<String> list)
    {
        sop(list);
        //获取字典序最大字
        String max = Collections.max(list);
        //打印max
        sop("max="+max);    
    }

    //获取最长字符串
    public static void maxLenDemo(List<String> list)
    {
        sop(list);
        //获取长度最大字符串
        String max = Collections.max(list,new StrLenComparator());
        //打印max
        sop("max="+max);    
    }

    //binarySearchDemo
    public static void binarySearchDemo(List<String> list,String key)
    {
        //二分查找要求集合必须是有序的，先排序
        Collections.sort(list);
        //根据集合和指定元素使用二分查找，最后返回的是该指定元素的角标
        int index = Collections.binarySearch(list,key);
        //打印指定元素的角标
        sop("index="+index);
    }

    //binaraySearch原理
    public static int halfSearch(List<String> list ,String key)
    {
        sortDemo(list);//字典序排序
        //对已经是自然序的集合进行折半查找
        //头指针，折半指针，尾指针
        int min,mid,max;
        min = 0;
        max = list.size()-1;

        //当头指针小于等于尾指针的时候，循环查找
        while(min <= max)
        {
            mid = (min + max)>>1;//等价于min = (min + max)/2但是移位操作更省资源
            //根据折半得到的指针，取出元素
            String str = list.get(mid);
            //对取出的元素和关键字进行比较
            int num = str.compareTo(key);
            //如果关键字在str的右边
            if(num > 0)
            {
                //头指针不动，尾指针移动
                max = mid - 1;
            }
            //如果关键字在str的左边
            else if( num < 0)
            {
                //头指针移动，尾指针不动
                min = mid + 1;
            }
            //如果关键字等于str
            if( num == 0)
            {
                //返回关键字的角标
                return mid;
            }
        }
        //如果找不到返回插入点的相反数-1
        return -min-1;
    }

    //binaraySearch传自定义比较器原理
    public static int halfSearch_2(List<String> list ,String key,Comparator<String> comparator)
    {
        lenSortDemo(list);//字符串长度排序
        //对已经是自然序的集合进行折半查找
        //头指针，折半指针，尾指针
        int min,mid,max;
        min = 0;
        max = list.size()-1;

        //当头指针小于等于尾指针的时候，循环查找
        while(min <= max)
        {
            mid = (min + max)>>1;//等价于min = (min + max)/2但是移位操作更省资源
            //根据折半得到的指针，取出元素
            String str = list.get(mid);
            //对取出的元素和关键字进行比较
            int num = comparator.compare(str,key);
            //如果关键字在str的右边
            if(num > 0)
            {
                //头指针不动，尾指针移动
                max = mid - 1;
            }
            //如果关键字在str的左边
            else if( num < 0)
            {
                //头指针移动，尾指针不动
                min = mid + 1;
            }
            //如果关键字等于str
            if( num == 0)
            {
                //返回关键字的角标
                return mid;
            }
        }
        //如果找不到返回插入点的相反数-1
        return -min-1;
    }
}

//构造字符串长度比较器
class StrLenComparator implements Comparator<String>
{
    public int compare(String str1 ,String str2)
    {
        int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
        if(num == 0)
            return str1.compareTo(str2);
        return num;
    }
}

Collections排序方法，排序结果是自然顺序。

Collections获取最大元素方法，可以根据自然顺序排序之后，获取最大元素。
也可以自定义比较器，根据自定义比较器排序的结果，获取最大元素。
字典序最大的元素

最长的字符串

根据字符串长度排序

binarySearch的两种情况得到的返回值。
情况一是：关键字在集合内。在集合内则返回关键字的角标
情况二是：关键字不在集合内。不在集合内则返回插入点的相反数-1

根据自定义比较器排序后，再用折半查找关键字