• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

Java中数组的定义和使用

互联网 diligentman 2周前 (10-16) 13次浏览

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

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

在这个代码中:

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

2.2理解引用类型(重点)

关于传参类型我已经在 java中方法的使用 中谈到当传递参数类型为内置类型时也就是简单类型时,可以发现修改形参的值是不会改变实参的值的。
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[] 变量, 这个变量是一个引用类型, 里面只保存了一个整数(数组的起始内存地址)。
Java中数组的定义和使用
© 接下来我们进行传参相当于 int[] a = arr , 内存布局如图:
Java中数组的定义和使用
(d) 接下来我们修改 a[0] , 此时是根据 0x100 这样的地址找到对应的内存位置, 将值改成 100。
Java中数组的定义和使用
此时已经将 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 的内存被划分成了几个区域:

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

Native 方法:

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

  1. 局部变量和引用保存在栈上, new 出的对象保存在堆上。
  2. 堆的空间非常大, 栈的空间比较小。
  3. 堆是整个 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("%dt", arr[row][col]); 
	}
	System.out.println(""); 
}
//将二位数组转为字符串打印
System.out.println(Arrays.deepToString(数组名)); 

喜欢 (0)