Java 数组总结

Java数组总结

1.数组的基本用法

1.1数组的定义

数组是“批量”创建**相同类型**的变量；

1.2创建数组

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

代码示例：
int[] arr = new int{1, 2, 3};
int[] arr = {1, 2, 3}; 

注意：
静态初始化时，数组元素个数和初始化数据的个数是一样的。

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. 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到；
2. 使用 [ ] 按下标取数组元素. 需要注意, 下标从0开始数；
3. 下标访问不能超过有效范围【0~length-1】，如果超出范围会出现下标越界异常。如：

int[] arr = {1, 2, 3};
System.out.println(arr[100]);

这样就会出现下标越界异常Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException:

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

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); 
}

执行结果与for语句相同；
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.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 是一个 “引用” . 当传参的时候, 是按照引用传参。
什么是引用?
引用相当于一个 “别名”, 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.

3.数组作为方法的返回

** 写一个方法, 将数组中的每个元素都 * 2**
class Test {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
int[] output = transform(arr);
printArray(output);
}

public static void printArray(int[] arr) {         
    for (int i = 0; i < arr.length; i++) {             
	    System.out.println(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;     
    } 
} 

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

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]

4.2数组拷贝
for语句拷贝：

public static int[] copyOf(int[] arr) {    
	int[] ret = new int[arr.length];     
	for (int i = 0; i < arr.length; i++) {         
		ret[i] = arr[i];    
	}     
	return ret; 
} 
  

返回值：
void arraycopy 速度快
int[] copyOf
数组名.clong() ->数组名为你要拷贝的数组 是Object的方法 返回一个副本
深拷贝：对于数组当中是简单类型
浅拷贝：对于数组类型当中是引用数组
4.3数组排序
Arrays.sort(array) 将数组进行排序

5.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

int[][] arr = {     
	{1, 2, 3, 4},     
	{5, 6, 7, 8},     
	{9, 10, 11, 12} 
}; 
 
for (int row = 0; row < arr.length; row++) {     
	for (int col = 0; col < arr[row].length; col++) {         
		System.out.printf("%d\t", arr[row][col]);     
	}     
	System.out.println(""); 
} 
 
// 执行结果 
1       2       3       4 
5       6       7       8 
9       10      11      12 

二维数组的用法和一维数组并没有明显差别。