1 数组概述

1.1 数组的理解

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

1.2 数组相关的概念

  • 数组名
  • 元素
  • 角标、下标、索引
  • 数组的长度：元素的个数

1.3 数组的特点

  1. 数组是有序排列的
  2. 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
  3. 创建数组对象会在内存中开辟一整块连续的空间
  4. 数组的长度一旦确定，就不能修改。


1.4 数组的分类

  • 按照维数：一维数组、二维数组、。。。
  • 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

2. 一维数组

【关注点】
① 一维数组的声明和初始化
② 如何调用数组的指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值
⑥ 数组的内存解析

2.1 一维数组的声明与初始化

  1. // 1. 一维数组的声明和初始化
  2. int[] ids;//声明
  4. // 1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
  5. ids = new int[]{1001,1002,1003,1004};
  7. // 1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
  8. String[] names = new String[5];
  10. //错误的写法：
  11. // int arr[5];//错误的声明方式，声明数组时不能指定其长度
  12. // int[] arr1 = new int[];
  13. // int[5] arr2 = new int[5];
  14. // int[] arr3 = new int[3]{1,2,3};
  16. //也是正确的写法：（但是不推荐）
  17. int arr[];//方括号也可以放在后面
  18. int[] arr4 = {1,2,3,4,5};//类型推断
  20. //总结：数组一旦初始化完成，其长度就确定了。

2.2 通过角标的方式调用数组指定位置的元素

  1. //2.如何调用数组的指定位置的元素:通过角标的方式调用。
  2. //数组的角标（或索引）从0开始的，到数组的长度-1结束。
  3. String[] names = new String[5];
  4. names[0] = "王铭";
  5. names[1] = "王赫";
  6. names[2] = "张学良";
  7. names[3] = "孙居龙";
  8. names[4] = "王宏志";//charAt(0)
  9. // names[5] = "周扬";//错误

2.3 如何获取数组的长度

  1. //3.如何获取数组的长度。
  2. //属性:length
  3. System.out.println(names.length);//5
  4. System.out.println(ids.length);

2.4 如何遍历数组

  1. for(int i = 0;i < names.length;i++){
  2.     System.out.println(names[i]);
  3. }

2.5 数组元素的默认初始化值

image.png
注意：char初始化为0是ASCII值0，而非字符‘0’

2.6 数组的内存解析

image.png
image.png

3. 二维数组和多维数组

3.1 二维数组的使用

【理解】

  • 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
  • 其实，从数组底层的运行机制来看，其实没有多维数组。

【关注点】
① 二维数组的声明和初始化
② 如何调用数组的指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内层数组的元素

  • int[][] arr = new int[4][3];
  • 外层元素：arr[0],arr[1]等
  • `内层元素：arr[0][0],arr[1][2]等

`

针对于初始化方式一：比如：int[][] arr = new int[4][3];

  • **外层**元素的初始化值为：**地址值**
  • **内层**元素的初始化值为：**与一维数组初始化情况相同**

针对于初始化方式二：比如：int[][] arr = new int[4][];

  • **外层**元素的初始化值为：**null**
  • **内层**元素的初始化值为：**不能调用，否则报错。**

image.png
image.png

  1. // 1.二维数组的声明和初始化
  2. int[] arr = new int[]{1,2,3};//一维数组
  4. // 静态初始化
  5. int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
  7. // 动态初始化1
  8. String[][] arr2 = new String[3][2];
  10. // 动态初始化2
  11. String[][] arr3 = new String[3][];
  13. // 错误的情况 
  14. // String[][] arr4 = new String[][4];
  15. // String[4][3] arr5 = new String[][];
  16. // int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
  18. // 也是正确的写法：(不推荐)
  19. int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
  20. int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
  22. // 2.如何调用数组的指定位置的元素
  23. System.out.println(arr1[0][1]);//2
  24. System.out.println(arr2[1][1]);//null
  26. // 3.获取数组的长度
  27. System.out.println(arr4.length);//3
  28. System.out.println(arr4[0].length);//3
  29. System.out.println(arr4[1].length);//4
  31. // 4.如何遍历二维数组
  32. for(int i = 0;i < arr4.length;i++){
  33.     for(int j = 0;j < arr4[i].length;j++){
  34.         System.out.print(arr4[i][j] + "  ");
  35.     }
  36.     System.out.println();
  37. }

3.2 二维数组的内存解析

image.png
image.png
image.png

  1. int[][] arr1 = new int[2][]; 
  2. System.out.println(arr1); // [[I@4cdf35a9
  3. System.out.println(arr1[0]); // null(没有地址)
  4. // System.out.println(arr1[0][0]);//报错
  6. int[][] arr2 = new int[2][3];
  7. System.out.println(arr2); // [[I@53e25b76
  8. System.out.println(arr2[0]); // [I@73a8dfcc
  9. System.out.println(arr2[0][0]); // 0 （int型数据的默认值）
  11. String[][] arr3 = new String[2][];
  12. System.out.println(arr3); // [[Ljava.lang.String;@ea30797
  13. System.out.println(arr3[0]); // null（没有地址）
  14. // System.out.println(arr3[0][0]);//报错
  16. String[][] arr4 = new String[2][3];
  17. System.out.println(arr4); // [[Ljava.lang.String;@7e774085
  18. System.out.println(arr4[0]); // [Ljava.lang.String;@3f8f9dd6
  19. System.out.println(arr4[0][0]); // null （引用数据类型的默认值）

4 数组中常见的算法

4.1 数组元素的赋值——杨辉三角

image.png

  1. //1.声明并初始化二维数组
  2. int[][] yangHui = new int[10][];
  4. //2.给数组的元素赋值
  5. for(int i = 0;i < yangHui.length;i++){
  6.     // 2.1初始化数组
  7.     yangHui[i] = new int[i + 1];
  8.     // 2.2给首末元素赋值
  9.     yangHui[i][0] = yangHui[i][i] = 1;
  10.     // 2.3给每行的非首末元素赋值
  11.     for(int j = 1;j < yangHui[i].length - 1;j++){
  12.         yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
  13.     }
  14. }
  16. //3.遍历二维数组
  17. for(int i = 0;i < yangHui.length;i++){
  18.     for(int j = 0;j < yangHui[i].length;j++){
  19.         System.out.print(yangHui[i][j] + "  ");
  20.     }
  21.     System.out.println();
  22. }

4.2 随机生成数值互不相同的数组

image.png

  1.         int[] arr = new int[10];
  2.         // 随机从[10,99]范围内赋值，且能保证不重复
  3.         for(int i = 0; i < arr.length; i++) {
  4.             arr[i] = (int)(Math.random() * (99-10+1) +10); 
  5.             for(int j = 0; j < i; j++) {
  6.                 if(arr[j] == arr[i]) {
  7.                     i--;  // 如果后面的值与前面的值相同就重新赋值
  8.                     break;
  9.                 }
  10.             }
  11.         }
  12.         int max = arr[0];
  13.         int min = arr[0];
  14.         int sum = 0;
  15.         for(int i = 0; i < arr.length; i++) {
  16.             if(max < arr[i]) {
  17.                 max = arr[i];
  18.             }
  19.             if(min > arr[i]) {
  20.                 min = arr[i];
  21.             }
  22.             sum += arr[i];
  23.             System.out.print(arr[i] + " ");
  24.         }
  25.         System.out.println("\\n" + "最大值为：" + max + "最小值为：" +
  26.         min + "总和为" + sum + "平均值为：" + (sum/arr.length));

4.3 数组的复制

image.png

  1.         int[] array1, array2;
  2.         array1 = new int[]{2,3,5,7,11,13,17,19};
  4.         //显示array1的内容
  5.         for(int i = 0;i < array1.length;i++){
  6.             System.out.print(array1[i] + "\\t");
  7.         }
  9.         //赋值array2变量等于array1
  10.         //不能称作数组的复制。
  11.         array2 = array1;
  13.         //修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
  14.         for(int i = 0;i < array2.length;i++){
  15.             if(i % 2 == 0){
  16.                 array2[i] = i;
  17.             }
  18.         }
  19.         System.out.println();
  21.         //打印出array1
  22.         for(int i = 0;i < array1.length;i++){
  23.             System.out.print(array1[i] + "\\t");
  24.         }


image.png

  1.         int[] array1,array2;
  2.         array1 = new int[]{2,3,5,7,11,13,17,19};
  3.         //显示array1的内容
  4.         for(int i = 0;i < array1.length;i++){
  5.             System.out.print(array1[i] + "\\t");
  6.         }
  7.         //数组的复制:
  8.         array2 = new int[array1.length];
  9.         for(int i = 0;i < array2.length;i++){
  10.             array2[i] = array1[i];
  11.         }
  12.         //修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
  13.         for(int i = 0;i < array2.length;i++){
  14.             if(i % 2 == 0){
  15.                 array2[i] = i;
  16.             }
  17.         }
  18.         System.out.println();
  19.         //打印出array1
  20.         for(int i = 0;i < array1.length;i++){
  21.             System.out.print(array1[i] + "\\t");
  22.         }

image.png

4.4 数组的反转

  1.         String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
  3.         //数组的反转
  5.         //方法一：
  6.         for(int i = 0;i < arr.length / 2;i++){
  7.             String temp = arr[i];
  8.             arr[i] = arr[arr.length - i -1];
  9.             arr[arr.length - i -1] = temp;
  10.         }
  12.         //方法二：
  13.         for(int i = 0,j = arr.length - 1;i < j;i++,j--){
  14.             String temp = arr[i];
  15.             arr[i] = arr[j];
  16.             arr[j] = temp;
  17.         }
  19.         //遍历
  20.         for(int i = 0;i < arr.length;i++){
  21.             System.out.print(arr[i] + "\\t");
  22.         }
  23.         System.out.println();

4.5 数组的查找（线性查找、二分法查找）

  1.         // 一、线性查找：
  3.         String[] arr1 = new String[]{"JJ","DD","MM","BB","GG","AA"};
  4.         String dest = "BB"; // 待查找值
  5.         boolean isFlag = true;
  6.         for(int i = 0;i < arr1.length;i++){
  7.             if(dest.equals(arr1[i])){
  8.                 System.out.println("找到了指定的元素，位置为：" + i);
  9.                 isFlag = false;
  10.                 break;
  11.             }
  12.         }
  13.         if(isFlag){
  14.             System.out.println("很遗憾，没有找到哦！");
  15.         }
  17.         // 二、二分法查找：(熟悉)
  18.         // 前提：所要查找的数组必须有序。
  20.         int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
  21.         int des = -34; // 待查找值
  22.         int head = 0; // 初始的首索引
  23.         int end = arr2.length - 1; // 初始的末索引
  24.         boolean flag = true;
  26.         while(head <= end){
  27.             int middle = (head + end)/2; // 中间位置
  28.             if(des == arr2[middle]){
  29.                 System.out.println("找到了指定的元素，位置为：" + middle);
  30.                 flag = false;
  31.                 break;
  32.             }else if(arr2[middle] > des){
  33.                 end = middle - 1;
  34.             }else{
  35.                 head = middle + 1;
  36.             }
  37.         }
  38.         if(flag){
  39.             System.out.println("很遗憾，没有找到的啦！");
  40.         }

4.6 数组的排序

4.6.1 排序算法概述

image.png
image.png
image.png
image.png
image.png
image.png

image.png

4.6.2 冒泡排序

image.png

  1.         //冒泡排序
  2.         int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
  3.         int temp;
  5.         //n个元素只需要循环n-1轮
  6.         for(int i = 0; i < arr.length - 1; i++) {
  7.             //每次对相邻元素比较，数字大的放后面
  8.             //一轮过后，最后一个数最大，下一轮比较时最后一个不用再比较
  9.             for(int j = 0; j < arr.length - 1 - i; j++) {
  10.                 if(arr[j] > arr[j+1]) {
  11.                     temp = arr[j];
  12.                     arr[j] = arr[j+1];
  13.                     arr[j+1] = temp;
  14.                 }
  15.             }
  16.         }
  18.         for(int i = 0; i < arr.length; i++) {
  19.             System.out.print(arr[i] + " ");
  20.         }

4.6.3 快速排序

image.png
image.png
image.png

5. Arrays工具类与数组的常见异常

5.1 常用方法

image.png

  1.         //1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
  2.         int[] arr1 = new int[]{1,2,3,4};
  3.         int[] arr2 = new int[]{1,3,2,4};
  4.         boolean isEquals = Arrays.equals(arr1, arr2);
  5.         System.out.println(isEquals);
  7.         //2.String toString(int[] a):输出数组信息。
  8.         System.out.println(Arrays.toString(arr1));
  10.         //3.void fill(int[] a,int val):将指定值填充到数组之中。
  11.         Arrays.fill(arr1,10);
  12.         System.out.println(Arrays.toString(arr1));
  13.         //4.void sort(int[] a):对数组进行排序。
  14.         Arrays.sort(arr2);
  15.         System.out.println(Arrays.toString(arr2));
  17.         //5.int binarySearch(int[] a,int key)
  18.         // 二分查找的前提是排序好的数据
  19.         int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
  20.         int index = Arrays.binarySearch(arr3, 210);
  21.         if(index >= 0){
  22.             System.out.println(index);
  23.         }else{
  24.             System.out.println("未找到");
  25.         }

5.2 数组的常见异常

image.png

  1.         //1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
  3.         int[] arr = new int[]{1,2,3,4,5};
  4.         for(int i = 0;i <= arr.length;i++){
  5.             System.out.println(arr[i]);
  6.         }
  7.         System.out.println(arr[-2]);
  8.         System.out.println("hello");//一旦异常后面的就不会再执行！
  10.         //2. 空指针异常：NullPointerException
  12.         //情况一：
  13.         int[] arr1 = new int[]{1,2,3};
  14.         arr1 = null;
  15.         System.out.println(arr1[0]);
  16.         //情况二：
  17.         int[][] arr2 = new int[4][];
  18.         System.out.println(arr2[0][0]);
  19.         //情况三：
  20.         String[] arr3 = new String[]{"AA","BB","CC"};
  21.         arr3[0] = null;
  22.         System.out.println(arr3[0].toString());