【0 基础学 Java】（九）数组

最新推荐文章于 2024-08-09 07:30:00 发布

编程反思录

最新推荐文章于 2024-08-09 07:30:00 发布

阅读量605

点赞数 1

分类专栏： JavaSE 文章标签： java 编程语言数组

本文链接：https://blog.csdn.net/qq_44954010/article/details/106689514

版权

JavaSE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

码字不易，对你有帮助 点赞/转发/关注 支持一下作者

微信搜公众号：不会编程的程序圆

看更多干货，获取第一时间更新

看更多示例和代码： https://github.com/hairrrrr/EasyJava，欢迎 star

思维导图

上面的高清思维导图获取方式：请看原文的文末哦~

阅读原文

正文

一数组的基本用法

1.1 什么是数组

数组本质上就是让我们能 “批量” 创建相同类型的变量。

例如:
如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b 。

如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5 。

但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建。

注意事项: 在 Java 中, 数组中包含的变量必须是 相同类型。

1.2 创建数组

基本语法

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [ ] { 初始化数据 };

// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };

例如：

int[] arr1 = new int[3];//定义但不初始化
int [] arr2 = {1,2,3};//定义并初始化，数组大小为 3
int[] arr3 = new int[]{1, 2, 3};//定义并初始化，数组大小为 3。后面的[]内不能写数字

没有初始化的数组元素默认值为 0

其实数组也可以写成:

int arr[] = {1, 2, 3}；

这样就和 C 语言更相似了. 但是我们还是更推荐写成 int[] arr 的形式. int和 [] 是一个整体

1.3 数组的使用

1）获取长度 & 成员访问

int[] arr = {1, 2, 3};
// 获取数组长度
System.out.println("length: " + arr.length); // 执行结果: 3
// 访问数组中的元素
System.out.println(arr[1]); // 执行结果: 2
System.out.println(arr[0]); // 执行结果: 1
arr[2] = 100;
System.out.println(arr[2]); // 执行结果: 100

注意

使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
使用 [ ] 操作既能读取数据, 也能修改数据.
下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常

2）下标越界

int[] arr = {1, 2, 3};
System.out.println(arr[100]);
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at Test.main(Test.java:4)

3）遍历数组

所谓 “遍历” 是指将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句。

for 循环遍历

int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
	System.out.println(arr[i]);
}
// 执行结果
1 
2 
3

for - each 遍历数组

int[] arr = {1, 2, 3};
for (int x : arr) {
	System.out.println(x);
}
// 执行结果
1 
2 
3

使用 Arrays 类的方法

int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr));//将 数组 转化为 字符串

将数据内容以字符串的形式输出

在 Java 中提供了一个工具类，这个工具可以帮助我们操作数组。

int[] arr = new int[]{1,2,3};
System.out.println(Arrays.toString(arr));
//输出：
//[1, 2, 3]

二数组作为方法的参数

2.1 基本用法

打印数组内容

public static void main(String[] args) {
	int[] arr = {1, 2, 3};
	printArray(arr);
}
public static void printArray(int[] a) {
	for (int x : a) {
	System.out.println(x);
	}
}
// 执行结果
1 2 3

注意

int[] a 是函数的形参, int[] arr 是函数实参
如果需要获取到数组长度, 同样可以使用 a.length

2.2 引用类型

普通变量作为方法参数与数组作为方法参数的不同

普通变量作为方法参数：

public static void main(String[] args) {
	int num = 0;
	func(num);
	System.out.println("num = " + num);
}
public static void func(int x) {
	x = 10;
	System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0

我们发现, 修改形参 x 的值, 不影响实参的 num 值

数组作为参数：

public static void main(String[] args) {
	int[] arr = {1, 2, 3};
	func(arr);
	System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
	a[0] = 10;
	System.out.println("a[0] = " + a[0]);
}
// 执行结果
a[0] = 10
arr[0] = 10

我们发现, 在函数内部修改数组内容, 函数外部也发生改变

此时数组名 arr 是一个 “引用” ，当传参的时候, 是按照引用传参。

总结

所谓的 “引用” 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大) 。

2. 3 null

null 在 Java 上表示空引用

int[] arr = null;
System.out.println(arr[0]);
// 执行结果
Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:6)

2.4 JVM 内存区域划分

Java 跨平台一个很重要的原因就是最终 Java 的程序都是在 JVM 上运行的。

注意：

从 JDK1.7 开始，运行时常量池移入堆中。
每一个线程（Thread）中都有一个虚拟机栈，程序计数器，本地方法栈，而堆和方法区是共享的。

2.5 浅拷贝与深拷贝

int[] arr1 = new int[3]{1, 2, 3};
int[] arr2 = arr1;
int[] arr3 = Arrays.copyOf(arr1);
arr1[0] = 0;
System.out.println(arr2[0]);
System.out.println(arr3[0]);

//输出：
0
1

Arrays.copyOf() 是包含在 Arrays 类中的方法，使用需要导入包java.util.Arrays，作用是拷贝数组 arr1 到 arr3 中（这句话其实很耐人寻味）。

我们发现：改变 arr1 中元素的值，arr2 中的元素也被改变了，但是 arr3 的元素并没有被改变，这是为什么呢？

int[] arr2 = arr1这样让两个引用指向同一块内存的拷贝称为 浅拷贝

int[] arr3 = Arrays.copyOf(arr1) 这样让两个引用指向的是不同内存的拷贝称为 深拷贝

三数组作为方法的返回值

如果我想将数组每个元素都乘以 2，我们可以这么做：

class Test1{
    public static void main(String[] args) {

        int[] arr = {3, 4, 2, 1};
        Double(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void Double(int[] arr) {

       for(int i = 0; i < arr.length; i++) {
           arr[i] *= 2;
       }
    }

}

但是，如果我们不想改变原有数组的内容，上面这种方式就不合适了。这时，我们可以在函数内创建一个新的数组，然后返回运算后的数组即可。

class Test1{
    
    public static void main(String[] args) {

        int[] arr = {3, 4, 2, 1};
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(Double(arr)));
    }
    public static int[] Double(int[] arr) {
        int[] ret = new int[arr.length];
       for(int i = 0; i < arr.length; i++) {
           ret[i] = arr[i] * 2;
       }
       return ret;
    }

}
//输出：
[3, 4, 2, 1]
[6, 8, 4, 2]

四二维数组

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

5.1 二维数组的创建

 int[][] arr1 = {{1, 2}, {3, 4}, {5, 6}};
 int[][] arr2 = new int[][]{{1, 2, 3}, {4, 5, 6}};
 //不规则二维数组,可手动指定列数
 int[][] arr3 = new int[2][];
 arr3[0] = new int[]{1,2};
 arr3[1] = new int[]{3, 4, 5, 6};
 System.out.println(Arrays.deepToString(arr3));

5.2 遍历数组

for 循环

class Test1{
    public static void main(String[] args) {
        int[][] arr1 = {{1, 2}, {3, 4}, {5, 6}};
        for(int row = 0; row < arr1.length; row++){
            for(int col = 0; col < arr1[row].length; col++){
                System.out.print(arr1[row][col] + " ");
            }
            System.out.println();
        }
    }

}

for-each

class Test1{
    public static void main(String[] args) {
        int[][] arr1 = {{1, 2}, {3, 4}, {5, 6}};
        for(int[] row : arr1){
            for(int col : row){
                System.out.print(col + " ");
            }
            System.out.println();
        }
    }

}