Java数组的定义与常用使用方法

一.什么是数组

二.数组的创建及初始化

数组的创建

数组的初始化

动态初始化：

静态初始化：

【注意】

三.数组的使用

数组中元素访问

遍历数组

四.数组作为方法的参数

参数传基本数据类型

参数传数组类型(引用数据类型)

作为方法的返回值

五.java.util.Arrays 常用方法

数组转字符串

数组拷贝

求数组中元素的平均值

查找数组中指定元素(顺序查找)

查找数组中指定元素(二分查找)

数组排序

六.二维数组

一.什么是数组

数组：可以看成是 相同类型元素的一个集合 。在内存中是一段连续的空间。比如现实中的车库：

数组有以下特征：

数组中存放的元素其类型相同
数组的空间是连在一起的
每个空间有自己的编号，其实位置的编号为0，即数组的下标

二.数组的创建及初始化

数组的创建

T[ ] 数组名 = new T[N];

在上述表达式中：

T：表示数组中存放元素的类型
T[ ]：表示数组的类型
N：表示数组的长度

int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组

数组的初始化

数组的初始化可以分为 动态初始化 以及 静态初始化

动态初始化：

在创建数组时，直接指定数组中元素的个数
int[] array = new int[10];

静态初始化：

在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

【注意】

静态初始化虽然没有指定数组的长度，编译器在编译时会根据 { } 中元素个数来确定数组的长度
静态初始化时, { } 中数据类型必须与 [ ] 前数据类型一致
静态初始化可以简写，省去后面的new T[ ]

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};

数组也可以按照如下C语言个数创建，不推荐，该种定义方式不太友好，容易造成数组的类型就是int的误解，[]如果在类型之后，就表示数组类型，因此int[]结合在一块写意思更清晰

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

静态和动态初始化也可以分为两步，但是省略格式不可以

int[] array1;
array1 = new int[10];

int[] array2;
array2 = new int[]{10, 20, 30};

// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};

如果没有对数组进行初始化，数组中元素有其默认值，如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，比如：

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0f
double	0.0
char	/u0000
boolean	false
引用	null

三.数组的使用

数组中元素访问

数组在内存中是一段连续的空间，空间的编号都是从 0 开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);

// 也可以通过[]对数组中的元素进行修改
array[0] = 100;
System.out.println(array[0])

数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素，下标从0 开始，介于 [0, N ）之间不包含 N ， N为元素个数，不能越界，否则会报出下标越界异常

int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组中只有3个元素，下标一次为：0 1 2，array[3]下标越界

// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100

遍历数组

使用循环来进行打印

int[]array = new int[]{10, 20, 30, 40, 50};
    for(int i = 0; i < 5; i++) {
    System.out.println(array[i]);
}

在数组中可以通过数组对象 .length 来获取数组的长度

int[]array = new int[]{10, 20, 30, 40, 50};
    for(int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

也可以使用 for-each 遍历数组， for-each 是 for 循环的另外一种使用方式 . 能够更方便的完成对数组的遍历 . 可以避免循环条件和更新语句写错

int[] array = {1, 2, 3};
    for (int x : array) {
    System.out.println(x);
}

四.数组作为方法的参数

参数传基本数据类型

public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
}

public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
}

执行结果：

x = 10

num = 0

发现在func方法中修改形参 x 的值, 不影响实参的 num 值

参数传数组类型(引用数据类型)

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

发现在func 方法内部修改数组的内容 , 方法外部的数组内容也发生改变 .

这是因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的

所谓的 " 引用 " 本质上只是存了一个地址 . Java 将数组设定成引用类型 , 这样的话后续进行数组参数传参 , 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝 ( 数组可能比较长 , 那么拷贝开销就会很大 )

作为方法的返回值

我们可以用数组做返回值求得斐波那契数列的前N项

public class TestArray {
    public static int[] fib(int n){
        if(n <= 0){
            return null;
        }
        int[] array = new int[n];
        array[0] = array[1] = 1;
        for(int i = 2; i < n; ++i){
            array[i] = array[i-1] + array[i-2];
        }
        return array;
    }
    public static void main(String[] args) {
        int[] array = fib(10);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

五.java.util.Arrays 常用方法

数组转字符串

Java 中提供了 java.util.Arrays 包 , 其中包含了一些操作数组的常用方法，如 toString 就可以将我们的数组转化为字符串，方便了我们输出

import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);

数组拷贝

使用 Arrays 中 copyOf 方法完成数组的拷贝，copyOf 方法在进行数组拷贝时，创建了一个新的数组，arr 和 newArr 引用的不是同一个数组

    public static void func() {
        // newArr和arr引用的是同一个数组
        // 因此newArr修改空间中内容之后，arr也可以看到修改的结果
        int[] arr = {1,2,3,4,5,6};
        int[] newArr = arr;
        newArr[0] = 10;
        System.out.println("newArr: " + Arrays.toString(arr));

        // 使用Arrays中copyOf方法完成数组的拷贝：
        // copyOf方法在进行数组拷贝时，创建了一个新的数组
        // arr和newArr引用的不是同一个数组
        arr[0] = 1;
        newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("newArr: " + Arrays.toString(newArr));

        // 因为arr修改其引用数组中内容时，对newArr没有任何影响
        arr[0] = 10;
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr: " + Arrays.toString(newArr));

        // 拷贝某个范围.
        int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
        System.out.println("newArr2: " + Arrays.toString(newArr2));
    }

如图：

求数组中元素的平均值

我们可以使用 avg 将数组传入，就可以得到平均值

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(avg(arr));
    }
    public static double avg(int[] arr) {
        int sum = 0;
        for (int x : arr) {
            sum += x;
        }
        return (double)sum / (double)arr.length;
    }

查找数组中指定元素(顺序查找)

使用 find，传入目标数组和要查询的值

public static void main(String[] args) {
    int[] arr = {1,2,3,10,5,6};
    System.out.println(find(arr, 10));
}
public static int find(int[] arr, int data) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == data) {
            return i;
        }
    }
    return -1; // 表示没有找到
}

查找数组中指定元素(二分查找)

针对 有序数组 , 可以使用更高效的二分查找，以升序数组为例 , 二分查找的思路是先取中间位置的元素 , 然后使用待查找元素与数组中间元素进行比较：

如果相等，即找到了返回该元素在数组中的下标
如果小于，以类似方式到数组左半侧查找
如果大于，以类似方式到数组右半侧查找

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};
    System.out.println(binarySearch(arr, 6));
}

数组排序

Java 中内置了高效的排序算法

public static void main(String[] args) {
    int[] arr = {9, 5, 2, 7};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

六.二维数组

二维数组本质上也就是一维数组 , 只不过每个元素又是一个一维数组

基本语法

数据类型 [][] 数组名称 = new 数据类型 [ 行数 ][ 列数 ] { 初始化数据 };

int[][] arr = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
for(int row=0;row<arr.length;row++) {
    for(int col=0;col<arr[row].length;col++) {
        System.out.printf("%d\t",arr[row][col]);
    }
    System.out.println("");
}

二维数组的用法和一维数组并没有明显差别，唯一需要注意的一点是，在省略数组大小的时候，我们不能省略行数，这与c语言是截然相反的

正确格式：

int[][] arr = new int [3][];

错误格式：

int[][] arr = new int [][3];
int[][] arr = new int [][];