数组的定义与方法

数组基本用法

定义

数组是一组元素的线性集合。
在 Java 中, 数组中包含的变量必须是 相同类型。
数组是一种引用类型。

创建数组

基本的语法：

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 }

代码：

int[] arr = new int[]{1, 2, 3};
int[] arr = {1, 2, 3};

注意: 静态初始化的时候, 数组元素个数和初始化数据的格式是一致的。

数组使用方法

举个例子：
获取数组的长度和访问数组的元素
注意:数组的下标从0开始
范围是 [0,length-1]

int[] arr = {1, 2, 3};
// 获取数组长度
System.out.println("length: " + arr.length); // 执行结果: 3
// 访问数组中的元素
System.out.println(arr[1]); // 执行结果: 2
System.out.println(arr[0]); // 执行结果: 1
//赋值
arr[2] = 100;
System.out.println(arr[2]); // 执行结果: 100

数组在方法中的使用

例如：方法打印数组：
for-each是for循环的另一种使用方法，更方便完成对数组的遍历。

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    printArray(arr);
}
public static void printArray(int[] a) {
    for (int x : a) {
        System.out.println(x);
   }
}

注意：形参的改变并不会影响实参的值

参数传参组类型

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}
// 执行结果
a[0] = 10
arr[0] = 10

在这个方法中, 在方法内部修改数组内容, 方法外部也发生改变.
此时数组名 arr 是一个 “引用” . 当传参的时候, 是按照引用传参。

Arrays中的方法

Arrays.copyOfRange()方法
将一个原始的数组，从下标from开始复制，复制到上标to，不包括to，生成一个新的数组；
举例：
超过原数组用0代替.

private static void testCopyRange() {
        long[] a = { 1, 2, 3, 4, 5 };
        //from  to
        //long[] copy = Arrays.copyOfRange(a, 3, 4); 4
        long[] copy = Arrays.copyOfRange(a, 3, 10);//4,5,0,0,0,0,0
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(copy));
    }

Arrays的copyOf()方法
传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。
copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留数组默认值0

private static void testCopy() {
        long[] a = { 1, 2, 3, 4, 5 };
        System.out.println(Arrays.toString(a));

        //long[] copy = Arrays.copyOf(a, 3);// 新数组长度小于源长度， 1，2，3
        //long[] copy = Arrays.copyOf(a, 5);// 新数组长度等于源长度 ，1，2，3，4，5
        long[] copy = Arrays.copyOf(a, 10);// 新数组长度大于源长度

        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(copy));

Arrays.fill（）方法
将数组中的内容替换
from 到to 包含from的下标，但不包含to的下标。，也可以全部替换。
举例：

String[] a = new String[6];
Arrays.fill(a, "Hello");
Arrays.fill(a, 3, 5,"World");
结果是 a[] = {Hello,Hello,Hello,World,World,Hello};

Arrays.sort() 方法
1.Arrays.sort(int[] a)；
是对一个数组的所有元素进行排序，并且是按从小到大的顺序。
举例：

private static void testSort() {
        long[] a = { 9, 5, 2, 7, 1, 6, 8, 3, 0, 4 };
        System.out.println(Arrays.toString(a));
        Arrays.sort(a); // In-place Sort 原地排序
        System.out.println(Arrays.toString(a));
    }

2.Arrays.sort(int[] a，from,to)；
是对数组中from下标到to下标中的元素排序，不包括to.

private static void testSort() {
        long[] a = { 9, 5, 2, 7, 1, 6, 8, 3, 0, 4 };
        System.out.println(Arrays.toString(a));
        Arrays.sort(a,1,5); // 
        System.out.println(Arrays.toString(a));
    }

Arrays的equals()方法
比较两个数组是否相等。
举例：

private static void testEquals() {
        long[] a = { 1, 2, 3, 4 };
        long[] b = { 1, 2, 3, 0 };

        b[3] = 4;
        System.out.println(Arrays.equals(a, b));
    }

Arrays类的binarySearch()方法
可以使用二分搜索法来搜索指定的数组，以获得指定对象。
如果key在数组中，则返回搜索值的索引；否则返回-1
举例：

 private static void testBinarySearch() {
        long[] a = { 9, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9 };
        System.out.println(Arrays.binarySearch(a, 5));  // 由于数组无序，返回什么都是合理的

//        System.out.println(Arrays.binarySearch(a, 3));  // 3
//        System.out.println(Arrays.binarySearch(a, 4));  // 4 OR 5
//        System.out.println(Arrays.binarySearch(a, -1)); // -1
//        System.out.println(Arrays.binarySearch(a, 10)); // -12
    }

注意：
[1] 搜索值不是数组元素，且在数组范围内，从1开始计数，得“ - 插入点索引值”；
[2] 搜索值是数组元素，从0开始计数，得搜索值的索引值；
[3] 搜索值不是数组元素，且大于数组内元素，索引值为 – (length + 1);
[4] 搜索值不是数组元素，且小于数组内元素，索引值为 – 1。
Arrays.toString方法
这是打印数组的方法

 private static void toString() {
        long[] a = { 9, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9 };
        System.out.println(Arrays.toString(a));//9,1,2,3,4,4,5,6,7,8,9

Arrays.deepToString方法
这里针对的是打印数组中的数组的方法
例如：long[] a = {{ 9, 1, 2, 3,} {4, 4, 5, 6, 7, 8, 9} };

private static void deepToString() {
        long[] a = { {9, 1, 2, 3} {4, 4, 5, 6, 7, 8, 9} };
        System.out.println(Arrays.toString(a));//[[9,1,2,3],[4,4,5,6,7,8,9]]