Java中数组的定义和使用

最新推荐文章于 2023-06-10 16:01:43 发布

na小子叫坚强

最新推荐文章于 2023-06-10 16:01:43 发布

阅读量2.7k

点赞数 28

分类专栏： java学习笔记文章标签： java 编程语言

本文链接：https://blog.csdn.net/weixin_46078890/article/details/109018173

版权

java学习笔记专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1.数组基本用法

1.1什么是数组

数组本质上就是让我们能 “批量” 创建相同类型的变量。
例如:
如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b 。
如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;
但是如果需要表示一万个数据, 那么就不能创建一万个变量了。这时候就需要使用数组, 帮我们批量创建。

1.2创建数组

基本语法：

//静态初始化
数组类型[]数组名称 = {初始化数据}；//用逗号间隔
//动态初始化
数据类型[]数组名称 = new 数据类型[]{初始化数据}；
//未初始化
数据类型[]数组名称 = new 数据类型[数组大小]; //这里必须指定大小，不然会报错。

代码示例：

int[] arr = new int[]{1, 2, 3}; 
int[] arr = {1, 2, 3};
int[] arr = new int[4];

注意：

静态初始化的时候, 数组元素个数和初始化数据的格式是一致的，不能在前面的中括号中写具体的数字。
其实数组也可以写成：

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

但是这样就和C/C++语言没什么区别了，所以我们还是更推荐写成 int[] arr 的形式，int和 [ ]是一个整体。

1.3数组的使用

代码示例：获取数组长度&访问元素

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

注意：

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

代码示例：数组越界

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

抛出了java.lang.ArrayIndexOutOfBoundsException 异常。所以使用数组一定要防止下标越界。

代码示例：遍历数组

通常需要用到循环语句。

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

方法2：
使用 for-each 遍历数组
int[] arr = {1, 2, 3}; 
for (int x : arr) { 
	System.out.print(x+" "); 
}
// 执行结果 1 2 3

for-each 是for循环的另外一种使用方式，能够更方便的完成对数组的遍历，可以避免循环条件和更新语句写错。

2.数组作为方法的参数

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.print(x+" "); 
	} 
}
// 执行结果 1 2 3

在这个代码中：

int[] a 是函数的形参，其作用域在printArray这个函数中，int[] arr 是函数实参。
在printArray()中，想要获取数组长度，同样可以使用 a.length。

2.2理解引用类型(重点)

关于传参类型我已经在 java中方法的使用中谈到当传递参数类型为内置类型时也就是简单类型时，可以发现修改形参的值是不会改变实参的值的。
在这里插入图片描述

代码示例：参数传数组类型

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

我们发现, 在函数内部修改数组内容, 函数外部也发生改变。
此时数组名 arr 是一个 “引用” 。当传参的时候, 是按照引用传参。
这里我们要先从内存开始说起：
内存就是指我们熟悉的 “内存”. 内存可以直观的理解成一个宿舍楼。有一个长长的大走廊, 上面有很多房间。
每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿个这样的房间)。每个房间上面又有一个门牌号, 这个门牌号就称为地址。

引用是什么：

引用相当于一个 “别名”, 也可以理解成一个指针。
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址。
关于引用，可以参考 C++入门知识点详谈。
那么针对 int[] arr = new int[]{1,2,3}; 这段代码，内存布局如图：
(a) 当我们创建 new int[]{1, 2, 3} 的时候, 相当于创建了一块内存空间保存三个 int。
(b) 接下来执行 int[] arr = new int[]{1, 2, 3} 相当于又创建了一个 int[] 变量, 这个变量是一个引用类型, 里面只保存了一个整数(数组的起始内存地址)。
在这里插入图片描述
© 接下来我们进行传参相当于 int[] a = arr , 内存布局如图:

(d) 接下来我们修改 a[0] , 此时是根据 0x100 这样的地址找到对应的内存位置, 将值改成 100。

此时已经将 0x100 地址的数据改成了 100 。也就是说通过a[0]修改，arr[0]也会改变。那么根据实参 arr 来获取数组内容 arr[0] , 本质上也是获取 0x100，地址上的数据, 也是 100。
总结: 所谓的 “引用” 本质上只是存了一个地址.。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)

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

2.4初识 JVM 内存区域划分(重点)

JVM 的内存被划分成了几个区域：

程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址。
虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存。
本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的. 堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )。
方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法编译出的的字节码就是保存在这个区域。
运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意从 JDK1.7开始，运行时常量池在堆上)。

Native 方法:

JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数。
这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数。
在这里插入图片描述

局部变量和引用保存在栈上, new 出的对象保存在堆上。
堆的空间非常大, 栈的空间比较小。
堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈)。

3.数组作为方法的返回值

代码示例：写一个方法，将数组中的每个元素都 * 2

// 直接修改原数组 
class Test { 
public static void printArray(int[] arr) {  //打印这个数组
	for (int i = 0; i < arr.length; i++) { 
	System.out.print(arr[i]+" "); 
	} 
}
public static void transform(int[] arr) { 
	for (int i = 0; i < arr.length; i++) { 
		arr[i] = arr[i] * 2; 
	} 
} 
	public static void main(String[] args) { 
		int[] arr = {1, 2, 3}; 
		transform(arr); 
		printArray(arr); 
	}
} 
//运行结果：
2 4 6

可以看到这个代码固然可行，但是破坏了原有的数组内容，有时候我们不希望不破坏原数组，就需要在方法内部创建一个新的数组，并由方法返回出来。

代码示例：

//返回一个新的数组
class Test { 
public static void printArray(int[] arr) {  //打印这个数组
	for (int i = 0; i < arr.length; i++) { 
	System.out.print(arr[i]+" "); 
	} 
}
public static int[] transform(int[] arr) { 
	int[] ret = new int[arr.length];
	for (int i = 0; i < arr.length; i++) { 
		ret[i] = arr[i] * 2; 
	} 
	return ret;
} 
	public static void main(String[] args) { 
		int[] arr = {1, 2, 3}; 
		int[] ret = transform(arr); 
		printArray(ret); 
		System.out.println();
		printArray(arr);
	}
} 
//运行结果:
2 4 6
1 2 3

这样的话就不会破坏原有数组了,另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高
效。

4.数组常见操作

4.1数组转字符串

代码示例：

import java.util.Arrays 
int[] arr = {1,2,3,4,5,6}; 
String newArr = Arrays.toString(arr); System.out.println(newArr); 
// 执行结果 
[1, 2, 3, 4, 5, 6]

使用这个方法打印数组变的更简单一些。
Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法。自己可以把Arrays包里的每个方法都试试。
当然我们也可以自己实现一个数组转字符串：

public static String toString(int[] arr) { 
	String ret = "["; 
	for (int i = 0; i < arr.length; i++) { 
		// 借助 String += 进行拼接字符串 
		ret += arr[i]; 
		// 除了最后一个元素之外, 其他元素后面都要加上 ", " 
		if (i != arr.length - 1) { 
			ret += ", "; 
		} 
	}
	ret += "]"; 
	return ret; 
}
public static void main(String[] args) { 
	int[] arr = {1,2,3,4,5,6}; 
	System.out.println(toString(arr)); 
}
//运行结果:
[1, 2, 3, 4, 5, 6]

4.2数组拷贝

首先实现自己的拷贝数组，用常用for循环即可：

public static int[] copyOf(int[] arr) { 
	int[] ret = new int[arr.length]; //创建一个和arr一样大小的新数组
	for (int i = 0; i < arr.length; i++) { 
		ret[i] = arr[i]; 
	}
	return ret; 
}

当然，也有本地方法，更快速：

public static void main(String[] args) {
		int []arr = {1,2,3,4,5};
		int []dest = new int[arr.length];
		//方法1：本地方法
		//System.arraycopy(src,srcPos,dest,destPos,length);
		//src：源数组   srcPos: 从源数组的pos位置开始拷贝
	    //dest：拷贝到目的数组 destPos：拷贝到目的数组的pos位置
	    //length： 拷贝长度
		System.arraycopy(arr, 0, dest, 0, arr.length);
		//方法2:(速度最快)	
		//Arrays.copyOf(src,length);
		//src: 源数组  length:拷贝长度
		int []dest = Arrays.copyOf(arr, arr.length);
		//方法3:
		//数组名.clone(); 产生需要克隆的对象的一个副本
		int []dest = arr.clone();
		System.out.println(Arrays.toString(dest));	
	}

4.3检查数组有序性

给定一个整型数组, 判断是否该数组是有序的(升序)：

public static boolean isSorted(int[] arr) { 
	for (int i = 0; i < arr.length - 1; i++) {
 		if (arr[i] > arr[i + 1]) { 
 			return false; 
 		} 
 	}
 	return true; 
 }
 public static void main(String[] args) { 
 	int[] arr = {1,2,3,10,5,6}; 
 	System.out.println(isSorted(arr)); 
 }
 //运行结果：false

4.4数组排序(冒泡排序)

给定一个数组, 让数组升序 (降序) 排序。
具体参考简单冒泡排序和冒泡排序改进版
冒泡排序性能较低. Java 中内置了更高效的排序算法。
代码示例：

public static void main(String[] args) { 
	int[] arr = {9, 5, 2, 7}; 
	Arrays.sort(arr); 	
	System.out.println(Arrays.toString(arr)); 
}
运行结果: [2, 5, 7, 9]

4.5数组数字排列

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分。

例如
{1, 2, 3, 4}
调整后得到
{4, 2, 3, 1}

基本思路
设定两个下标分别指向第一个元素和最后一个元素。用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素,依次循环即可。

具体参考:

将一个数组的奇数放在偶数前面，这个是将奇数放在偶数前面，如果要将偶数放在奇数前面，将判定条件一改就ok了。

5.二维数组

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

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

代码示例：

int[][] arr = new int[2][3];

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

int[][] arr = new int[2][3]{{1,2},{3,4}};

int[][] arr = new int[2][]; //不规则数组，列数需要自己指定
arr[0] = 2;  //第一列
arr[1] = 3;  //第二列

二维数组的用法和一维数组并没有明显差别，二位数组遍历与C/C++有些许不同。
代码示例：

for (int row = 0; row < arr.length; row++) {  //arr.length 这里指的是二维数组的行数
	for (int col = 0; col < arr[row].length; col++) {//arr[row].length 这里指每一行的列数 		
		System.out.printf("%d\t", arr[row][col]); 
	}
	System.out.println(""); 
}
//将二位数组转为字符串打印
System.out.println(Arrays.deepToString(数组名));

na小子叫坚强

关注

28
点赞
踩
20

收藏

觉得还不错? 一键收藏
9
评论
Java中数组的定义和使用

目录：1.数组基本用法：1.1什么是数组 1.2 创建数组 1.3数组的使用 2.数组作为方法的参数：2.1基本用法 2.2理解引用类型(重点) 2.3 认识null 2.4 初识 JVM 内存区域划分(重点) 3.数组作为方法的返回值 4.数组常见操作：4.1 数组转字符串 4.2数组拷贝 4.3检查数组有序性 4.4 数组排序(冒泡) 4.5 数组数字排列 5. 二维数组
复制链接

扫一扫