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(数组名));
