二、数组的定义和使用

🚀一、数组的基本概念

🌟1.1 什么是数组？

我们在C语言中已经交代过数组的概念和使用：
数组是相同类型元素的一个集合，数组在内存中是连续的一段空间。

数组有以下特点：

1. 数组中存放的元素的类型是相同的。
2. 数组的空间是连续的。
3. 每个空间都有自己的编号，初始位置为0，即数组的初始下标。

那么在JAVA中如何创建数组呢？

🌟1.2 数组的创建和初始化

1.2.1 数组的创建

JAVA中数组的创建与C语言中不相同

int[] arr = new int[10];
// 如上：int 是数组中存放元素的类型，
// arr 是数组名
// int[] 表示数组的类型
// 10 表示数组的长度

int[] arr1 = new int[10];		// 创建一个容纳 10 个 int 类型元素的数组
double[] arr2 = new double[5];	// 创建一个可以容纳 5 个 double 类型元素的数组
String[] arr3 = new String[3];	// 创建一个容纳 3 个字符串类型元素的数组

1.2.2 数组的初始化

在C语言中数组的初始化分为动态初始化和静态初始化，JAVA中同样也是。

1. 动态初始化：创建数组时，直接指定数组中元素的个数。

int[] arr = new int[10];

2. 静态初始化：创建数组时不指定数据元素的个数，而是直接指定具体的数据内容。

int[] arr = {0,1,2,3,4,5,6,7,8,9};

❌注意事项：

1. 静态初始化虽然没有指定数组的长度，但是会根据 {} 中元素的个数来确定。
2. 静态初始化时，{} 中的数据类型必须与 [] 前的数据类型一致。
3. 如果不确定数组当中内容，使用动态初始化，否则建议使用静态初始化。
4. 如果没有对数组进行初始化，数组中元素有默认值。

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

如果数组中存储的元素类型为引用类型，默认值为null

🌟1.3 数组的使用

1.3.1 数组中元素的访问

数组在内存中是一段连续的空间，编号从 0 开始，依次递增，该编号称为数组的下标，数组可通过下标访问其任意位置的元素。

int[] arr = new int[10];
arr[0] = 999;	// 通过下标对数组元素修改

❗ 注意事项：

1. 数组是一段连续的内存空间，支持随机访问，即通过下标访问快速访问数组中任意位置的元素。
2. 下标从 0 开始，一共 N 个元素，下标介于[ 0, N-1 )，下标越界会报错。

1.3.2 遍历数组

遍历是将数组中的元素都访问一遍，访问是对数组中的元素进行某种操作。
数组中可以通过 arr.length 的形式获得数组长度

int[] arr = {0,1,2,3,4,5,6,7,8,9};
// arr.length 表示数组长度
for(int i = 0; i < arr.length; i++){
	System.out.println(arr[i]);
}

2. for - each 遍历数组

int[] arr = {0,1,2,3,4,5,6,7,8,9};
for(int x:arr){
	System.out.println(arr[i]);
}

for - each 是 for 循环的另一种表达方式，能够更方便的完成数组的遍历，缺点是无法精确获某个数组下标的元素。

🚀二、数组是引用类型

🌟 2.1 初始 JVM 的内存分布

内存是一段连续的存储空间，主要来存储程序运行时的数据。

1. 程序运行时的代码要加载到内存。
2. 程序运行时产生的中间数据要存放在内存。
3. 程序中的常量
4. 有些数据要长时间存储，但是有些数据当方法运行结束时要销毁。

JVM对所使用的内存按照功能的不同进行了划分

• **程序计数器：**很小的一个空间，保存下一条执行的指令的地址。
• **虚拟机栈：**与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包括局部变量表、操作数栈、动态链接、返回地址等。当方法运行结束后，栈帧就销毁了，栈帧中的数据也销毁了。
• 本地方法栈：本地方法栈和虚拟机栈的作用类似，但是保存的内容是Native方法的局部变量，有些版本的 JVM 中，本地方法栈和虚拟机栈是在一起的。
• 堆（Heap）： JVM所管理的最大内存区域，new创建的对象都在堆上保存，堆随着程序开始运行而创建，随着程序的退出而销毁。
• **方法区：存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。**方法编译出的字节码就是保存在这个区域。

🌟 2.2 基本类型变量和引用类型变量

基本数据类型创建的变量，称为基本变量，变量空间中存放的是其对应的值。
引用数据类型创建的变量，成为引用变量，空间中存放的是对象所在空间的地址。（与C语言中的指针类似，但是语法操作不同）

public static void func(){
	int a = 10;
	int b = 20;
	int[] arr = {1, 2, 3};
}
// a,b 是基本变量
// 数组 arr 是引用变量，内部保存的内容可以简单理解为数组在 “堆” 空间中的首地址。

🌕由上图可以看到，引用变量不直接存储数据对象本身，可以简单理解为数组在 “堆” 空间中的首地址。通过该地址，引用变量可以去操作对象。

🌟2.3 认识 null

null 在 JAVA 中表示”空引用“，也就是一个不指向对象的引用。

null 的作用类似C语言中的 NULL（空指针），表示一个无效的内存位置，因此不能对这个内存进行任何读写操作，否则会抛出 错误。

🚀三、数组的应用场景

🌟 3.1 保存数据

int[] arr = {0, 1, 2};

🌟 3.2 作为函数的参数

public static void main(String[] args){
	int[] arr = {1,2,3};
	func(arr);	// 数组作为函数的参数
	System.out.println(arr[0]);
}

public static void func(int[] arr){
	arr[0] = 10;
}
// arr[0] = 10;

• func 方法内部修改数组的内容，方法外部的内容也发生改变。因为数组是引用类型，按照引用类型传递参数，可以改变数据。

⛅

所谓的 “引用” 本质上只是存了一个地址，Java 将数组设定为引用类型，后续进行数组传参，其实指数将数组的地址传入到函数形参中。

🌟 3.3 作为函数返回类型

eg1: 实现一个方法，将数组每个值乘2.

public class ddd3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] ret = func2(arr);
        for(int i=0;i<ret.length;i++){
            System.out.println(ret[i]);
        }

    }
    // 数组作为返回类型
    public static int[] func2(int[] arr){
        int[] ans = new int[arr.length];
        for(int i =0;i<arr.length;i++){
            ans[i] = arr[i]*2;
        }
        return ans;	// 返回一个数组
    }
}

eg2 ：获取斐波那契数列的前 N 项

import java.util.Scanner;
import java.util.Arrays;

public class ddd3{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] ans = get_fib(n);
        
        // 以字符串形式输出数组
        // Arrays.toString(ans);
        System.out.println(Arrays.toString(ans));
    }
    public static int[] get_fib(int n){
        int ans[] = new int[n];
        ans[0] = ans[1] = 1;
        for(int i=2;i<n;i++){
            ans[i]  = ans[i-1] + ans[i-2];
        }
        return ans;
    }
}

🚀四、数组拷贝

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

        // 1. 直接复制
//        int[] newarr = arr;
//        System.out.println(Arrays.toString(newarr));

        // 2. clone 方法
//        int[] copy = arr.clone();
//        System.out.println(Arrays.toString(copy));

        // 3. copyOf 方法
//        int[] newarr = Arrays.copyOf(arr,arr.length);
//        System.out.println(Arrays.toString(newarr));

        // 4. 拷贝某个范围
//        int[] newArr2 = Arrays.copyOfRange(arr,2,4);
//        System.out.println(Arrays.toString(newArr2));
    }

❗ 注意事项：

数组中存储的是基本类型数据时，不管怎么拷贝都不会出现问题，但是如果存储的是引用数据类型，拷贝时要考虑深浅的问题。

🚀五、二维数组

二维数组本质上也是一维数组，只不过每个元素又是一个一维数组。

数组类型[][] = new 数据类型[行数][列数]{ 初始化数据 };

int[][] arr = { 1,2,3,4,5,6,7,8,9,10,11,12};
// arr.length 行长
for(int row = 0;row < arr.length;row++){
	//  arr[row].length 列长
	for(int col = 0;col < arr[row].length;col++){
		 System.out.println(arr[row][col]);
	}
}

---

好了，本文到这里就结束了。