一、数组基本用法

1.1、什么是数组

数组本质上就是让我们能 “批量” 创建相同类型的变量
也可以说是存储一组相同数据类型的数据的集合

如:
如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b
如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;
但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建

注意事项: 在 Java 中, 数组中包含的变量必须是 相同类型

1.2、创建数组

基本语法
创建数组的三种方式：

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

代码示例：

public static void main(String[] args) {//动态初始化，数组里面存放了 1 2 3 4 int[] array2 = new int[]{1, 2, 3, 4};//静态初始化，数组里面存放了 1 2 3 4int[] array1 = {1, 2, 3, 4};//这里只是没有初始化数组的内容，默认里面存放的是5个0int[] array3 = new int[5];}

而且对数组有一定了解的人，都知道数组的每个元素都有一个下标（从0开始），方便去寻找寻找元素.

1.3、总结

一套讲解下来，你会发现在Java中 是这么来表达一个数组：int[] array
其实数组也可以写成
int arr[] = {1, 2, 3};
和 C 语言一样. 但是我们还是更推荐写成 int[] arr 的形式. int和 [] 是一个整体.，因此，其实在Java中数组的写法更为准确。

但是不能像C语言一样这样写 int array[10] = {0};
我们前面也看到了，在创建一个数组时，[ ]里是不能有具体数字的存在，除了第三种方法，其它的，一律不行

1.4、数组的使用

1.4.1、代码示例: 获取长度 ， 访问元素

public static void main(String[] args) {int[] array = new int[]{1,2,3,4,5,6};//计算数组的长度int len = array.length;System.out.println("数组的长度为：" + len);//访问数组的元素System.out.println(array[1]);System.out.println(array[2]);System.out.println(array[3]);}

1.4.2、代码示例: 下标越界

public static void main(String[] args) {int[] array = new int[]{1,2,3,4,5,6};System.out.println(array[-1]);}

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

1.4.3、码示例: 遍历数组

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

public static void main(String[] args) {int[] array = new int[]{1,2,3,4,5,6};for(int i = 0; i < array.length; i++){System.out.print(array[i] + " ");}}

1.1.4、代码示例: 使用 for-each 遍历数组

public static void main(String[] args) {int[] array = {1, 2, 3, 4, 5};for(定义一个 与数组元素类型 相同的变量 : 数组名)什么意思呢？
for-each(增强for循环)， 数组名部分，表示的意思 遍历访问数组的元素
将访问的元素赋给 冒号前面 定义的 与数组元素类型相同 的变量我们只需要 将该变量每次得到的元素值，打印就能做到不依靠元素下标，遍历打印数组所有元素for (int x: array) {System.out.print(x + " ");}}

那么 for 和 foreach 两者有什么区别？
最大的区别在于，for是可以拿到元素下标，而foreach拿不到元素下标
for循环用到的地方很多，但是foreach呢？
当我们只需要元素的值时，就是使用foreach，
当我们还需要元素的下标时，就用for。
for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错

注意事项

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

代码实例3（借助Java的操作数组的工具类 Arrays）

public static void main(String[] args) {int[] array = {1, 2, 3, 4, 5, 6};String str = Arrays.toString(array);System.out.println(str);}

Arrays工具类还有很多的方法：Arrays工具类的常用方法

二、数组作为方法的参数

首先要说一下 jvm内存模型

public static void main(String[] args) {int[] array = {1, 2, 3, 4, 5, 6};String str = Arrays.toString(array);System.out.println(str);}

public static void main(String[] args) {int[] array = null;System.out.println(array.length);}

2.1、基本用法

2.1.1、代码示例: 打印数组内容

/*** 打印数组的内容* @param array 数组名*/public static void printf(int[] array){for (int i = 0; i < array.length; i++) {System.out.print(array[i] + " ");}}public static void main(String[] args) {int[] array = {1, 2, 3, 4, 5, 6};printf(array);}

2.2.2、通过下面题目更好的理解引用类型

下面两题的输出结果是什么？
题目1：

public static void main(String[] args) {int[] array = {1,2,3,4,5};func1(array);System.out.println(Arrays.toString(array));// 图 18}public static void func1(int[] array){array = new int[]{11,2,13,4,51};}

题目2：

public static void main(String[] args) {int[] array = {1,2,3,4,5};func2(array);System.out.println(Arrays.toString(array));}public static void func2(int[] array){array[0] = 99;}

2.2.3、一个引用 是否 能同时 指向 多个对象？

public static void main(String[] args) {int[] array1 = new int[]{1,2,3,4,5};array1 = new int[10];array1 = new int[2];array1 = new int[4];}

答案是不能，如果前面认真看了，就该知道此时的array1，存储的地址，已经被改变（array是一个局部变量，意味着存的值是可以被改变的），现在存的是 new int[4] 的这个对象的地址， 而不是说，存几个对象的地址。

一个引用只能指向一个对象（一个引用只能保存一个对象的地址）

2.2.4、引用 就一定在栈上吗？

答案是不一定的，因为一个变量在不在栈上，是你变量的性质决定的
如果你的引用是一个局部变量，那就一定在栈上 实例成员变量那就不一定了。（先告诉你们有这个概念，等后面讲到成员变量时再说）

局部变量的引用保存在栈上, new 出的对象保存在堆上.

堆的空间非常大, 栈的空间比较小.    因为 堆 是整个 JVM 共享一个,
而 栈 每个线程具有一份 (一个 Java 程序中可能存在多个栈）

三、数组作为方法的返回值

3.1、代码示例: 写一个方法, 将数组中的每个元素都 * 2（直接修改原数组）

public static void main(String[] args) {//代码示例: 写一个方法, 将数组中的每个元素都 * 2// 直接修改原数组int[] array = {1,2,3,4,5};mul2(array);System.out.println(Arrays.toString(array));}public static void mul2(int[] array){for(int i = 0; i < array.length; i++){array[i] = array[i] * 2;}}

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

3.2、代码示例: 写一个方法, 将数组中的每个元素都 * 2（将原数组拷贝一份，改变拷贝的数组，并返回拷贝的数组）

public static void main(String[] args) {//代码示例: 写一个方法, 将数组中的每个元素都 * 2// 直接修改原数组int[] array = {1,2,3,4,5};int[] ret = mul2(array);System.out.println("原来的数组：" + Arrays.toString(array));System.out.println("改变后的数组：" + Arrays.toString(ret));}public static int[] mul2(int[] array){int[] str = new int[array.length];for(int i = 0; i < array.length; i++){str[i] = array[i] * 2;}return str;}

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

四、数组练习

4.1、模拟实现 ToString方法 ，数组转字符串

这是java自带的ToString方法

模拟实现：

public static void main(String[] args) {int[] array = {1,2,3,4,5};System.out.println(mytoString(array));//System.out.println(Arrays.toString(array));}public static String mytoString(int[] array){String str = "[";if(array.length == 0){return "[]";}for(int i = 0; i < array.length; i++){str = str + array[i];if(i != array.length - 1){str = str + ",";}}str = str + "]";return str;}

4.2、数组拷贝 代码示例 拷贝整个数组

拷贝整个数组

public static void main(String[] args) {int[] array = {1,2,3,4,5};int[] str = Arrays.copyOf(array, array.length);System.out.println(Arrays.toString(str));}

模拟实现mycopyDf

public static void main(String[] args) {int[] array = {1,2,3,4,5};int[] str = mycopyDf(array, array.length);//int[] str = Arrays.copyOf(array, array.length);System.out.println(Arrays.toString(str));}public static int[] mycopyDf(int[] array, int len){int[] str = new int[len];for (int i = 0; i < len; i++){str[i] = array[i];}return str;}

4.3、数组拷贝 代码示例 拷贝某个范围

拷贝某个范围

public static void main(String[] args) {int[] array = {1,2,3,4,5};int[] str = Arrays.copyOfRange(array, 2, 4);System.out.println(Arrays.toString(str));}

4.4、找数组中的最大元素

给定一个整型数组, 找到其中的最大元素 (找最小元素同理)

public static void main(String[] args) {//找数组中的最大元素int[] array = {3,5,1,40,55,20,80};int max = printMax(array);System.out.println(max);}public static int printMax(int[] array){int max = array[0];for(int i = 0; i < array.length - 1; i++){if(max > array[i+1]){max = array[i];}else {max = array[i + 1];}}return max;}

类似于 “打擂台” 这样的过程. 其中 max 变量作为 擂台, 比擂台上的元素大, 就替换上去, 否则就下一个对手

4.5、求数组中元素的平均值

public static void main(String[] args) {//求数组中元素的平均值int[] array = {3,5,1,40,55,20,80};double scr = avgSum(array);System.out.println(scr);}public static double avgSum(int[] array){double sum = 0.0;for(int i = 0; i < array.length; i++){sum = sum + array[i];}return sum / array.length;}

4.6、查找数组中指定元素(顺序查找)

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置

public static void main(String[] args) {//查找数组中指定元素(顺序查找)//返回下标，没有返回-1int[] array = {3,5,1,40,55,20,80};int k = 1;int ret = func(k,array);System.out.println("下标为：" + ret);}public  static int func(int k , int[] array){for(int i = 0; i < array.length; i++){if(k == array[i]){return i;}}return -1;}

4.7、 查找数组中指定元素(二分查找)

针对有序数组, 可以使用更高效的二分查找.
啥叫有序数组?
有序分为 “升序” 和 “降序”
如 1 2 3 4 , 依次递增即为升序.
如 4 3 2 1 , 依次递减即为降序.
以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找.

public static void main(String[] args) {//二分查找int[] array = {1,2,3,4,5,6,7,8,9,10};//k 为要查找的数,找到返下标，找不到返回-1int k = 11;int ret = func(k,array);System.out.println(ret);}public static int func(int k, int[] array){int left = 0;int right = array.length - 1;while(left <= right){int mid = (left + right) / 2;if(array[mid] > k){//中间值 > k，说明 k 是在中间值的左边//此时的右值应该是中间值right = mid - 1;}else if(array[mid] < k){//中间值 < k，说明 k 是在中间值的右边//此时的左值应该是中间值left = mid + 1;}else{return mid;}}return -1;}

4.8、检查数组的有序性

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

public static void main(String[] args) {//给定一个整型数组, 判断是否该数组是有序的(升序)int[] array = {1,2,3,4,10,6,7,8,9,10};boolean b = funcSce(array);System.out.println(b);}public static boolean funcSce(int[] array){for(int i = 0; i < array.length - 1; i++){if(array[i] > array[i+1]){return false;}}return true;}

4.9、数组排序(冒泡排序)

public static void main(String[] args) {//数组排序(冒泡排序)int[] array = {10,9,8,7,4,5,6,2,3,1};int[] ret = funcMao(array);System.out.println(Arrays.toString(ret));}public static int[] funcMao(int[] array){//i 表示比较多少对for(int i = 0; i < array.length-1; i++){//j 表示比较的趟数for(int j = 0; j < array.length - 1 - i ; j++){if(array[j] > array[j+1]){int tmp = array[j];array[j] = array[j+1];array[j+1] = tmp;}}}return array;}

4.10、数组逆序

给定一个数组, 将里面的元素逆序排列.
思路
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可.

public static void main(String[] args) {//数组逆序int[] array = {1,2,3,4,10,6,7,8,9,10};int[] ret = funcNixu(array);System.out.println(Arrays.toString(ret));}public static int[] funcNixu(int[] array){int left = 0;int right = array.length - 1;while(left <= right){int tmp = array[left];array[left] = array[right];array[right] = tmp;left++;right--;}return array;}

4.11、数组数字排列

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分
例如 {1, 2, 3, 4}
调整后得到 {4, 2, 3,1}

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

public static void main(String[] args) {//给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分int[] array = {1,2,3,4,10,6,7,8,9,10};int[] ret = swapNum(array);System.out.println(Arrays.toString(ret));}public static int[] swapNum(int[] array){int left = 0;int right = array.length - 1;while(left <= right){if(array[left] % 2 == 0){left++;}else if(array[right] % 2 != 0){right--;}else {int tmp = array[left];array[left] = array[right];array[right] = tmp;}}return array;}

五、 二维数组

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

5.1、基本语法

二维数组的创建

基本语法1

	数据类型[][] 数组名 = { 初始化数据 }

基本语法2

	 数据类型[][] 数组名 = new 数据类型[][]{ 初始化数据 }

基本语法3

	数据类型[][] 数组名 = new 数据类型[行数][列数]

public static void main(String[] args) {//和一位数组一样的定义方式//直接初始化数据内容int[][] array1 = {{1,2,3},{4,5,6}};//动态初始化int[][] array2 = new int[][]{{1,2,3},{4,5,6}};//静态初始化,没有初始化内容，默认为0int[][] array3 = new int[2][3];}

5.2、二维数组的打印

for循环打印

public static void main(String[] args) {int[][] array1 = {{1,2,3},{4,5,6}};for (int i = 0; i < array1.length; i++) {for (int j = 0; j < array1[i].length; j++) {System.out.print(array1[i][j] + " ");}System.out.println();}}

for - each 打印数组

public static void main(String[] args) {int[][] array1 = {{1,2,3},{4,5,6}};for (int[] str : array1) {for (int n: str) {System.out.print(n + " ");}System.out.println();}}

使用java自带的函数来打印二维数组（deepToString）

在前面，我们使用了 Arrays.toString，将数组转换的字符串输出

二维数组也有对应的 方法： Arrays.deepToString(数组名)

public static void main(String[] args) {int[][] array1 = {{1,2,3},{4,5,6}};System.out.println(Arrays.deepToString(array1));}

5.3、一种特别的二维数组（不规则的二维数组）

第一种情况：

public static void main(String[] args) {int[][] array = {{1,2,},{4,5,6}};for (int i = 0; i < array.length; i++) {for (int j = 0; j < array[i].length; j++) {System.out.print(array[i][j] + " ");}System.out.println();}}

第二种情况：不规则二维数组
二维数组可以省略列，不能省略行

public static void main(String[] args) {int[][] array = new int[2][];//手动给 二维数组 赋值//第一行有3个元素array[0] = new int[3];//第二行有4个元素array[1] = new int[4];for (int i = 0; i < array.length; i++) {for (int j = 0; j < array[i].length; j++) {System.out.print(array[i][j] + " ");}System.out.println();}}