Java 集合框架工具类--17

集合框架的工具类

Collections
Arrays

import java.util.*;
class CollectionsDemo
{
    public static void main(String[] args)
    {
        sortDemo();
        maxDemo();
        binarySearchDemo();
    }

    //二分查找
    public static void binarySearchDemo()
    {
        List<String> list = new ArrayList<String>();

        list.add("abcd");
        list.add("cc");
        list.add("afd");
        list.add("z");
        list.add("gg");
        list.add("cc");


        Collections.sort(list);

        sop(list);

        int index = Collections.binarySearch(list,"cc");

        sop("index="+index);
    }

    //最大值
    public static void maxDemo()
    {
        List<String> list = new ArrayList<String>();

        list.add("abcd");
        list.add("cc");
        list.add("afd");
        list.add("z");
        list.add("gg");
        list.add("gg");

        Collections.sort(list);
        //Collections.sort(list,new StrLenComparator());
        sop(list);

        String max = Collections.max(list);
        //String max = Collections.max(list,new StrLenComparator());


        sop("max="+max);
        sop("--------------------------");
    }

    //排序
    public static void sortDemo()
    {
        List<String> list = new ArrayList<String>();

        list.add("abcd");
        list.add("cc");
        list.add("afd");
        list.add("z");
        list.add("gg");
        list.add("gg");

        sop(list);

        //Collections.sort(list);
        Collections.sort(list,new StrLenComparator());

        sop(list);
        sop("--------------------------");
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
class StrLenComparator implements Comparator<String>
{
    public int compare(String s1,String s2)
    {
        if(s1.length()>s2.length())
            return 1;
        if(s1.length()<s2.length())
            return -1;
        return s1.compareTo(s2);
    }
}

import java.util.*;

class CollectionsDemo2
{
    public static void main(String[] args)
    {
        fillDemo();
        sop("------------------");
        replaceAllDemo();
        sop("------------------");
        orderDemo();
    }

    public static void orderDemo()
    {
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));

        ts.add("aaa");
        ts.add("advg");
        ts.add("bxs");
        ts.add("ff");
        ts.add("z");

        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }

    //使用另一个值替换列表中出现的所有某一指定值
    public static void replaceAllDemo()
    {
        List<String> list = new ArrayList<String>();

        list.add("abcd");
        list.add("ad");
        list.add("ad");
        list.add("qq");
        list.add("c");

        sop(list);

        Collections.replaceAll(list,"ad","zx");

        sop(list);
    }

    //使用指定元素替换指定列表中的所有元素。 
    public static void fillDemo()
    {
        List<String> list = new ArrayList<String>();

        list.add("abcd");
        list.add("ad");
        list.add("qq");
        list.add("c");

        sop(list);
        Collections.fill(list,"pp");
        sop(list);

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

Arrays:用于操作数组的工具类
里面都是静态方法。

asList:将数组变成list集合

import java.util.*;
class ArraysDemo
{
    public static void main(String[] args)
    {
        //int[] arr = {2,4,5};

        //System.out.println(Arrays.toString(arr));



        String[] arr = {"abs","cc","kkkk"};

        //把数组变成list集合有什么好处？
        /*
        可以使用集合的思想和方法来操作数组中的元素。

        注意：将数组变成集合，不可以使用集合的增删方法。
        因为数组的长度是固定的。
        contains
        get
        indexOf()
        subList()

        如果使用增删会出现不支持操作异常UnsupportedOperationException

        */
        List<String> list = Arrays.asList(arr);

        //sop("contains:"+list.contains("cc"));
        //list.add("qq");//UnsupportedOperationException
        //sop(list);

        int[] nums = {2,4,5};

        List<int[]> li = Arrays.asList(nums);

        Integer[] num = {2,3,5};

        List<Integer> l = Arrays.asList(num);
        /*
        如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
        如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
        Integer封装的是对象
        */
        sop(li);
        sop(l);
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }


}

集合变数组
Collection接口中的ToArray方法。

import java.util.*;
class CollectionToArray
{
    public static void main(String[] args)
    {
        ArrayList<String> al = new ArrayList<String>();

        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        /*
        1,指定类型的数组到底要定义多长呢？
        当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size
        当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组。
        所以创建一个刚刚好的数组最好。

        2,为什么要将集合变数组？
        为了限定对元素的操作。不需要进行增删了。
        */


        String[] arr = al.toArray(new String[al.size()]);
        System.out.println(Arrays.toString(arr));
    }
}

高级for循环

格式：
for（数据类型 变量名：被遍历的集合(Collection)或者数组）
{

}

对集合进行遍历，
只能获取集合元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的动作

import java.util.*;

class ForEachDemo
{
    public static void main(String[] args)
    {
        ArrayList<String> al = new ArrayList<String>();

        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        for(String s:al)
        {
            System.out.println(s);
        }
System.out.println("-------------------------------------");


        int[]arr = {2,4,6};
        for(int i:arr)
        {
            System.out.println("i:"+i);
        }
System.out.println("-------------------------------------");


        HashMap<Integer,String> hm = new HashMap<Integer,String>();

        hm.put(1,"a");
        hm.put(2,"b");
        hm.put(3,"c");

        //keySet写法
        Set<Integer> keySet = hm.keySet();
        for(Integer i:keySet)
        {
            System.out.println(i+"::"+hm.get(i));
        }
System.out.println("-------------------------------");

        //entrySet写法
        Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
        for(Map.Entry<Integer,String> k:entrySet)
        {
            System.out.println(k);
        }
System.out.println("-------------------------------");

        //entrySet写法二
        for(Map.Entry<Integer,String> k:hm.entrySet())
        {
            System.out.println(k.getKey()+"++++"+k.getValue());
        }

    }
}

JDk1.5版本出现的新特性

方法的可变参数
使用时注意可变参数一定要定义在参数列表的最后位置

class ParamMethodDemo
{
    public static void main(String[] args)
    {
        //show(3,4);
        //show();
        show("as",3,4,6,6);//打印结果4
    }

    /*
    可变参数，其实就是上一种数组参数的简写形式
    不用每一次都手动的建立数组对象
    只要将要操作的元素作为参数传递即可
    隐式将这些参数封装成了数组
    */

    public static void show(String str,int... arr)
    {
        System.out.println(arr.length);
    }


    /*
    public static void show(int a,int b)
    {
        System.out.println(a+","+b);
    }
    public static void show(int a,int b,int c)
    {}
    */  

}

静态导入
StaticImport

当类名重名时，需要指定具体的包名
当方法重名时，指定具备所属的对象或者类

import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。

/*
packa/Demo.class
packb/Demo.class

import packa.*;
import packb.*;
*/

import static java.lang.System.*;//导入了System中所有的静态成员

class StaticImport
{
    public static void main(String[] args)
    {
        out.println("hha");
        int[] arr = {3,1,5};

        sort(arr);
        int index = binarySearch(arr,1);
        out.println(Arrays.toString(arr));

        out.println("Index="+index);
    }
}