首页 > 编程笔记 > Java笔记 阅读：4

Java Collections和Arrays集合工具类的用法（附带实例）

Java 集合框架提供了两个非常实用的辅助工具类：Collections 和 Arrays。

Java Collections工具类

Collections 工具类位于 java.util 包中，提供了一些对 Collection 集合常用的静态方法，如排序、查找、复制和修改等操作。

1) 添加和排序操作

Collections 工具类提供了一系列方法用于对 List 集合进行添加和排序操作，如下表所示。

表 1 Collections工具类常用的添加和排序方法
方法声明 功能描述
static <T> boolean addAll(Collection<? super T> c, T... elements) 将所有的指定元素添加到指定集合 c 中
static void reverse(List<?> list) 反转指定 List 集合中元素的顺序
static void shuffle(List<?> list) 对 List 集合中的元素进行随机排序
static <T extends Comparable<? super T>> void sort(List<T> list) 根据元素的自然顺序对指定的 List 集合中的元素进行排序
static void swap(List<?> list, int i, int j) 交换指定 List 集合中角标 i 处和 j 处的元素

【实例】Collections工具类常用的添加和排序方法的应用。 
import java.util.ArrayList;
import java.util.Collections;
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> mylist = new ArrayList<>();
        Collections.addAll(mylist,"C","D","A","E","B");
        System.out.println("排序之前："+mylist);
        Collections.reverse(mylist);
        System.out.println("反转之后："+mylist);
        Collections.sort(mylist);
        System.out.println("按自然顺序排序后："+mylist);
        Collections.shuffle(mylist);
        System.out.println("按随机顺序排序后："+mylist);
        // 交换列表的首尾元素
        Collections.swap(mylist,0,mylist.size()-1);
        System.out.println("列表的首尾元素交换完后："+mylist);
    }
}
运行结果为：

排序之前：[C, D, A, E, B]
反转之后：[B, E, A, D, C]
按自然顺序排序后：[A, B, C, D, E]
按随机顺序排序后：[B, C, A, E, D]
列表的首尾元素交换完后：[D, C, A, E, B]

2) 查找和替换操作

Collections 工具类提供了一些用于查找和替换集合中元素的常用方法，如下表所示。

表 2 Collections工具类常用的查找和替换方法
方法声明 功能描述
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二分法搜索指定对象在 List 集合中的索引，查找的 List 集合中的元素必须是有序的
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 根据元素的自然顺序返回给定集合的最大元素
static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 根据元素的自然顺序返回给定集合的最小元素
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 使用一个新值 newVal 替换 List 集合中所有的旧值 oldVal

【实例】Collections 工具类常用的查找和替换方法的应用。 
import java.util.ArrayList;
import java.util.Collections;
public class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> mylist = new ArrayList<>();
        // 向 mylist 集合中添加元素
        Collections.addAll(mylist, 12, 25, -56, -15, 78, 6, 2, 4, 653, 123);
        System.out.println("集合中的元素：" + mylist);
        System.out.println("集合中最大的元素：" + Collections.max(mylist));
        System.out.println("集合中最小的元素：" + Collections.min(mylist));
        System.out.println("集合中的 “78” 替换成 “88” ");
        Collections.replaceAll(mylist, 78, 88);
        System.out.println("替换后的集合：" + mylist);
        // 在查找之前先对集合进行排序
        Collections.sort(mylist);
        System.out.println("排序后的集合：" + mylist);
        int pos = Collections.binarySearch(mylist, 88);
        System.out.println("元素 88 所在的角标为：" + pos);
    }
}
运行结果为：

集合中的元素：[12, 25, -56, -15, 78, 6, 2, 4, 653, 123]
集合中最大的元素：653
集合中最小的元素：-56
集合中的 “78” 替换成 “88”
替换后的集合：[12, 25, -56, -15, 88, 6, 2, 4, 653, 123]
排序后的集合：[-56, -15, 2, 4, 6, 12, 25, 88, 123, 653]
元素 88 所在的角标为：7

Java Arrays工具类

Arrays 工具类也位于 java.util 包中，提供了针对数组操作的各种静态方法，如排序、复制和查找等。Arrays工具类常用的静态方法如下表所示。

表 3 Arrays工具类常用的静态方法
方法声明 功能描述
static int binarySearch(Object[] a, Object key) 使用二分搜索法搜索指定的对象数组，以获得指定对象
static <T> int binarySearch(T[] a, T key, Comparator<? super T> c) 使用二分搜索法搜索指定的泛型数组，以获得指定对象，数组基于Comparator的逻辑排序
static <T> T[] copyOf(T[] original, int newLength) 复制指定的数组，如有必要需要截取或用null填充，以使副本具有指定的长度
static <T> T[] copyOfRange(T[] original, int from, int to) 将指定数组的指定范围复制到一个新数组中，包括下标from，不包括下标to
static void fill(Object[] a, Object val) 将指定的值填充到指定数组中的每个位置
static int hashCode(Object[] a) 基于指定数组的内容返回哈希码
static void sort(Object[] a) 根据元素的自然顺序对指定数组进行升序排序
static <T> void sort(T[] a, Comparator<? super T> c) 根据指定Comparator对指定数组进行排序
static String toString(Object[] a) 返回指定数组内容的字符串表示形式

【实例】Arrays工具类对对象数组操作方法的应用。 
import java.util.Arrays;
public class Demo {
    public static void main(String[] args) {
        // 创建一个Person对象数组
        int[] arr = {45, 12, 3, 5, 69, 78, 99, 457, 58, -25};
        System.out.println("数组排序之前：");
        for (int i : arr) {
            System.out.printf("%-5d", i);
        }
        // 排序：调用 sort() 方法
        Arrays.sort(arr);
        System.out.println("\n数组排序之后：");
        for (int i : arr) {
            System.out.printf("%-5d", i);
        }
        // 查找指定元素：查找元素 78
        int index = Arrays.binarySearch(arr, 78);
        System.out.println("\n元素 78 的索引为：" + index);
        // 复制元素：复制索引为 1～6 的数组元素，包括 1 号，不包括 6 号
        int[] copied = Arrays.copyOfRange(arr, 1, 6);
        System.out.println("复制的数组为（[1,6)）：");
        for (int i : copied) {
            System.out.printf("%-5d", i);
        }
        System.out.println("\n所有元素替换为 1 之后的数组：");
        // 替换元素：调用 fill() 方法，将所有元素替换为 1
        Arrays.fill(arr, 1);
        for (int i : arr) {
            System.out.printf("%-5d", i);
        }
    }
}
运行结果为：

数组排序之前：
45   12   3    5    69   78   99   457  58   -25 
数组排序之后：
-25  3    5    12   45   58   69   78   99   457 
元素 78 的索引为：7
复制的数组为（[1,6)）：
3    5    12   45   58  
所有元素替换为 1 之后的数组：
1    1    1    1    1    1    1    1    1    1   

相关文章