Java中的数组

数组是指一组数据的集合，数组中的每个数据被称为元素。

在数组中可以存放任意类型的元素，但是同一个数组例存放的元素类型必须一致。

一维数组

1.数组的定义

在Java中，数组有三种定义方式，其语法如下：

数组类型[] 数组名=new 数组类型[数组长度];
数组类型[] 数组名=new 数组类型[]{数组元素0,数组元素1,...};
数组类型[] 数组名={数组元素0,数组元素1,...};

注意：从上述数组定义的方式中，我们可以看出第二种和第三种在创建数组的时候可以设置默认的初始值，但是两种初始化的格式是独立分开的，严格要求不能混合使用

int[] ages = new int[3]{1,10,50}        //报错

2.数组的长度

在Java中提供了一个属性length，用来获取数组的长度。

• 每个数组的索引都有一个范围，即0~length-1，在访问数组的元素时，索引不能超出这个范围。

public class test {
    public static void main(String[] args) {
        int[] num=new int[10];
        System.out.println("num数组的长度："+num.length);
    }
}

3.Java不同数据类型元素的默认值

对于上述数组创建三种方式中的第一种方式，当数组被创建成功后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认的初始化值也是不一样的，下面是不同数据类型元素的初始值表。

什么是引用数据类型?

• 引用数据类型为java两大数据类型之一，引用数据型在被床架时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。

• 引用数据类型包括：类、接口类型、数组类型、枚举类型、注解类型，字符串型。java另一大数据类型为基本数据类型，其包括包括数值型，字符型和布尔型。

• 引用类型 由类型的实际值引用（类似于指针）表示的数据类型。如果为某个变量分配一个引用类型，则该变量将引用（或“指向”）原始值。不创建任何副本。引用类型包括类、接口、委托和装箱值类型。

public class test {

    public static void main(String[] args) {
        //int型
        int[] num=new int[10];
        System.out.println("默认初始值："+num[0]);

        //double型
        double[] m=new double[5];
        System.out.println("默认初始值："+m[0]);

        //char型
        char[] n=new char[5];
        System.out.println("默认初始值："+n[0]);

        //布尔型
        boolean[] a=new boolean[5];
        System.out.println("默认初始值："+a[0]);

        //引用数据类型
        String[] b=new String[5];
        System.out.println("默认初始值："+b[0]);

    }
}

4.数组初始化值

(1) 静态初始化

在声明数组的同时，为数组元素赋初值。

int[] numbers = {1, 2, 3, 4, 5};

(2) 动态初始化

在声明数组的同时，指定数组长度，然后通过循环或其他方法为每个数组元素赋值。

int[] numbers = new int[5];
for (int i = 0; i < numbers.length; i++) {
	numbers[i] = i + 1;
}

(3) 默认初始化

Java会为数组分配默认的初值，具体初值取决于数组的类型。例如，int类型的数组默认初值为0，boolean类型的数组默认初值为false。

int[] numbers = new int[5]; // 默认初值为0

boolean[] flags = new boolean[3]; // 默认初值为false

(4) 匿名数组初始化

创建一个没有名字的数组对象，只是用来初始化另一个数组。

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

(5) 使用Arrays工具类

void fill(int[] a, int val)：将指定值填充到数组之中

使用Arrays.fill()方法设置默认值

除了使用循环遍历的方式，Java还提供了一个方便的方法Arrays.fill()，该方法可以用来为数组的所有元素设置相同的值。

import java.util.Arrays;

public class test {

    public static void main(String[] args) {
        int[] num=new int[10];
        System.out.println("使用工具类设置默认值前："+num[0]);
        Arrays.fill(num,8);
        System.out.println("使用工具类设置默认值后："+num[0]);
    }
}

注意： 一旦数组被初始化，它的长度就不能改变。如果需要改变数组的长度，必须创建一个新的数组，并将原始数组的元素复制到新数组中。

多为数组

以二维数组为例：

1.定义

//指定二维数组的长度和每个数组的元素个数
int[][] num=new int[3][4];

//指定二维数组的长度，不确定每个数组的元素个数
int[][] ints=new int[3][];

//使用大括号，对二维数组初始化赋值
int[][] arr={{1,2},{1,2,3,4},{7,8,9}};

2.数组的长度

int[][] arr=new int[3][4];
arr.length   //代表数组行的长度 
arr[i].length   //代表数组列的长度 

3.二维数组的初始化及遍历

（1）对于第一种二维数组的创建方式

//1.可以使用循环直接赋予初值
public class Main {
    public static void main(String[] args) {
        //指定二维数组的长度和每个数组的元素个数
        int[][] num=new int[3][4];
        for (int i=0;i<num.length;i++){
            for (int j=0;j<num[i].length;j++){
                num[i][j]=10;
            }
        }

        System.out.println("赋予初值后：");
        for (int i=0;i<num.length;i++){
            for (int j=0;j<num[i].length;j++){
                System.out.print(num[i][j]+" ");
            }
            System.out.println();
        }
    }
}

//2.使用工具类Array.fill()方法

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int rowCount = 3;
        int colCount = 4;

        int[][] arr = new int[rowCount][colCount];
        int[] row = new int[colCount];
        Arrays.fill(row, 0);
        for (int i = 0; i < rowCount; i++) {
            arr[i] = row;
        }

        for (int i = 0; i < rowCount; i++) {
            for (int j = 0; j < colCount; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

对于使用工具类赋予初值，和一维数组有所不同。如果按照一维数组初始化值，就会直接报错。

public class Main {
    public static void main(String[] args) {
        //指定二维数组的长度和每个数组的元素个数
        int[][] num=new int[3][4];
        Arrays.fill(num,10);
        for (int i=0;i<num.length;i++){
            for (int j=0;j<num[i].length;j++){
                System.out.print(num[i][j]+" ");
            }
            System.out.println();
        }
    }
}

（2）对于第二种二维数组的创建方式

public class Main {
    public static void main(String[] args) {
        //指定二维数组的长度，不确定每个数组的元素个数
        int[][] arr=new int[3][];
        
        arr[0]=new int[]{11,12};
        arr[1]=new int[]{21,22,23};
        arr[2]=new int[]{33,32,30,5,31};

        for (int i=0;i<arr.length;i++){
            for (int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

（3）对于第三种二位数组的创建方式

public class test {

    public static void main(String[] args) {

        //使用大括号，对二维数组初始化赋值
        int[][] arr={{1,2},{1,2,3,4},{7,8,9}};

        for (int i=0;i<arr.length;i++){
            for (int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

对于上述的遍历，大括号中不是最多的一个中有几个元素，就代表整个数组中的列全部有就是几个元素。。

public class test {
    public static void main(String[] args) {
        //使用大括号，对二维数组初始化赋值
        int[][] arr={{1,2},{1,2,3,4},{7,8,9}};

        for (int i=0;i<3;i++){
            for (int j=0;j<4;j++){
                System.out.println(arr[i][j]);
            }
        }
    }
}