美文网首页
Java学习之集合工具类

Java学习之集合工具类

作者: 玉圣 | 来源:发表于2017-05-31 17:18 被阅读78次

    一、Util 工具类

    工具类的Collections和Arrays中的方法全是静态的,下面主要总结几个比较重要的方法。

    1、Collections工具类:

    在Collections工具类中很多方法是用于对List集合进行操作的,如比较,查找,随机排序等等
    1、集合的各种方法:
    1)查找:
    T max(Collection<? extends T> coll) ---> 根据集合的自然顺序,获取coll集合中的最大元素
    T max(Collection<? extends T> coll,Comparator<? super T> comp) ---> 根据指定比较器comp的顺序,获取coll集合中的最大元素
    int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey) ---> 二分法搜索list集合中的指定对象
    2)替换:
    void fill(List<? super T> list, T obj) ---> 将list集合中的全部元素替换成指定对象obj
    boolean replaceAll(List<T> lsit,T oldVal,T newVal) ---> 使用newVal替换list集合中的oldVal值

    3)排序:
    void shuffle(List<?> list) ---> 使用默认随机源对list集合中的元素进行随机排序
    void sort(Lsit<T> list) ---> 根据自然顺序对list集合中的元素进行排序
    void sort(List<T> lsit,Comparator<? super T> c) ---> 根据指定比较器c的排序方式对list集合进行排序

    4)反转
    reverse(List<?> list) ---> 反转list集合中元素的顺序
    Comparator reverseOrder() ---> 返回一个比较器,强行逆转了实现Comparable接口的对象的自然顺序
    Comparator reverseOrder(Comparator<T> cmp) ---> 返回一个比较器,强行逆转了指定比较器的顺序

    示例:

        ......  
        public static void sop(Object obj)  
        {  
            System.out.println(obj);  
        }  
        //定义比较器  
        class StrLenCom implements Comparator<String>  
        {  
            public int compare(String s1,String s2)  
            {  
                int n = new Integer(s1.length()).compareTo(new Integer(s2.length()));  
                if (n == 0)  
                    return s1.compareTo(s2);  
                return n;  
            }  
        }  
        ......  
            List<String> list = new ArrayList<String>();  
            list.add("abd");  
            list.add("cd");  
            list.add("f");  
            list.add("yyyy");  
            list.add("abd");  
            //打印原集合  
            sop(list);  
            sop("--------------排序-------------------");  
            //随机排序:  
            Collections.shuffle(list);  
            sop("随机排序:" + list);  
            //对元素排序,存入的对象必须具备比较性  
            Collections.sort(list);  
            //打印新集合  
            sop("自然排序后的集合元素:" + list);  
            //按指定比较器顺序排序  
            Collections.sort(list,new StrLenCom());  
            sop("长度排序:" + list);  
            sop("------------获取最大元素-----------------");  
            //获取最大元素  
            String max = Collections.max(list);  
            sop("max = " + max);  
            sop("--------------查找--------------------");  
            int index = Collections.binarySearch(list,"acd");  
            sop("二分法查找值:" + index);  
            int ex = half(list,"acd");  
            sop("二分法查找值:" + ex);  
            Collections.sort(list,new StrLenCom());  
            sop("排序后的集合元素:" + list);  
            int x = half2(list,"acd",new StrLenCom());  
            sop("二分法查找值:" + x);  
            sop("---------------替换-反转----------------");  
            //反转  
            Collections.reverse(list);  
            sop("反转后:" + list);  
            //替换  
            Collections.fill(list,"pp");  
            sop("替换后:" + list);  
        ......
    

    创建部分替换方法:

    //替换部分字符  
        public static void fillPart(List<String> list,int start,int end,String str)  
        {  
            List<String> li = new ArrayList<String>();  
            for(int i=start;i<end;i++)  
            {  
                li.add(list.get(i));  
                list.remove(list.get(i));  
            }  
            sop(list);  
            Collections.fill(li,str);  
            list.addAll(start,li);  
        }  
    }
    

    2、Arrays工具类:

    1、Lsit<T> asList(T... a) ---> 将数组转换为集合

    注意:
    将数组转换成集合,不可使用集合的增删方法,因为数组的长度是固定的,如果进行增删操作,则会产生UnsupportedOperationException的编译异常。
    a.如果数组中的元素都是对象,则变成集合时,数组中的元素就直接转为集合中的元素
    b.如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在

    2、binarySearch():查找方法,fill():替换方法,sort():排序方法等
    特点:可对数组元素进行相应操作,可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数,且还可以对指定元素的范围,并可根据指定比较器进行相应的操作

    如:
    sort(T[] a,Comparator<? super T> c)
    fill(int[]a,int from,int to)

    3、String toString() 可以接收各种数组类型参数,并返回指定数组内容的字符串表现形式

    4、集合转为数组
    void toString(String[] s) ---> 将集合转为指定数组s,并可通过Arrays.toString(s)获取数组s中的元素

    1)指定类型的数组定义的长度:
    a.当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组,长度为集合的size
    b.当指定类型的数组长度大于了集合的size,就不会创建数组,而是使用传递进来的数组,并且多出的元素的值为null

    2)为何将集合转为数组:为了限定对集合中元素的操作,如增删,因为想对创建的集合不做增删方面的操作。

    示例:

        ......  
        public static void sop(Object obj)  
        {  
            System.out.println(obj);  
        }  
        ......  
        int[] arr = {5,8,6};  
        sop("toString : int[]转为集合:" + Arrays.toString(arr));  
          
        String[] sarr = {"ac","eg","nse","gui"};  
        List<String> list = Arrays.asList(sarr);  
        sop("asList--String对象数组转集合:" + list);  
      
        List<int[]> li = Arrays.asList(arr);  
        sop("asList--int[]转集合:" + li);  
        Integer[] iarr = {5,8,6};  
        List<Integer> lis = Arrays.asList(iarr);  
        sop("asList--Integer[]转集合:" + lis);  
        ......
    

    集合转数组:

            ArrayList<String> as = new ArrayList<String>();  
            as.add("01");  
            as.add("02");  
            as.add("03");  
            sop("原集合" + as);  
            String[] s = new String[as.size()];  
            as.toArray(s);  
            sop("新数组" + Arrays.toString(s));
    

    二、小知识点

    1、增强for循环

    1、格式:
    for(数据类型 变量名 : 被遍历的集合(Collection)或数组){执行语句}

    2、说明:
    1)对集合进行遍历,只能获取集合的元素,但是不能对集合进行操作。
    2)迭代器除了遍历外,还可进行remove集合中元素的操作,如果使用ListIterator,还可在遍历过程中,对集合进行增删改查的操作。

    3、传统for循环和增强for循环区别:
    增强for循环有局限性。必须有被遍历的目标;而传统for循环有索引。所以建议在遍历数组时,使用传统for循环。

    示例:

    import java.util.*;  
    class ForEachDemo  
    {  
        //打印方法  
        public static void sop(Object obj)  
        {  
            System.out.println(obj);  
        }  
      
        //测试  
        public static void main(String[] args)   
        {  
            //创建集合  
            ArrayList<String> as = new ArrayList<String>();  
            as.add("01-a");  
            as.add("02-b");  
            as.add("03-c");  
            System.out.println("原集合" + as);  
            //增强for循环取出元素  
            for (String s : as)  
            {  
                System.out.println(s);  
            }  
            System.out.println("-------------------------");  
            //创建HashMap集合  
            HashMap<Integer,String> hm = new HashMap<Integer,String>();  
            hm.put(1,"a");  
            hm.put(2,"b");  
            hm.put(3,"c");  
            hm.put(4,"d");  
            System.out.println("hm原集合:" + hm);  
            //增强for循环的两种方式测试  
            //keySet方法  
            sop("keySet方法:|--");  
            for(Integer i : hm.keySet())  
            {  
                sop(i + ":-" + hm.get(i));            
            }  
            //entrySet方法  
            sop("entrySet方法--");  
            for(Map.Entry<Integer,String> me : hm.entrySet())  
            {  
                sop(me.getKey() + "-->" + me.getValue());  
            }  
        }  
    }
    

    2、可变参数:

    如果在参数列表中传入多个参数,个数不确定,每次都要复写该方法,可变参数的出现就可以省去复写的麻烦,而直接对数组进行操作

    注意:可变参数一定要定义在参数列表的后面。

    示例:

    ......  
        //1.5版本前写法  
        public static void show(int a,int b)  
        {  
            System.out.println(a + " :" + b);  
        }  
        //1.5新特性,可加入更多的值  
        public static void show(int... arr)  
        {  
            System.out.println(arr.length);//结果为数组arr的长度  
            System.out.println(arr);//arr的地址值  
        }  
        public static void print(String... s)  
        {  
            //遍历字符串数组s  
            for(String str : s)  
            {  
                System.out.print(str);  
            }  
            System.out.println();  
        }  
          
        ......
    

    3、静态导入:

    静态导入,是将类中的所有静态成员导入进来,但需要注意的是,当导入的两个类中有同名成员时,需要在成员前加上相应的类名。
    当类名重名时,需要制定具体的包名;当方法名重名时,制定具体所属的对象或类。

    1、import static java.util.Arrays.*; ---> 写入的是Arrays类中的所有静态成员。

    2、import static java.lang.System.*; ---> 导入了System类中的所有静态成员

    示例:

    import java.util.*;  
    import static java.util.Arrays.*;//导入的是Arrays类中的所有静态成员  
    import static java.lang.System.*;//导入的是System类中的所有静态成员  
    class Demo  
    {  
        public static void main(String [] args)  
        {  
            int[] arr = {2,7,6,3};  
            sort(arr);  
            out.println(Arrays.toString(arr));//此处不可省略Arrays,原因见下  
      
        }  
    }
    

    相关文章

      网友评论

          本文标题:Java学习之集合工具类

          本文链接:https://www.haomeiwen.com/subject/aysjfxtx.html