Java中的集合框架-Collections和Arrays

　　上一篇《Java中的集合框架-Map》把集合框架中的键值对容器Map中常用的知识记录了一下，本节记录一下集合框架的两个工具类Collections和Arrays

一，Collections

　　Collections类中的方法全部都是静态的，它可以对Collection和Map进行一些操作，并返回这些接口的对象或操作结果。

　　1，Collections的字段

　　Collections有三个静态字段：EMPTY_LIST，EMPTY_MAP，EMPTY_SET；这三个字段分别返回一个空的List，Map和Set并且是不可修改的，当我们试图修改这三个返回的集合容器时，会抛出java.lang.UnsupportedOperationException异常；只所以不能修改这三个返回的集合容器，原因是被返回的这三个容器都是final所修饰的。

2，Collections的方法

    private static void fun_demo1() {
        ArrayList list = new ArrayList();
        Collections.addAll(list, "a", "b", "c");// addAll方法，将三个元素添加到list集合中
        int result = Collections.binarySearch(list, "b");// 使用二分查找法查询一个元素在容器中的位置，若没有该元素则返回-1
        System.out.println("二分查找元素位置：" + result);
        // 返回一个类型安全的容器，相当于Collection<String> al=new ArrayList<String>();
        Collection al = Collections.checkedCollection(new ArrayList(), String.class);
        // checkedList,checkedSet,checkedMap与上面相同，不再操作
        ArrayList list2 = new ArrayList();
        Collections.addAll(list2, "d", "e", "f");
        Collections.copy(list, list2);// 将一个List2中的内容复制到List中此时list中元素的长度应当大于等于list2的长度
        System.out.println(list);
        System.out.println(Collections.disjoint(list, list2));// 若两个容器没有相同的元素则返回true
        Collections.emptyList();
        Collections.emptySet();
        Collections.emptyMap();// 这三个方法返回三个空的，不可添加元素的容器对象
        Enumeration enumeration = Collections.enumeration(list);// 返回collection上的枚举器对象
        Collections.fill(list, "555");// 使用“555”把list中的所有元素都替换掉
        System.out.println(Collections.frequency(list2, "d"));// 返回list2中等于“d”的元素数量
        System.out.println(Collections.indexOfSubList(list, list2));// 返回list中第一次出现list2的位置
        System.out.println(Collections.lastIndexOfSubList(list, list2));// 返回list中最后一次出现list2的位置
        ArrayList aList = Collections.list(enumeration);// 返回一个ArrayList，接收一个枚举器对象
        System.out.println(Collections.max(list));// 返回集合中的最大元素，此方法有一个重载的版本可以接收一个自定义比较器自行指定比较的方式
        System.out.println(Collections.min(list));// 返回集合中的最小元素，此方法也有一个重载可接收一个比较器
        System.out.println(Collections.nCopies(3, "777"));// 返回一个由三个“777”组成的不可修改的List
        System.out.println(Collections.newSetFromMap(new HashMap()));// 从Map转为Set
        Collections.replaceAll(list2, "d", "33333");// 使用“33333”替换容器中的“d”
        Collections.reverse(list2);// 反转容器中的元素
        Collections.reverseOrder();// 返回一个比较器对象,它还可以接收一个比较器参数
        Collections.rotate(list2, 1);// 根据指定距离轮换容器中的元素
        System.out.println(list2);
        Collections.shuffle(list2);// 使用默认随机对指定列表进行转换,此方法还可以接收一个Random随机种子
        System.out.println(list2);
        Collections.sort(list);// 排序，可再接收一个参数比较器对象，指定排序方式
        Collections.swap(list2, 1, 2);// 交换两个指定位置的元素
        System.out.println(list2);
        Collections.synchronizedCollection(list);//返回一个线程安全的Collection对象
        Collections.synchronizedList(list);//返回一个线程安全的List，还有synchronizedSet以及synchronizedMap
        Collections.unmodifiableCollection(list);//返回一个不可修改的Collection
        Collections.unmodifiableList(list);//返回一个不可修改的List，还有unmodifiableSet和unmodifiableMap
    }

 

二，Arrays

　　此类包含了用来操作数组的静态方法，通过此类还可以将数组转为List来查看。若此数组为null则在调用此方法后会抛出空指针异常。具体演示如下：

　　1，asList(T... e)方法，将数组或数组元素转为一个不可修改的List视图

    private static void fun_demo2() {
        int[] arry = { 1, 2, 3, 4, 5, 6 };//
        List list1 = Arrays.asList(arry);// 将数组转为List，此时List中只包含了一个元素即arry的引用，并且此List不可修改
        System.out.println(list1.size());// 此时size为1
        List list = Arrays.asList(1, 2, 3, 4, 5, 6);// 将数组元素转为List
        System.out.println(list.size());// 此时size为6
        Object[] obj = list.toArray();// 可以用Collection的toArray方法用于List和数组的互转
    }

　　2，binarySearch方法

　　　　此方法有很多个重载的版本，可以对各种基本数据类型的数组以二分查找法查找指定值在数组中的位置，若没有该值，则返回一个负值，所返回的负值加1便是该值若存在时应该在的位置。

　　　　当此方法处理泛型时，可指定一个比较器用于对泛型元素进行比较。

public class MyComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {

        return o1.toString().compareTo(o2.toString());
    }

}

    private static void fun_demo3() {
        int[] arry = { 1, 2, 10, 4, 23, 9 };//
        int result = Arrays.binarySearch(arry, 0, arry.length, 8);// 使用二分查找法查找元素的位置，返回-3，此返回值+1便是应该在数组中的位置
        System.out.println(result);
        String[] str = { "abc", "adei", "zkdie", "nmkiek" };
        System.out.println(Arrays.binarySearch(str, "zkdie", new MyComparator()));//使用泛型可指定一个比较器
    }

 

 　　3，copyof方法

　　　　此方法也有多个重载的版本，可以对各种基本数据类型的数组进行截取或扩展，当此方法的第二个参数大于原数组的长度时，它便扩展；当小于原数组的长度时它便截取。

　　　　此方法截取或扩展后返回一个原数组的副本，若是截取则从第一个元素开始；若是扩展则是在扩展位置填充该数组类型的默认值。操作如下：

    private static void fun_demo4() {
        int[] arry = { 1, 2, 10, 4, 23, 9 };//
        arry = Arrays.copyOf(arry, 10);// 对数组进行扩展，扩展位置填充0
        System.out.println(arry.length);
        for (int i = 0; i < arry.length; i++) {
            System.out.print(arry[i]);
            System.out.print("    ");
        }
        arry = Arrays.copyOf(arry, 3);// 截取数组
        System.out.println(arry.length);
        for (int i = 0; i < arry.length; i++) {
            System.out.print(arry[i]);
            System.out.print("    ");
        }
    }

　　4，copyOfRange方法

　　　　此方法将指定数组的指定位置复制到一个新数组中，也有多个重载的版本，可处理各种基本类型的数组，操作如下：

    private static void fun_demo5() {
        int[] arry = { 1, 2, 10, 4, 23, 9 };//
        arry = Arrays.copyOfRange(arry, 2, 5);//指定截取位置的复制，位置包括头不包括尾
        for (int i = 0; i < arry.length; i++) {
            System.out.print(arry[i]);
            System.out.print("    ");
        }
    }

　　5，deepEquqls，deepHashCode和deepToString方法

　　这三个方法中第一个方法接收两个参数分别为两个Object类型的数组，是深度比较两个Object类型的数组是否相同，它比较的时候若此Object数组是个二维数组则会进一步比较二维数组中的内容，即深度比较。

第二个方法接收一个Object类型的数组，若此Object类型的数组是个二维数组，则对其中的元素进行相关计算后返回一个hashcode码

第三个方法也接收一个Object类型的组，返回此数组的直接字符串形式而不是一个hashCode码加上一个“[”。演示如下：

    private static void fun_demo6() {
        Object[] arry = { 1, 2, 10, 4, 23, 9 };//
        System.out.println(arry.toString());
        System.out.println(Arrays.deepToString(arry));
        Object[] arry1 = { 1, 2, 10, 4, 23, 9 };//
        System.out.println(Arrays.deepEquals(arry, arry1));
    }

 

　　6，equals方法

　　　　此方法有多个重载的版本，也处理各种基本的数组。接收两个基本类型数组参数，如果两个参数数组相等，则返回true。

　　7，fill方法

　　　　此方法有多个重载的版本，能处理各种基本类型的数组。接收两个参数，第一个为需要处理的数组，第二个为替换的值。此方法的功能就是拿第二个参数把数组中的所有元素都替换掉，演示如下：

    private static void fun_demo7() {
        Object[] arry = { 1, 2, 10, 4, 23, 9 };//
        Arrays.fill(arry, 0, 3, 0);//指定替换的位置
        System.out.println(Arrays.deepToString(arry));
        Arrays.fill(arry, 0);//全部替换
        System.out.println(Arrays.deepToString(arry));
    }

 　　8，hashcode与toString方法

　　　　这两个方法第一个返回数组的hash值，第二个返回数组的字符串表示形式；

　　　　它与deepHashCode和deepToString方法的不同之处在于当是一维数组时hashcode与deepHashCode方法返回结果相同，二维数组返回值则不同；

　　　　deepToString方法返回数组内容的字符串表示形式，而toString方法则返回"["+数组类型的简称+数组的hashCode

    private static void fun_demo8() {
        Object[][] arry = new Object[5][5];
        arry[0][0] = 1;
        arry[0][1] = 2;
        arry[0][3] = 3;
        arry[1][0] = 1;
        arry[1][1] = 2;
        arry[1][3] = 3;
        arry[2][0] = 1;
        arry[2][1] = 2;
        arry[2][3] = 3;
        arry[3][0] = 1;
        arry[3][1] = 2;
        arry[3][3] = 3;
        System.out.println(Arrays.deepHashCode(arry));
        System.out.println(Arrays.hashCode(arry));
        System.out.println(Arrays.deepToString(arry));
        System.out.println(Arrays.toString(arry));
    }

　　9，sort方法

　　　　此方法用在开发中比较多，对数组内容的排序操作，此方法没有返回值，排序后影响原来数组中的内容；默认按照升序排序，操作如下：

    private static void fun_demo9() {
        Object[] array = { 89, 9, 34, 2, 0, 1, -2 };
        Arrays.sort(array);
        System.out.println(Arrays.deepToString(array));
    }

　　　　也可指定对数组中的部分元素进行排序，操作如下：

    private static void fun_demo9() {
        Object[] array = { 89, 9, 34, 2, 0, 1, -2 };
        Arrays.sort(array, 3, 6);//指定从哪个索引开始排序到哪个索引结束排序，包括开始不包括结束
        System.out.println(Arrays.deepToString(array));
    }

　　　　也可以指定一个比较器对象，指定排序的方式，示例如下：

public class MyComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {

        return o2.toString().compareTo(o1.toString());
    }

}

　　　　按照降序对字符串进行排序

    private static void fun_demo10() {
        String[] str = { "abkcie", "kdiek", "iweeoie9", "7382akbik", "kdoiw", "null" };
        Arrays.sort(str, new MyComparator());
        System.out.println(Arrays.deepToString(str));
    }