正文

Java基础之不简单的数组

︶ㄣ速达网 メ
米米素材网V管理员 / 阅读
0919

数组(Array)是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量

引言

相信有过编程基础的小伙伴都知道数组这个数据结构，它应该也是我们第一个接触的数据结构，学过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其实支持两种语法声明数组：

?
1
2
type[] myArray;
type myArray[];

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

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

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

1.静态初始化

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

格式如下：

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

或者

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

测试代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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");
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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.动态初始化

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

格式如下：

?
1
type myArray = new type[length];

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

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

测试代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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语言指针动态分配内存，当一个指针动态分配了一块内存后，这一块内存存放在堆中，而这个指针变量存放在栈中，只有通过这个指针变量才能访问到分配的动态内存 }

画个图更好理解：

Java基础之不简单的数组

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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：内容如果有问题欢迎交流！！

到此这篇关于Java基础之不简单的数组的文章就介绍到这了,更多相关Java 数组内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！

原文链接：https://blog.csdn.net/YXXXYX/article/details/120107234