JAVASE语法零基础——数组的定义与使用【JAVA教程】

Java系列文章目录

---

Write once,Runanywhere.???

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

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

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

??? 新的知识开始喽???

文章目录

• Java系列文章目录
• 1.数组的定义
• 2.数组的创建和初始化
• • 2.1 数组的创建
  • 2.2 数组的初始化
  • • 2.2.1 动态初始化
    • 2.2.2 静态初始化
    • 2.2.3 null
    • 2.2.4 一些说明
• 3. 数组的访问和打印
• • 3.1 数组通过下标访问
  • 3.2 数组的打印
• 4.引用类型
• • 3.1 初始JVM的内存分布
  • 3.2 基本类型变量与引用类型变量的区别
• 4 数组的使用场景
• • 4.1 保存数据
  • 4.2 作为函数的参数
  • • 4.2.1 基本数据类型传参
    • 4.2.2 引用类型传参
    • 4.2.3数组作为函数的返回值
• 5. 二维数组

---

---

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(n2){
            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();
        }
    }

---

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

?? ?? ??下次见喽?? ?? ??