JAVASE语法零基础——数组的定义与使用

Java系列文章目录

---

Write once,Runanywhere.🔥🔥🔥

这篇文章讲解数组，从这篇文章开始讲解的知识就跟C语言有所不同了。

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

🚀🚀🚀 新的知识开始喽🚀🚀🚀

---

---

1.数组的定义

数组概念：相同类型元素的移个集合。
在Java中数组是一块连续的空间，存储相同元素类型的集合。

2.数组的创建和初始化

2.1 数组的创建

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

T：表示数组中存放元素的类型
T[]：表示数组的类型
N：表示数组的长度
new关键字：数组是对象在堆上创建

2.2 数组的初始化

数组的初始主要化分为动态初始化以及静态初始化，注意数组作为对象都是在堆上的。

2.2.1 动态初始化

在创建数组时，直接指定数组中元素的个数
下面举例数组的创建与初始化：

  //动态初始化
        int[] arr1 = new int[5];
        double[] arr2 = new double[5];
        String[] arr3 = new String[5];

2.2.2 静态初始化

在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
一般在静态初始化数组时，我们会将new T[]省略，简写成下面的语法格式
语法格式:T[] 数组名 = {data1,data2,...,datan};
下面举例数组的创建与初始化：

 //静态初始化
        int[] array1 = new int[]{1,2,3,4,5};
        double[] array2 = new double[]{1.0,2.0,3.0,4.0};
        String[] array3 = new String[]{"hello","java"};

2.2.3 null

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

 int[] arr = null;
        System.out.println("arr:"+arr);
        System.out.println(arr.length);//因为arr不指向任何对象，所以arr.length会异常

运行结果：

2.2.4 一些说明

• 对于静态初始化，虽然初始化时没有指定数组的长度，编译器在编译时会根据{}中的元素个数来确定数组的长度
• 静态初始化时，{}中数据类型必须与[]前数据类型一致
• 数组也可以按照如下C语言个数创建，不推荐，看下面比较：

//创建整型变量
int a = 10; //变量名为a 变量类型为int
//创建数组:C语言方式创建
int arr [] ={1,2,3,4,5};//数组名为arr 容易造成数组类型就是 int类型的误解

• 静态和动态初始化也可以分为两步，但是不可以省略new T[]

//静态
int[] array9;
array9 = new int[5];
//动态
int[] array10;
array10 = new int[]{1,2,3,4,5};

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

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

3. 数组的访问和打印

3.1 数组通过下标访问

数组访问：数组名[下标]
数组长度：数组名.length
示例：for循环遍历数组

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

注意：当数字不指向任何对象—>null时，计算数组对象的长度会报错。

 public static void main(String[] args) {
        int[] arr = null;
        System.out.println(arr.length);
    }

运行结果：

3.2 数组的打印

用到下标的打印：

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

for each打印：for(类型 变量名：数组名){ 打印语句}没有用到下标，依次从数组里读取元素，然后放到：前的变量当中。

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

为了让我们更好的去操作数组，Java提供了一系列的方法，这些方法在工具类Arrays当中：

import java.util.Arrays;//导入包
为了让我们更好的去操作数组，提供了一系列的方法，这些方法在工具类Arrays当中
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        String ret = Arrays.toString(arr);将你传进来的数组，以字符串的形式进行输出 tostring的返回类型是String类型
        System.out.println(ret);
    }

运行结果：

4.引用类型

数组时引用类型

3.1 初始JVM的内存分布

内存是一段连续的空间，主要用来存储程序运行时数据的。
1.程序运行时代码需要加载到内存
2.程序运行产生的中间数据要存放在内存
3.程序中的常量也要保存
4.有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁
下面看JVM内部不同区域的划分：

程序计算器(PC Register)：只是一个很小的空间，保存下一条执行的指令地址
虚拟机栈(JVM Stack)：与方法调用相关的一些信息，每个方法在执行时，都会先创建移栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
本地方法栈(Native Method Stack)：本地方法栈与虚拟机栈的作用类似，只不过保存的内容是Native方法的局部变量，在有些版本的JVM(例如HotSpot)，本地方法栈和虚拟机栈是一起的。
堆(Heap)：JVM所管理的最大内存区域，使用new创建的对象都是在堆上保存(例如前面的new int[]{1,2,3,4,5}),堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。
方法区(Method Area):用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，方法编译出的字节码就是保存在这个区域
现在我们只关心堆和虚拟机栈这两块区域，后序JVM中还会跟详细介绍。

3.2 基本类型变量与引用类型变量的区别

由基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
引用数据类型创建的变量，一般称为对象的引用，其空间中存放的是对象所在空间的地址
下面举例说明：

  public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int[] array = {1,2,3,4,5};
        System.out.println(a);
        System.out.println(b);
        System.out.println("array:"+array);
        }

运行结果：

上述代码中，a、b、arra都是main函数内部的变量，因此其空间都在main方法对应的栈帧中分配。
a、b是基本类型变量，因此其空间保存就是给该变量初始化的值。
array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆堆空间上对应的地址(可以理解成是首地址)。
看下面的图：

**从上图可以看出，引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆空间的起始地址。通过该地址，引用变量便可以去操作对象。**有点类似C语言中的指针，但是Java中引用要比指针的操作更简单。

再看下面的代码：

  public static void main(String[] args) {
        int[] arr1 = new int[3];
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
        
        int[] arr2 = new int[]{1,2,3,4,5};
        arr2[0] = 100;
        arr2[1] = 200;
        
        arr1=arr2;
        arr1[2] = 300;
        arr1[3] = 400;
        arr1[4] = 500;
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }

分析过程以及运行结果：

4 数组的使用场景

4.1 保存数据

        int[] arr = {1,2,3,4,5};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

4.2 作为函数的参数

4.2.1 基本数据类型传参

基本数据类型传参就是基本类型作为实参来传入到被调用的方法里。

 public static void fuc(int b){
        b = 20;
    }
    public static void main(String[] args) {
        int a = 10;
        fuc(a);
        System.out.println(a);
    }

运行结果：

因为a为main方法里的局部变量，在main的方法栈帧中，b为fuc方法里的局部变量，在fuc的方法栈帧中，在main方法里调用fuc时，b是a的临时拷贝，在fuc调用结束后，fuc方法栈帧销毁，a的值并未发生改变。

4.2.2 引用类型传参

看下面一段代码：

  public static void func1(int[] array) {
        array = new int[]{1,2,3};
    }
    public static void func2(int[] array) {
        array[0] = 99;
    }

    public static void main(String[] args) {
        int[] array = {9,8,7};
        func1(array);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+ " ");
            System.out.println();
        }
        System.out.println("===========");
        func2(array);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+ " ");
        }
        System.out.println();
    }

运行结果：


总结：
1.Java当中无论是基本数据类型传参还是引用类型传参，其实都是传值，不过基本数据类型传参传的是简单值，而引用类型传参传的是对象在堆空间中开辟一块连续空间的首地址。
2.就算是传递的是引用类型，也可能不会影响main方法里的数组对象，因为func1方法中的引用类型在拷贝到了main方法中数组对象的地址后，还是可以通过关键字new去指向一块在堆上新开辟的空间，而不影响main方法里引用类型所指向的数组对象。

4.2.3数组作为函数的返回值

//数组作为函数的返回值 获取斐波那契数列的前N项
    public static int[] fib(int n){
        if(n<=0){
            return null;
        }
        int[] arr = new int[n];
        arr[0]=1;
        arr[1]=1;
        if(n>2){
            for (int i = 3; i < n; i++) {
                arr[i] = arr[i-1]+arr[i-2];
            }
        }
        return arr;
    }
    public static void main(String[] args) {
        int[] arr = fib(10);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

运行结果：

5. 二维数组

二维数组本质上就是一个特殊的一维数组，只不过二维数组的每一个元素又是一个一维数组。
二维数组的定义语法：数据类型[][] 数组名= new 数据类型[行数][列数]{数据初始化内容}
二维数组的三种创建以及初始化方式：

 int[][] arr1 = {{1,2,3},{4,5,6}};
 int[][] arr2 = new int[2][3];
 int[][] arr3 = new int[][]{{1,2,3},{4,5,6}};

循环遍历二维数组：

public static void main(String[] args) {
        int[][] arr1 = {{1,2,3},{4,5,6}};
        for (int i = 0; i < arr1.length; i++) {//arr1.length表示行数
            for (int j = 0; j < arr1[i].length; j++) {//arr1[i].length表示每一行元素的数组长度
                System.out.print(arr1[i][j]+" ");
            }
            System.out.println();
        }
    }

for each遍历二维数组：嵌套使用for each

 //for each遍历二维数组
        int[][] arr={{1,2,3},{4,5,6}};
        for (int[] tmp:arr) {
            for (int x: tmp) {
                System.out.print(x+" ");
            }
            System.out.println();
        }
    }

不规则二维数组：列数不是确定的，在定义不规则二维数组时，可以省略列数。

  //定义不规则二维数组
        int[][] arr = new int[2][];//不规则二维数组
        arr[0] = new int[3];
        arr[1] = new int[5];
        String ret = Arrays.deepToString(arr);//打印二维数组需要使用ToString
        System.out.println(ret);

运行结果：两行，一行3列，一行5列。

---

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

🌔 🌔 🌔下次见喽🌔 🌔 🌔