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中方法的使用 中谈到当传递参数类型为内置类型时也就是简单类型时，可以发现修改形参的值是不会改变实参的值的。

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

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 的内存被划分成了几个区域：

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 来调用的函数。

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("%d\t", arr[row][col]); }System.out.println(""); 
}
//将二位数组转为字符串打印
System.out.println(Arrays.deepToString(数组名));