Java数组

一、数组作为参数

1.数组的引用指向一个新的对象

import java.util.Arrays;
public class ArrayParameter {
    public static void main(String[] args) {
        int[] array = {0, 1};
        newArray(array);
        System.out.println(Arrays.toString(array));
    }

    public static void newArray(int[] array) {
        array = new int[] {1, 2, 3, 4, 5};
    }
}

上述代码的结果为[0, 1]。
由于形参中的引用变量array指向一个新的对象，导致函数中的array存储的地址与主函数中的实参引用变量array的值不同。所以无法通过这个方法改变实参array的值。

2.数组的引用指向数组的一个变量。

import java.util.Arrays;
public class ArrayParameter {
    public static void main(String[] args) {
        int[] array = {0, 1};
        newArray(array);
        System.out.println(Arrays.toString(array));
    }

    public static void newArray(int[] array) {
        array[0] = 5;
        array = new int[] {1, 2, 3, 4, 5};
    }
}

这样结果会变为[5, 1]
因为形参array所存储的地址是与实参array存储的地址一样的，所以两个参数指向了同一个对象，所以可以直接对指向的对象的值进行修改。

import java.util.Arrays;
public class ArrayParameter {
    public static void main(String[] args) {
        int[] array = {0, 1};
        newArray(array);
        System.out.println(Arrays.toString(array));
        int[] array2 = {1, 2, 3, 4};
        array = array2;
        array2[2] = 51;
        System.out.println(Arrays.toString(array));
    }

    public static void newArray(int[] array) {
        array[0] = 5;
        array = new int[] {1, 2, 3, 4, 5};
    }
}

其实上述代码的主函数的后面片段与方法的实现是一样的，因为array和array2存储的地址变得一样了所以array2的值被改变，array所指向的值也被变化。

3.数组作为返回值

数组在java中是可以作为返回值的哦，尽管在C中是不可以作为返回值的。

    public static int[] multiplyTwo(int[] array) {
   		int i = 0;
        int[] result = new int[array.length];
        for (i = 0; i < array.length; i++) {
            result[i] = 2*array[i];
        }
        return result;
    }

二、数组的初始化与赋值方法

int[] array = {0, 1};
int[] array = new int[] {1, 2, 3, 4, 5};

注意，这里的第二种赋值方法中的new int[]中的[ ] 中不能存放数字。并且上面上述代码中的任意一个[ ]中都不能存放数字。

三、数组的打印

public class ArrayPrint {
	public static void main(String[] args) {
		int[] array = {0, 1, 2, 3};
		print(array);
	}

	public static void print(int[] array) {
		for(int x : array) {
			System.out.print(x + " ");
		}
	}
}

for each循环打印代码，用于不需要获取数组下标的情况。

 import java.util.Arrays;
 System.out.println(Arrays.toString(array));

这种打印运用了工具类Array，需要在使用前声明。这种将打印出来[0, 1, 2, 3]。

三、工具类Arrays中的方法使用

注意哦，使用Arrays需要在开头声明 import java.util.Arrays;

1. Arrays.toString

	import java.util.Arrays;
 	System.out.println(Arrays.toString(array));

toString方法可以将数组以字符串的形式返回。形如：[1, 2, 3, 4]

2. Arrays.binarySearch

		int[] array = {1, 5, 7, 9};
		int a = 0;
		a = Arrays.binarySearch(array, 0);
		System.out.println("The number " + 0 + " is in index " + a);

只可以用二分法寻找有序数列的特定元素的下标。

3. Arrays.sort

		int[] array = {1, 2, 3, 55, 3, 3, 5, 2, 1};
		Arrays.sort(array);
		String arr = Arrays.toString(array);
		System.out.println(arr);

Arrays.sort可以将数组从小到大排序。

4.Arrays.fill

Arrays.fill其实是具有重载的方法，具有两种参数类型

两个参数与四个参数

		int[] array = new int[7];
		Arrays.fill(array, 6);
		System.out.println(Arrays.toString(array));
		Arrays.fill(array, 3, 5, 8);
		System.out.println(Arrays.toString(array));

输出结果

[6, 6, 6, 6, 6, 6, 6]
[6, 6, 6, 8, 8, 6, 6]

注意拥有四个参数的fill方法的第二个与第三个参数是左闭右开区间。

import java.util.Arrays;
public class FillTwo {
	public static void main(String[] args) {
		int[] array = new int[8];
		System.out.println(Arrays.toString(array));
		Arrays.fill(array, 1, 4, 6);
		System.out.println(Arrays.toString(array));
	}
}

[0, 0, 0, 0, 0, 0, 0, 0]
[0, 6, 6, 6, 0, 0, 0, 0]
这样数组会被先赋值0。

5.克隆数组（包括与C语言之间的区别）

import java.util.Arrays;
public class CopyOne {
	public static void main(String[] args) {
		int[] array = {0, 1, 2, 3};
		int[] array2 = array;
		System.out.println(Arrays.toString(array2));
	}
}

这样子克隆出来的数组会互相影响，因为存储的地址一样，只要一个数组的值改变两个数组对应的值都会改变。
而C语言中数组的复制就不能像上面那样操作。

#include <stdio.h>
int main() {
	int array[] = { 0, 1, 2, 3, 4 };
	int array2[5] = array;
	int i = 0;
	for (i = 0; i < sizeof(array2) / sizeof(int); i++) {
		printf("%d ", array2[i]);
	}
	return 0;
}

上面的代码会报错。

import java.util.Arrays;
public class CopyDirectly {
	public static void main(String[] args) {
		double[] array = {0, 1.1, 2.2, 3.3, 4.4};
		double[] array2 = Arrays.copyOf(array, array.length * 2);
		double[] array3 = Arrays.copyOf(array, array.length - 3); 
		double[] array4 = Arrays.copyOfRange(array, 1, 2);
		System.out.println(Arrays.toString(array2));
		System.out.println(Arrays.toString(array3));
		System.out.println(Arrays.toString(array4));
	}
}

[0.0, 1.1, 2.2, 3.3, 4.4, 0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 1.1]
[1.1]
上面是代码的运行结果。

public static int[] copyArray(int[] array) {
        int[] copy = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        return copy;
    }

当然，你也可以通过上面的方式遍历数组进行数组的拷贝。

import java.util.Arrays;
public class CopyQuickly {
	public static void main(String[] args) {
		double[] array = {1.2, 2.2, 2.3, 3.3};
		double[] copy = new double[array.length];
		System.arraycopy(array, 0, copy, 0, array.length);
		System.out.println(Arrays.toString(copy));
	}
}

这样的拷贝数组的方式会更快一点因为System.arraycopy是native修饰的方法，由C或C++实现。