【Java开发指南 | 第十六篇】Java数组及Arrays类

读者可订阅专栏：Java开发指南 |【CSDN@秋说】

数组

Java中的数组是一种用来存储固定大小的相同类型元素的数据结构。

数组特点

数组具有以下特点：

1、固定大小: 一旦数组被创建，其大小就不能被改变。

2、相同类型元素: 数组中的所有元素必须是相同的数据类型，可以是基本数据类型（如int、double等）或者是引用数据类型（如对象）。

3、连续内存空间: 数组中的元素在内存中是连续存储的。

4、零索引: 数组的元素是通过索引访问的。数组的索引从零开始，即第一个元素的索引是0，第二个元素的索引是1，以此类推到 arrayRefVar.length-1。

创建数组

1、

dataType[] arrayRefVar;   //声明数组的类型和名称

//char[] myArray;

不能按这种方法创建声明数组：char[10] arr;

2、

dataType arrayRefVar[];
//声明数组的类型和名称

//可以指定其大小
//int[] myArray = new int[5];

public class ice {
    public static void main(String[] args) {
       int arr[] = new int[5];

       for(int i=0;i<arr.length;i++)
        {
            System.out.println(i*2);
        }

    }
}

3、

dataType[] arrayRefVar = {value0, value1, ..., valuek};

//char[] myArrar={'a','b','c','d'}

例如：

public class ice {
    public static void main(String[] args) {
       int[] arr = {'1','2','3','a'};
    }
}

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。

public class ice {
    public static void main(String[] args) {
       int arr[] = new int[5];
        
        for(int i=0;i<arr.length;i++)
        {
            arr[i]=i*2;
        }//循环进行赋值

       for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }//循环进行打印

    }
}

多维数组

type[][] typeName = new type[typeLength1][typeLength2];

创建一个两行三列的二维数组 a ：

int[][] a = new int[2][3];

访问二维数组中第二行第一列的元素：

int t=a[1][0];

Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

排序（Sorting）：

• sort(T[] a): 对指定数组进行排序，使用默认的比较器。

import java.util.Arrays;

public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        Arrays.sort(arr);
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }
    }
}

• sort(T[] a, Comparator<? super T> c): 对指定数组根据指定比较器进行排序。
• parallelSort(T[] a): 对指定数组进行并行排序，使用默认的比较器。
• parallelSort(T[] a, Comparator<? super T> c): 对指定数组进行并行排序，使用指定的比较器。

搜索（Searching）：

• binarySearch(T[] a, T key): 在指定数组中搜索指定的元素，返回元素的索引。数组必须是有序的。

import java.util.Arrays;

public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        Arrays.sort(arr);
        int t=Arrays.binarySearch(arr,543);
        System.out.println(t);
    }
}

• binarySearch(T[] a, int fromIndex, int toIndex, T key): 在指定范围内的数组中搜索指定的元素，返回元素的索引。数组必须是有序的。

比较（Comparing）：

• equals(T[] a, T[] a2): 比较两个数组是否相等。
• deepEquals(Object[] a1, Object[] a2): 深度比较两个数组是否相等。

填充（Filling）：

• fill(T[] a, T val): 将指定数组的所有元素替换为指定值。
• fill(T[] a, int fromIndex, int toIndex, T val): 将指定范围内的数组元素替换为指定值。

转换为列表（Converting to List）：

• asList(T... a): 将指定数组转换为 List。

import java.util.Arrays;
import java.util.List;

public class ice {
    public static void main(String[] args) {
        Integer[] arr = {1,12,543,235,2,13,122,43}; // 使用 Integer 类型的数组
        List<Integer> a = Arrays.asList(arr);
        System.out.println(a);
    }
}

注意：列表不能直接复制给数组，因为基本数据类型不能作为泛型的参数。

/*无法输出正确列表*/
import java.util.Arrays;
import java.util.List;

public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        List a = Arrays.asList(arr);
        System.out.println(a);
    }
}

数组的输出（Array Output）：

• toString(T[] a): 返回数组的字符串表示形式。

import java.util.Arrays;

public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        String a = Arrays.toString(arr);
        System.out.println(a);
    }
}

数组的复制（Array Copying）：

• copyOf(T[] original, int newLength): 将指定数组的前几个元素复制到一个新数组中，新数组的长度为指定长度。

import java.util.Arrays;
import java.util.List;

public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        int[] brr=Arrays.copyOf(arr,3);
        System.out.println(Arrays.toString(brr));
    }
}

• copyOfRange(T[] original, int from, int to): 将指定数组的指定范围的元素复制到一个新数组中。

import java.util.Arrays;
import java.util.List;

public class ice {
    public static void main(String[] args) {
        int[] arr = {1,12,543,235,2,13,122,43};
        int[] brr=Arrays.copyOfRange(arr,3,6);
        System.out.println(Arrays.toString(brr));
    }
}

数组的填充（Array Padding）：

• copyOfRange(T[] original, int from, int to): 将指定数组的指定范围的元素复制到一个新数组中，并使用指定值填充不足的部分。