Collections 工具类和 Arrays 工具类常见方法

Collections

Collections 工具类常用方法：

1、排序

2、查找，替换

3、同步控制（一般不推荐使用，需要线程安全集合类型时考虑用 JUC 包下的并发集合）

参考资料：JDK_API_1.8_zh_CN 中 Java.util 下的 Collections

1、排序操作

void reverse(List list) //反转指定列表中元素的顺序。
void shuffle(List list) //使用默认的随机源随机排列指定的列表。 
void sort(List list)    //按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由 Comparator 控制排序逻辑
void swap(List list,int i,int j);//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。将指定列表中的元素旋转指定的距离

代码实操：

package com;


import java.util.*;

/*
 * @Description: Collections 的排序操作
 * @param null
 * @return: 
 *
 * @Creator: xiaoxin
 * @Date: 2020/7/25 16:33
 *
 * @Modify: xiaoxin
 * @Date: 2020/7/25 16:33
 *
 */

public class Calculator {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        int a = 10;
        for (int i = 0; i <= a; i++) {
            arrayList.add(i);
        }
        System.out.println("原始数据：" + arrayList);

        // void reverse（List list）反转
        Collections.reverse(arrayList);
        System.out.println("Collections.reverse(arrayList)：" + arrayList);

        // void rotate(List list, int distance)//旋转。将指定列表中的元素旋转指定的距离
        Collections.rotate(arrayList,4);
        System.out.println("Collections.rotate(arrayList,4)：" + arrayList);

        // void sort(List list)    按自然排序的升序排序
        Collections.sort(arrayList);
        System.out.println("Collections.sort(arrayList)：" + arrayList);

        // void shuffle(List list) //使用默认的随机源随机排列指定的列表。
        Collections.shuffle(arrayList);
        System.out.println("Collections.shuffle(arrayList)：" + arrayList);

        // void swap(List list,int i,int j);//交换两个索引位置的元素
        Collections.swap(arrayList,0,1);
        System.out.println("Collections.swap(arrayList,0,1)：" + arrayList);

        // 定制排序用法
        Collections.sort(arrayList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println("定制排序后：" + arrayList);
    }
}

输出结果：

原始数据：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Collections.reverse(arrayList)：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Collections.rotate(arrayList,4)：[3, 2, 1, 0, 10, 9, 8, 7, 6, 5, 4]
Collections.sort(arrayList)：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Collections.shuffle(arrayList)：[5, 6, 1, 10, 0, 7, 8, 4, 2, 9, 3]
Collections.swap(arrayList,0,1)：[6, 5, 1, 10, 0, 7, 8, 4, 2, 9, 3]
定制排序后：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

2、查找，替换

int binarySearch(List list, Object key) //对 List 进行二分查找，返回索引，注意 List 必须是有序的，否则会返回未定义的结果
int max(Collections coll) //根据其元素的自然顺序返回给定集合的最大元素。
int min(Collections coll) //根据其元素的自然顺序返回给定集合的最小元素。
int max(Collectiosn coll,Comparator comp)//根据指定的比较器引发的顺序，返回给定集合的最大元素
void fill(List list,T obj) //用指定元素代替列表中的所有元素
int frequency(Collection c, Object o) //返回集合中指定元素出现的次数
int indexOfSubList(List list,List target)//统计 target 在 list 中第一次出现的索引，如果没有，则返回-1。
boolean replaceAll(List list,Object oldval,Object newVal) //用新元素替换旧元素

代码实操：

package com;


import java.util.*;

/*
 * @Description: Collections 的查找和替换
 * @param null
 * @return:
 *
 * @Creator: xiaoxin
 * @Date: 2020/7/25 16:33
 *
 * @Modify: xiaoxin
 * @Date: 2020/7/25 16:33
 *
 */

public class Calculator {
    public static void main(String[] args) {
        //新建一个 arrayList 集合
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        int a = 10;
        for (int i = 0; i <= a; i++) {
            arrayList.add(i);
        }
        //添加个重复元素，待会要用到
        arrayList.add(3);

        ArrayList<Integer> arrayList1 = new ArrayList<Integer>();
        arrayList1.add(0);
        arrayList1.add(1);
        arrayList1.add(2);
        System.out.println("原始数据：" + arrayList);

        // int max(Collections coll) //根据其元素的自然顺序返回给定集合的最大元素。
        System.out.println("Collections.max(arrayList)：" + Collections.max(arrayList));

        // int min(Collections coll) //根据其元素的自然顺序返回给定集合的最小元素。
        System.out.println("Collections.min(arrayList)：" + Collections.min(arrayList));

        // int binarySearch(List list, Object key) 对 List 进行二分查找，返回索引，注意 List 必须是有序的，否则会返回未定义的结果
        System.out.println("Collections.binarySearch(arrayList,1)：" + Collections.binarySearch(arrayList,1));

        // boolean replaceAll(List list,Object oldval,Object newVal) //用新元素替换旧元素

        System.out.println("把 arrayList 集合中的 3 换成 1：" + Collections.replaceAll(arrayList,3,1));
        System.out.println(arrayList);

        //int frequency(Collection c, Object o) //返回集合中指定元素出现的次数
        System.out.println("1 在 arrayList 集合中出现了 " + Collections.frequency(arrayList,1) + " 次");

        //int indexOfSubList(List list,List target)//统计 target 在 list 中第一次出现的索引，如果没有，则返回-1。
        System.out.print("Collections.indexOfSubList(arrayList,arrayList1)：");
        System.out.println(Collections.indexOfSubList(arrayList,arrayList1));

        //void fill(List list,T obj) //用指定元素代替列表中的所有元素
        System.out.print("Collections.fill(arrayList1,1)：");
        Collections.fill(arrayList1,1);
        System.out.println(arrayList1);
    }

}

输出结果：

原始数据：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 3]
Collections.max(arrayList)：10
Collections.min(arrayList)：0
Collections.binarySearch(arrayList,1)：1
把 arrayList 集合中的 3 换成 1：true
[0, 1, 2, 1, 4, 5, 6, 7, 8, 9, 10, 1]
1 在 arrayList 集合中出现了 3 次
Collections.indexOfSubList(arrayList,arrayList1)：0
Collections.fill(arrayList1,1)：[1, 1, 1]

同步控制

Collection 提供了多个synchronizedXxx()方法，该方法可以将指定集合包装成线程同步的集合，解决多线程并发访问集合时的线程安全问题。

HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。Collections 提供多个静态方法可以把他们包装成线程同步的集合。

以下方法谨慎使用，效率低下，如果需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合

synchronizedCollection(Collection<T>  c) //返回指定 collection 支持的同步（线程安全的）collection。
synchronizedList(List<T> list)//返回指定列表支持的同步（线程安全的）List。
synchronizedMap(Map<K,V> m) //返回由指定映射支持的同步（线程安全的）Map。
synchronizedSet(Set<T> s) //返回指定 set 支持的同步（线程安全的）set。

Collections还可以设置不可变集合，提供了如下三类方法：

emptyXxx(): 返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set，还可以是Map。singletonXxx(): 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。
unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。
上面三类方法的参数是原有的集合对象，返回值是该集合的”只读“版本。

代码实操：

public class Calculator {
    public static void main(String[] args) {
       ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for (int i = 0; i <= 10; i++) {
            arrayList.add(i);
        }

        HashSet<Integer> integers = new HashSet<>();
        for (int i = 0; i < 3; i++) {
            integers.add(i);
        }

        Map scores = new HashMap();
        scores.put("python 从入门到精通",90);
        scores.put("java 从入门到精通",98);

        //Collections.emptyXXX();创建一个空的、不可改变的XXX对象
        List<Object> list = Collections.emptyList();
        System.out.println(list);
        Set<Object> set = Collections.emptySet();
        System.out.println(set);
        Map<Object,Integer> map = Collections.emptyMap();
        System.out.println(map);

        //Collections.singletonList();
        List<ArrayList<Integer>> arrayLists = Collections.singletonList(arrayList);
        System.out.println(arrayLists);
        //创建一个只有一个元素，而且不可以改变的 Set 对象
        Set<ArrayList<Integer>> singleton = Collections.singleton(arrayList);
        System.out.println(singleton);

        Map<String,String> stringMap = Collections.singletonMap("1","我是String");
        System.out.println(stringMap);

        //unmodifiableXXX();创建普通XXX对象对应的不可变版本
        List<Integer> integers1 = Collections.unmodifiableList(arrayList);
        System.out.println(integers1);
        Set<Integer> integers2 = Collections.unmodifiableSet(integers);
        System.out.println(integers2);
        Map<Object,Object> objectObjectMap2 = Collections.unmodifiableMap(scores);
        System.out.println(objectObjectMap2);
    }


}

输出结果：

[]
[]
{}
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
{1=我是String}
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 1, 2]
{java 从入门到精通=98, python 从入门到精通=90}

Process finished with exit code 0

Arrays 类的常见操作

排序：sort()

查找：binarySearch()

比较：equals()

填充：fill()

转列表：asList()

转字符串：toString()

复制：copyOf()

1、排序：sort()

代码实操：

public class Calculator {
    public static void main(String[] args) {
        int a[] = {1,3,5,7,9,2,4,6,8,10};
        //按照数字顺序排列指定的数组。
        Arrays.sort(a);
        System.out.println("Arrays.sort(a)：");
        for (int i : a){
            System.out.print(i);
        }
        //换行
        System.out.println();

        // void sort(int[] a,int fromIndex,int toIndex)。
        int b[] = {9,5,3,0,7,1,6,3,9};
        // 对 b 数组进行排序，范围是从 1 索引到 3 索引,索引 fromIndex （包括）扩展到索引 toIndex
        // 将 b 数组的【1,3) 进行排序
        Arrays.sort(b,1,3);
        System.out.println("Arrays.sort(b,1,3)：");
        for (int i : b) {
            System.out.print(i);
        }
        System.out.println();

        int c[] = {1,3,5,7,9,2,4,6,8,10};
        //parallelSort(int[] a) 按照数字顺序排列指定的数组。
        Arrays.parallelSort(c);
        System.out.println("Arrays.parallelSort(c)：");
        for (int i : c) {
            System.out.print(i);
        }
        System.out.println();

        //parallelSort(byte[] a) 按照数字顺序排列指定的数组。
        char d[] = {'a' , 'f' , 'b' , 'd' , 'h'};
        Arrays.parallelSort(d);
        System.out.println("Arrays.parallelSort(d)：");
        for (char d1 : d){
            System.out.print(d1);
        }
        System.out.println();
    }
}

     //对字符串进行排序，Arrays.sort() 对每个字符串的位置逐一比较，进行升序排序
        String []e = {"adfj","adfa","adfm"};
        Arrays.sort(e);
        System.out.println(Arrays.toString(e));

输出结果：

Arrays.sort(a)：
12345678910
Arrays.sort(b,2,6)：
935071639
Arrays.parallelSort(c)：
12345678910
Arrays.parallelSort(d)：
abdfh
[adfa,adfj,adfm]

2、查找：binarySearch()

代码实操：

public class Calculator {
    public static void main(String[] args) {
        // 查找 binarySearch()
        char[] e = {'a' , 'f' , 'b' , 'l' , 'c', 'A' , 'D' , 'C'};
        //先排序
        Arrays.sort(e);
        System.out.println("Arrays.sort(e)：" + Arrays.toString(e));
        int b = Arrays.binarySearch(e, 'b');
        System.out.println("b 在数组中的位置是：" + b);
    }
}

输出结果：

Arrays.sort(e)：[A, C, D, a, b, c, f, l]
b 在数组中的位置是：4

3、比较：equals()

代码实操：

  public static void main(String[] args) {
        // 比较 equals()
        char[] e = {'a' , 'f' , 'b' , 'l' , 'c', 'A' , 'D' , 'C'};
        char[] f = {'a' , 'f' , 'b' , 'l' , 'c', 'A' , 'D' , 'C'};
        System.out.println(Arrays.equals(e,f));
    }

输出结果：

true

4、填充：fill()

代码实操：

public class Calculator {
    public static void main(String[] args) {
        // 填充 fill (初始化)
        int[] g = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        // fill(long[] a, long val)：将指定的 long 值分配给指定的 longs 数组的每个元素。
        Arrays.fill(g, 2);
        System.out.println("Arrays.fill(g, 2)：");
        for (int i : g) {
            System.out.print(i);
        }
        // 换行
        System.out.println();

        // fill(long[] a, int fromIndex, int toIndex, long val)：将指定的 int 值分配给指定的 int 数组的指定范围的每个元素。
        int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Arrays.fill(a,0,5,3);
        System.out.println("Arrays.fill(a,0,5,3)：");
        for (int i : a){
            System.out.print(i);
        }
    }
}

输出结果：

Arrays.fill(g, 2)：
222222222
Arrays.fill(a,0,5,3)：
333336789

5、转列表：asList()

代码实操：

public class Calculator {
    public static void main(String[] args) {
//        @SafeVarargs
//        public static <T> List<T> asList(T... a)返回由指定数组支持的固定大小的列表。 （将返回的列表更改为“写入数组”。）该方法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()相结合 。 返回的列表是可序列化的，并实现RandomAccess 。
//        此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表：
        List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
        System.out.println(stooges);    
    }
}

输出结果：

[Larry, Moe, Curly]

6、转字符串：toString()

代码实操：

public class Calculator {
    public static void main(String[] args) {
        char[] a = {'a','b','c'};
        System.out.println(Arrays.toString(a));
    }
}

输出结果：

[a, b, c]

7、复制：copyOf()

代码实操：

public class Calculator {
    public static void main(String[] args) {
        // copyOf(boolean[] original, int newLength), original - 要复制的数组 ，newLength - 要返回的副本的长度
        int[] a = {1, 2, 2, 3, 4, 5, 7, 8};
        int[] b = Arrays.copyOf(a, 5);
        System.out.println("Arrays.copyOf(a, 5)：" +Arrays.toString(b));
        System.out.println();

        // copyOfRange：将指定数组的指定范围复制到新数组中。
        int[] c = Arrays.copyOfRange(a, 4, 6);
        System.out.println(Arrays.toString(a));
        System.out.print("Arrays.copyOfRange(a, 4, 6)：");
        System.out.println(Arrays.toString(c));
    }
}

输出结果：

Arrays.copyOf(a, 5)：[1, 2, 2, 3, 4]

[1, 2, 2, 3, 4, 5, 7, 8]
Arrays.copyOfRange(a, 4, 6)：[4, 5]