数组的创建与初始化

在C语言中我们也提到了数组的概念，什么是数组呢？数组就是相同类型元素的一个集合。那么我们如何在Java中创建一个数组呢？跟C语言的语法一样嘛？其实是不一样的。
T[] 数组名 = new T[N];

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

例如：

 public static void main(String[] args) {
        int[] array = new int[10];// 创建了一个可以储存10个整形的数组
        double[] array2 = new double[10];// 创建了一个可以储存10个double类型的数组
        boolean[] array3 = new boolean[10];// 创建了一个可以储存10个布尔类型的数组
    }

数组的初始化

静态初始化

数组在静态初始化时不指定数据元素的个数，而直接将具体的数据内容进行指定
语法格式： T[] 数组名称 = {data1, data2, data3, ..., datan};或者 T[] 数组名称 = new T[]{data1, data2, data3, ..., datan};

动态初始化

数组在动态初始化时，直接指定数组中的元素个数
语法格式：T[] 数组名称 = new T[10]

   public static void main(String[] args) {
        //静态初始化
        int[] array = new int[]{1,2,3,4};
        double[] array2 = {1.4,2.9,10.4};
        //动态初始化
        boolean[] array3 = new boolean[4];
    }

注意事项：

1、静态初始化时我们没有给数组的长度，但编译器在编译时会根据我们给的数据来确定数组长度。
2、初始化时保持前后的数据类型一致
3、如果我们没有对数组进行初始化，数组中元素有对应默认值。

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

数组的存储

我们了解了Java中数组是如何创建的之后，数组是存储在哪里的呢？在Java中new创建的对象都是在堆上保存的，所以我们数组中的数据也保存在堆上的。

 public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4};
    }

我们这样去创建一个数组因为arr这个数组变量是在main方法内创建的，是局部变量，所以他的内存空间在栈上开辟，而这个数组的内容是我们new出来的对象，所以数组的内容存储在堆上。我们用一个图来帮助大家理解

我们从图中可以看出，arr本身并没有存储数组的信息，他存储的是对象在堆上的起始地址。在Java中称这样的变量为引用变量。

null

既然有地址的出现那一定有null，null在Java中表示”空引用“，也就是一个不指向对象的引用。null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置。 因此不能对这个内存进行任何读写操作.，一旦尝试读写, 就会抛出 NullPointerException。

打印数组的三种方式

循环遍历打印

在C语言我们都知道了，使用数组就需要去访问数组，如何访问数组呢？我们通过数组的下标去访问数组，数组的下标从0开始，依次递增，通过下标可以访问其任意位置的元素。我们就可以通过循环遍历打印数组：

 public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }

foreach打印

在Java中还支持这样的语法：

 public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7};
        for (int ret: arr) {
            System.out.print(ret);
        }
     
    }

这样我们也可以打印我们的数组。

Arrays.toString()打印

我们觉得上面两个太麻烦了，在Java中还支持这样的语法，使用方法把数组变为字符串打印出来：

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

这样我们也可以打印数组。这是如何实现的呢？我们可以在帮助文档中找到这个方法：


就可以看到有关他的相关介绍。

数组的练习

冒泡排序

在我讲解C语言时我们写过一个排序，冒泡排序，我们把数组作为方法的参数：

    public static void bubbleSort(int[] array) {
        //外层循环代表需要排序的次数，当数组中n - 1个数有序时，第n个数也有序，所以偶们只需要对array.length - 1个数排序
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;//当此次循环没有进行排序时说明数组有序
            //内层循环表示每个数的排序次数，因为每排一个都有一个数变为有序，所以每个数，排序次数是递减的
            for (int j = 0; j < array.length - 1 - i; j++) {
                if(array[j] > array[j + 1]) {//交换数据的条件
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    flag = true;
                }
            }
            if(flag == false) {
                return ;
            }
        }
    }
    
    public static void main2(String[] args) {
        int[] array = new int[]{2,1,3,4,5,6,8,7,9};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

常用的API

使用这些Java中内置的方法我们可以快速的完成我们想要的需求，当然除了我介绍的方法外还有一些方法大家可以自己在帮助文档中查阅。

数组拷贝Arrays.copyOf()

 public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        int[] arr2 = Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(arr2));
    }

数组排序Arrays.sort()

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

数组的快速初始化Arrays.fill()

  public static void main(String[] args) {
        int[] arr = new int[10];
        Arrays.fill(arr,1);
        System.out.println(Arrays.toString(arr));
    }

二维数组

二维数组其实就是特殊的一维数组，我们来看看二维数组的基本语法：
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

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

我们就可以使用上面这行代码创建一个二维数组，我们也可以遍历他并且将他打印出来。

 public static void main1(String[] args) {
        int[][] array = new int[][]{{1,2,3},{4,5,6}};
        //打印数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
}

我们可以运行一下查看结果：

在C语言中我们说二维数组的行可以省略列不可以省略，但是在Java中恰恰相反。

    public static void main(String[] args) {
        int[][] array4 = new int[2][];
        array4[0] = new int[]{1,2,3,4,5,6};
        array4[1] = new int[]{3,4,5,6};
        System.out.println(Arrays.deepToString(array4));
    }

我们称这样的数组为不规则数组，有的小伙伴要问了，博主你怎么没有遍历就把这个二维数组打印出来了，其实二维数组的打印也有简便的方法。使用Arrays.deepToString()这个方法就可以实现打印二维数组。