Java 数组

引言

相信有过编程基础的小伙伴都知道数组这个数据结构，它应该也是我们第一个接触的数据结构，学过C或者C++的应该知道数组和指针紧密相关，那么在java里没有了指针，java里的数组又有哪些不同的特点呢？下面就来介绍一下java里的数组；

数组也是一种类型

数组里面的数组元素都是唯一的，这个大家应该都知道，但是因为java是面向对象语言，类与类之间又有继承关系（C++中同样拥有），所以有时候会出现一个数组里面出现多种数据类型的情况，其实归根结底，数组元素的类型就是一个，就是那个父类；

在java中，其实数组也是一种数据类型，数组的父类是Object，数组本身是一种引用类型（基本类型如int，char ，double等）

就比如在java里定义数组的一种方式 ：int[] ，这是定义了一个整型的数组，不能把它分开来看，就把int[] 当成一种数据类型，这样我们用该类型创建的对象就是数组，所以int[] 是一种引用类型；

在下面的数组学习中一定要把数组当成引用类型来看，更有助于理解，不要带着C或者C++的数组来思考；

数组特点

下面就简单规整一些数组的几个特点：

1. 数组是一组数据的集合
2. 数组作为一种引用类型
3. 数组元素的类型可以是基本类型（基本类型数组），也可以是引用类型（引用类型数组），但同一个数组只能是同一种类型
4. 数组作为对象，数组中的元素作为对象的属性，而且数组包括一个成员属性 length，length 表示数组的长度
5. 数组的长度在数组对象创建后就确定了，就无法再修改
6. 数组元素是有下标的，下标从 0 开始，也就是第一个元素的下标为 0，依次类推最后一个元素的下标为 n-1，我们可以通过数组的下标来访问数组的元素

数组的声明和初始化

java其实支持两种语法声明数组：

type[] myArray;
type myArray[];

对于这两种方法，这里就不多介绍了，只是让大家了解一下，但是，我们需要记住并且使用的只用一种方法，就是第一种，不管是可读性还是对数组的理解，第一种都是完胜第二种的，可能刚学过C或者C++的都会看第二种更亲切些，从现在开始，就不要再想第二种了；（C#已经不支持第二种语法，并且越来越多语言不再支持该语法）；

数组是一种引用类型的变量，所以当它声名一个变量时，就只是定义了一个引用变量（也就是指针），学过C或者C++的小伙伴一定知道，当一个指针定义出来时并没有指向任何有效的内存空间，这里也是一样，这个引用变量也是没有指向任何有效空间，所以这时候的数组不能使用，需要进行初始化操作；
ps：学过C或者C++的话可以将引用变量和指针相互联系思考，学起来会更加轻松；

下面看看数组初始化操作，初始化其实就是给数组的元素分配内存空间（类似C、C++中的动态内存分配），并且为每个数组元素赋值；
数组初始化有两种方式：

1.静态初始化

初始化时由你自己来显式的指定每个数组元素的初始值，由系统来决定数组长度；

格式如下：

type[] myArray;
myArray = new type[] {element1, element2, element3, element4};

或者

type[] myArray = {element1, element2, element3, element4};

测试代码：

public class MyArrayTest02 {
    public static void main (String[] args) {
        //静态初始化数组01
        int[] arr;
        arr = new int[] {0, 1, 2, 3, 4};
        //foreach循环
        for (int i : arr) {
            System.out.println(i);
        }

        //静态初始化数组02
        Object[] objarr;
        objarr = new String[] {"I", " love", " coding!"};
        //foreach循环
        for (Object str : objarr) {
            System.out.print(str);
        }
        System.out.print("\n");
    }
}

public class MyArrayTest03 {
    public static void main (String[] args) {
        //静态初始化数组简化版01
        int[] arr = {0, 1, 2, 3, 4};
        //foreach循环
        for (int i : arr) {
            System.out.println(i);
        }

        //静态初始化数组02
        Object[] objarr = {"I", " love", " coding!"};
        //foreach循环
        for (Object str : objarr) {
            System.out.print(str);
        }
        System.out.print("\n");
    }
}

这两种哪一种都是可以的，第二种相对第一种简化一些，但是我感觉第一种更好有利于对数组内存空间的理解；

2.动态初始化

初始化时你只需要指定数组长度，系统会自动分配初始值；

格式如下：

type myArray = new type[length];

这里提一下系统自动分配的初始值：

1. byte，shoet，int，long 初始值是0
2. float， double初始值是0.0
3. char 初始值是'\0000'
4. boolean初始值是false
5. 所有引用类型初始值是null

测试代码：

public class MyArrayTest02 {
    public static void main (String[] args) {
        //动态初始化数组
        int[] arr = new int[5];
        for (int i = 0; i < arr.length; ++i) {
            arr[i] = i;
        }
        //foreach循环
        for (var i : arr) {
            System.out.println(i);
        }
     }
}    

数组和内存

java里面虽然没有了指针，但是java引入了引用的概念，同样是对内存的操作，所以理解好底层的机制对代码的编写和理解尤为重要；
下面的内容就是有一些小小的难度了，但是如果提前接触过指针的概念，对于下面的内容，你会发现许多相似之处；

数组引用变量是一个引用，只由引用变量指向了有效内存，才能通过数组变量访问数组元素；
同样，只有通过了数组的引用变量，才能访问到数组中的元素，即数组对象本身；

重点！！！
数组对象存储在堆中，引用变量存储在栈中（引用变量是局部变量的情况）
{ 这一点可以类比C语言指针动态分配内存，当一个指针动态分配了一块内存后，这一块内存存放在堆中，而这个指针变量存放在栈中，只有通过这个指针变量才能访问到分配的动态内存 }

画个图更好理解：

给大家来个案例看看，通过代码会更好理解：

public class PointTest {
    public static void main (String[] args) {
        int a[] = {1, 2, 3, 4, 5};
        //注意：此时的b的长度为6
        int[] b = new int[6];

        for (int i : a) System.out.print(i + " ");
        System.out.println();
        for (int i : b) System.out.print(i + " ");
        System.out.println();

        //b指向a所指向的内存
        b = a;

        //当b指向a所指向的内存空间时，b的长度就是a的长度
        System.out.println("b的长度为：" + b.length);
        //此时b指向的内存数据为
        for (int i : b) System.out.print(i + " ");
        System.out.println();
        //当a的第一个数据改变时，输出b的第一个数据看看是否改变
        a[0] = 100;
        System.out.println(b[0]);
    }
}

这里解释一下：
开始定义了两个引用变量：a和b，然后系统内存就产生了四个内存区，a和b就在栈区，而a和b所指向的数组本身在堆区；
a引用的数组对象里面有{1, 2, 3, 4, 5}五个元素，而b引用的数据对象则是系统初始化的，为{0, 0, 0, 0, 0, 0}六个元素，而当b指向a时，此时的b的数据对象就处于没有任何引用变量引用的情况，而a的数据对象此时被a和b两个引用变量所引用，此时b的长度就是a的长度5，所以当a的第一个数据改变时，相当于b的第一个数据改变；

总结一下：
我们看待一个数组时，要把数组看成两部分，一部分是数组的引用，即代码中定义的数组引用变量（存储在栈中），另一部分是实际的数组对象（存储在堆中）；所以需要用过引用变量来访问数组对象；

总结

在这里我只是简单的介绍了一下java中的数组，不要以为掌握了这些就算真正学会了数组了，这些只能算作java数组的一个入门，你也许能够学会使用数组，但是数组在内存中的运行机制还有很多难以理解的地方，强烈建议提前学习一下C语言指针的相关内容，还有指针数组也最好掌握理解，这些将会帮助你更好的理解数组在内存中的存储和初始化，理解了这些，你将会对你的程序运行机制有着更准确的把握！

ps：内容如果有问题欢迎交流！！