1、数组的概述

1.1 定义

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

1.2 数组的相关概念

数组名
元素
数组的索引/下标
数组的长度：元素的个数

1.3 数组的特点

(1) 数组是有序排列的；
(2) 数组本身属于引用数据类型，数组的元素是基本数据类型或引用数据类型；
(3) 数组在内存中占用一块连续的内存空间，数组名引用的是这块连续空间的首地址；
(4) 数组在内存中长度一旦确定，不可以修改。

1.4 数组的分类*

（1）按照维数：一维数组、二维数组、……
（2）按照数组元素的类型：基本数据类型的数组、引用数据类型的数组

2、一维数组的使用

2.1 声明和初始化

声明是指出数组元素是什么类型的。
声明方式：type var[] 或 type[] var，声明的时候中括号 [] 放在类型后面或者数组名称后面都没有问题。
数组声明的时候不能指定其长度（数组元素的值），例如： int a[5]; //非法
初始化两种方式：静态初始化和动态初始化。
静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
动态初始化 ：数组声明且为数组元素分配空间与赋值的操作分开进行。

int[] ids;//声明和初始化分开进行
//静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004};
//动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];//这里声明和初始化同时进行
names[0] = “钱学森”;
names[1] = “邓稼先”;
names[2] = “袁隆平”;

注意:
（1）声明和初始化可以分步进行也可以同步进行。
（2）不管是动态还是静态初始化，数组的长度就确定了，不能更改。
（3）静态初始化时候的 new int 语句可以省略，也是正确的可以编译通过的，例

String names1[] = {“李四光”,“茅以升”,“华罗庚”
}

2.2 调用数组的指定位置的元素

数组元素的引用方式：数组名[数组元素下标]
数组的角标（索引）是从 0 开始的，到数组的长度 N-1 结束
int a[]=new int[3]：可引用的数组元素为a[0]、a[1]、a[2]
定义并用运算符 new 为之分配空间后，才可以引用数组中的每个元素，即new之后，堆空间中才会为数组元素赋默认值。

2.3 获取数组的长度

每个数组都有一个属性 length 指明它的长度，例如：a.length指明数组a的长度(元素个数)
数组一旦初始化，其长度是不可变的

//属性：length
System.out.println(names.length);   //3
System.out.println(ids.length);     //4

2.4 遍历数组

使用 for 循环，同时需要用到数组长度属性作为循环条件。

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

2.5 数组元素的默认初始化值（对动态初始化来说的）

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。

注意：

System.out.println("*******************");
boolean[] arr1 = new boolean[5];
System.out.println(arr1[0]);    //boolean型的默认值是falseSystem.out.println("*******************");
String[] arr2 = new String[5];
System.out.println(arr2[0]);    //默认值是null

2.6 数组的内存解析

放在方法中的变量都是局部变量，局部变量放置在栈空间中
new 出来的结构都放置在堆当中，堆中的元素地址确定之后，将第一个元素的地址赋给局部变量，作为栈中局部变量 arr 的地址
不管是静态初始化还是动态初始化，初始的时候堆中创建的结构变量中都赋值 0/null
然后静态初始化直接将元素赋新值，动态初始化后面进行赋值
程序举例1：

public class Test{public static void main(String args[]){//1、为s分配栈内存int[] s;            //2、为数组元素开辟空间后将地址值赋给栈内的s，并为他们赋默认值。                s = new int[10];                   // int[] s=new int[10];// 基本数据类型数组在显式赋值之前，// Java会自动给他们赋默认值。for ( int i=0; i<10; i++ ) {//3、为数组元素赋值，即把相应地址之内储存的数值进行修改。s[i] =2*i+1;                   System.out.println(s[i]);}}
}

该程序的内存分布图示：

6. 程序举例2：

2.7 课后练习题目

1、练习1（会读程序）
程序：

package com.atguigu.exer;public class ArrayTest {public static void main(String[] args) {int[] arr = new int[] { 8, 2, 1, 0, 3 };int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };String tel = "";for (int i = 0; i < index.length; i++) {tel += arr[index[i]];}System.out.println(" 联系方式：" + tel);//18013820100}
}

2、练习2

程序：

package com.atguigu.exer;import java.util.Scanner;//导包快捷键ctrl+shift+o；/*从键盘读入学生成绩，找出最高分，
并输出学生成绩等级。
成绩>=最高分-10    等级为’A’
成绩>=最高分-20    等级为’B’
成绩>=最高分-30    等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，
存放学生成绩。*/
public class ArrayTest1 {public static void main(String[] args) {// 1.使用scanner读取学生个数numSystem.out.println("请输入学生总人数：");Scanner scanner = new Scanner(System.in);int number = scanner.nextInt();// 2.创建一个num长的数组score放置学生的成绩，动态初始化int[] score = new int[number];// 3.for循环内scanner输入学生成绩并赋值给score数组System.out.println("请输入" + number + "个学生成绩：");for (int i = 0; i < score.length; i++) {score[i] = scanner.nextInt();}// 4.通过排序算法找出最高赋值给max？如何选择效率最高的排序算法//这一次for循环遍历可以和上一个for循环遍历合并，减少程序复杂度int maxScore = 0;for (int i = 0; i < score.length; i++) {if (score[i] > maxScore) {maxScore = score[i];}}System.out.println("最高分是：" + maxScore);// 5.计算num个学生成绩与max的差值，if-else判断在哪一等级，并输出等级和成绩
/*      for (int i = 0; i < score.length; i++) {if (maxScore - score[i] <= 10) {System.out.println("第" + (i + 1) + "个学生的成绩为" + score[i] + "，等级为A");} else if (maxScore - score[i] <= 20) {System.out.println("第" + (i + 1) + "个学生的成绩为" + score[i] + "，等级为B");} else if (maxScore - score[i] <= 30) {System.out.println("第" + (i + 1) + "个学生的成绩为" + score[i] + "，等级为C");} else {System.out.println("第" + (i + 1) + "个学生的成绩为" + score[i] + "，等级为D");}}*///宋老师版本char level;for (int i = 0; i < score.length; i++) {if (maxScore - score[i] <= 10) {level = 'A';} else if (maxScore - score[i] <= 20) {level = 'B';} else if (maxScore - score[i] <= 30) {level = 'C';} else {level = 'D';}System.out.println("第" + (i + 1) + "个学生的成绩为" + score[i] + "，等级为" + level);}}
}

注意:

sout 运行时间很长，所以尽量不要在循环中使用。
这里程序不严谨，默认输入成绩在0-100之间。

3、多维数组的使用（以二维数组为例）

3.1 理解

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

3.2 声明和初始化

静态初始化有一种方式，动态初始化有两种方式，下方的程序举例，声明和初始化同时进行。
对第二种动态初始化方式，可以看出二维数组的内层数组可以稍后初始化，但不是说不用初始化，也就是必须经过 new 在堆空间中开辟空间后才能使用。

3. 程序举例：

//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][]; //也是正确的
int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};//两[]的位置可以变
int arr5[][] = {{1,2,3},{4,5},{6,7,8}};//当声明和初始化在一行的时候，后面的new int[][]可以省略。

注意:
（1）声明的时候两个 [][] 位置可以放置在类型后面，也可以放置在数组名称后面。
（2）对于静态初始化，当声明和初始化在一行的时候，后面的 new int[][] 可以省略，也是正确的，编译可以通过。

3.3 调用数组指定位置的元素

int[][] arr = new int[3][4];//声明和初始化

外层元素：arr[0]，arr[1]等
内层元素：arr[0][1]，arr[1][2]等

若运用第二种动态初始化方式，即内层数组结构还未被创建的时候内层数组元素是不能调用的，外层数组元素默认值为null。

System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null
//System.out.println(arr3[0][1]);
//报错:NullPointerException，空指针

3.4 数组的长度

外层数组：arr.length
内层数组：arr[i].length

System.out.println(arr4.length); //3
System.out.println(arr4[0].length); //3
System.out.println(arr4[1].length); //2

3.5 遍历数组

遍历一维数组需要一个 for 循环，遍历二维数组需要两个 for 循环嵌套。
这里外层循环条件为外层数组长度，内层循环为内层循环长度。

for(int i = 0;i < arr4.length;i++){for(int j = 0;j < arr4[i].length;j++){System.out.print(arr4[i][j]+"  ");}System.out.println();
}

3.6 数组元素的默认初始化值（动态初始化）

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

外层元素的初始化值为：内层数组首地址值
内层元素的初始化值为：与一维数组初始化情况相同，0/null

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

外层元素的初始化值：null
内层元素的初始化值：不能调用，否则报错空指针

int[][] arr = new int[3][4];
System.out.println(arr[0]);     //[I@15db9742，一维int型@一个地址值
System.out.println(arr[0][0]);  // 0
//System.out.println(arr);      //[[I@6d06d69c，二维数组int型@地址System.out.println("******************");
float[][] arr1 = new float[3][4];
System.out.println(arr1[0]);    //[F@6d06d69c，一维float型@地址值
System.out.println(arr1[0][0]); // 0.0System.out.println("******************");
String[][] arr2 = new String[3][4];
System.out.println(arr2[0]);    //[Ljava.lang.String;@7852e922
System.out.println(arr2[0][0]); // nullSystem.out.println("******************");
double[][] arr3 = new double[3][];
System.out.println(arr3[0]);    // null，数组的类型是引用数据类型，默认值是null

3.7 数组的内存解析

以这段程序为例：
第一句程序：（1）为 arr1 分配栈内存；（2）为 arr1 的元素即外层数组在堆空间中开辟一块连续的内存后，将首地址元素值赋值给 arr1；（3）为 arr1 的元素赋默认值，这里元素内放置数组即引用数据类型，默认值为null。
第二句程序：（1）为 arr1[1] 在堆空间中开辟一块连续的内存后，将首地址元素值赋值给 arr1[1]；（2）为 arr1[1] 的元素赋默认值，这里元素为 int 型，默认值为0；（3）将静态初始化定义的元素分别赋值给对应位置的元素。
第三句程序：（1）为 arr[2] 在堆空间中开辟内存，将新开辟内存的首地址值赋值给 arr[2] ;（2）赋默认值0。
第四句：将30赋值给 arr[2][1]。

3.8 课后练习题

1、练习1

程序：

package com.atguigu.exer;
/** 练习2：见第3章数组p32* * 获取arr数组中所有元素的和。* 提示：使用for的嵌套循环即可。* */
public class ArrayExer1 {public static void main(String[] args) {int[][] arr = new int[][] { { 3, 5, 8 }, { 12, 9 }, { 7, 0, 6, 4 } };int sum = 0; // 记录总和for (int i = 0; i < arr.length; i++) {for (int j = 0; j < arr[i].length; j++) {sum += arr[i][j];}}System.out.println("arr数组中所有元素的和为" + sum);}
}

2、练习2（观察是否可以进行赋值，即是否是同类型数据）

3、练习3（杨辉三角）

程序：

package com.atguigu.exer;
/** 使用二维数组打印一个 10 行杨辉三角。* * 【提示】* 1. 第一行有 1 个元素, 第 n 行有 n 个元* 2. 每一行的第一个元素和最后一个元素都是 1* 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：* yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];*/
public class YanghuiExer {public static void main(String[] args) {//定义杨辉三角出现的行列数int leng = 10;//1.声明并初始化储存杨辉三角的二维数组int[][] yanghui = new int[leng][];//2.给数组的元素赋值，这里我犯了一个天大的错误！！！！！！！！//yanghui[0][0] = 1;    //空指针异常:java.lang.NullPointerException              //System.out.println(yanghui[0][0]);        for(int i = 0;i < yanghui.length;i++){//首先定义所有二维数组的内层数组长度yanghui[i] = new int[i+1];yanghui[i][0] = 1;                          //所有行的第一个数字都是1//System.out.print(yanghui[i][0] + "\t");  //对杨辉三角进行打印//这里对首尾元素赋值的时候循环条件最好是j < yanghui[i].length-1for(int j = 1;j < i;j++){                   yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];//System.out.print(yanghui[i][j] + "\t");//对杨辉三角进行打印}yanghui[i][i] = 1;                           //所有行的最后一个数字都是1//System.out.println(yanghui[i][0]);     //对杨辉三角进行打印}//3.遍历二维数组，对杨辉三角进行打印for(int i = 0;i < yanghui.length;i++){for(int j = 0;j < yanghui[i].length;j++){System.out.print(yanghui[i][j] + "\t");    }System.out.println();}}
}

4、练习4

程序：

package com.atguigu.exer;/** 【拓展之笔试题】* 创建一个长度为6的int型数组，要求数组元素的值都在1-30之间,* 且是随机赋值。同时，要求元素的值各不相同。*/
public class YanghuiExer1 {public static void main(String[] args) {// 创建一个长度为6的int型数组int[] arr = new int[6];// 为该数组赋值for (int i = 0; i < arr.length; i++) {arr[i] = (int) (Math.random() * 30 + 1);// 判断与之前的赋值是否相同for (int j = 0; j < i; j++) {if (arr[i] == arr[j]) {// 一旦发现赋值相等情况，重新赋值并重新开始判断arr[i] = (int) (Math.random() * 30 + 1);j = 0;}}}// 遍历数组for (int ii = 0; ii < arr.length; ii++) {System.out.println(arr[ii]);}}
}

4、数组中涉及到的常见算法

4.1 数组元素的赋值（杨辉三角、回型数）

1、杨辉三角（见3.8课后练习题练习3）
2、回型数

程序（自己写的）：以数组下标判断是否到头
注：

借鉴尚硅谷的，设置一个循环，以有多少个数为循环结束标志（没想到）。
回型数有四个走位，所以不能单纯的嵌套循环实现，很明显要分四种情况。

package com.atguigu.exer;
import java.util.Scanner;
/** 从键盘输入一个整数（1~20） * 则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。* 例如： 输入数字2，则程序输出： 1 2*                            4 3 *       输入数字3，则程序输出： 1 2 3 *                            8 9 4 *                            7 6 5 *       输入数字4， 则程序输出： *       1   2   3   4 *       12  13  14  5 *       11  16  15  6 *       10   9  8   7*/
public class HuiXingExer {public static void main(String[] args) {Scanner scan = new Scanner(System.in);System.out.println("请输入1-20内的一个整数");int leng = scan.nextInt();// 构造n*n维数组int arr[][] = new int[leng][leng];int s = leng * leng;// 一共有多少个数// 为数组赋值，这里需要设置flag，因为有四次变化// dir=1,right; dir=2,down; dir=3,left; dir=4,up;int dir = 1, i = 0, j = 0;//i表示行，j表示列int flag = leng-1;for (int m = 1; m <= s; m++) {if (dir == 1) {arr[i][j] = m;if(j == flag){dir = 2;i++;j--;}j++;}else if(dir == 2){arr[i][j] = m;  if(i == flag){dir = 3;j--;i--;}i++;}else if(dir ==3){arr[i][j] = m;if(j == (leng-flag-1)){dir = 4;i--;j++;}j--;                }else if(dir == 4){arr[i][j] = m;if(i == (leng-flag)){dir = 1;j++;i++;flag--;}i--;}}//遍历for(int m = 0;m < arr.length;m++){for(int n = 0;n < arr[m].length; n++){System.out.print(arr[m][n] + "\t");}System.out.println();}}
}

程序（尚硅谷）：以是否赋值判断是否到头
注意：

这里 arr[i][j++] = m; 是先赋值再 ++。

class RectangleTest {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("输入一个数字");int len = scanner.nextInt();int[][] arr = new int[len][len];int s = len * len;/** k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上*/int k = 1;int i = 0, j = 0;for (int m = 1; m <= s; m++) {if (k == 1) {if (j < len && arr[i][j] == 0) {arr[i][j++] = m;} else {k = 2;i++;j--;m--;}} else if (k == 2) {if (i < len && arr[i][j] == 0) {arr[i++][j] = m;} else {k = 3;i--;j--;m--;}} else if (k == 3) {if (j >= 0 && arr[i][j] == 0) {arr[i][j--] = m;} else {k = 4;i--;j++;m--;}} else if (k == 4) {if (i >= 0 && arr[i][j] == 0) {arr[i--][j] = m;} else {k = 1;i++;j++;m--;}}}// 遍历for (int m = 0; m < arr.length; m++) {for (int n = 0; n < arr[m].length; n++) {System.out.print(arr[m][n] + "\t");}System.out.println();}}
}

4.2 求数值型数组中元素的最大值、最小值、平均数、总和等

程序：

package com.atguigu.java;
/** 求数值型数组中元素的最大值、最小值、平均数、总和等* * 练习5：* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。* 要求：所有随机数都是两位数。* * 提示；* [0,1) * 90   [0,90) + 10   [10,100)   [10,99]* (int)(Math.random() * 90 + 10)* */
public class ArrayTest1 {public static void main(String[] args) {int leng = 10;int[] arr = new int[leng];//这里如果没有限制随机数的范围，对max，min赋值的时候应该赋值数组中的一个数//max = arr[0];min = arr[0];//然后求最大最小值的循环与赋值的循环分开int max = 0, min = 99, sum = 0;float mean = 0.0f;// 给一维数组赋值随机整数，且所有整数都是两位数for (int i = 0; i < arr.length; i++) {arr[i] = (int) (Math.random() * 90 + 10);System.out.print(arr[i] + " ");sum += arr[i];if (max <= arr[i]) {max = arr[i];}if (min >= arr[i]) {min = arr[i];}}System.out.println();mean = (float) sum / leng;System.out.println("max = " + max + "\tmin = " + min + "\tsum = " + sum + "\tmean = " + mean);}
}

注：

这里初始定义 int max = 0, min = 99; 是在已知随机数的范围是10-99 的情况下，这样可以保证在一个循环内实现。
如果不知道初始范围，最好是定义为数组中的一个数。

4.3 数组的复制、反转、查找(线性查找、二分法查找)

1、数组的复制

程序：

package com.atguigu.exer;public class ArrayExer2 {public static void main(String[] args) {// 声明array1和array2两个变量int[] array1, array2;// array1初始化，每new一次在堆空间中创建一个数组array1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };// 显示array1的内容for (int i = 0; i < array1.length; i++) {System.out.print(array1[i] + "\t");}System.out.println();// 赋值array2变量等于array1// 把array1的地址给了array2，不能称作赋值
//      array2 = array1;// 真正的复制操作array2 = new int[array1.length];for(int i = 0; i < array1.length;i++){array2[i] = array1[i];}// 修改array2中的偶索引元素，使其等于索引值for (int i = 0; i < array2.length; i++) {if (i % 2 == 0) {array2[i] = i;}}// 打印出array1,array1发生了变化！！！for (int i = 0; i < array1.length; i++) {System.out.print(array1[i] + "\t");}System.out.println();}
}

注：

单纯的 array2 = array1; 语句只是将 array1 中存放的地址值赋给了 array2 ，所以 array1 和 array2 指向的是堆内存中的同一快内存，改变 array2 数组的元素就会改变 array1 中的元素。
想要实现对 array1 的复制，需要如下操作，即开辟一块儿和 array1 相同长度的内存空间，然后通过循环将 array1 的值一个一个赋值给 array2：

     array2 = new int[array1.length];for(int i = 0; i < array1.length;i++){array2[i] = array1[i];}

两种情况的内存解析图

2、数组的反转

     for(int i = 0;i < arr.length/2;i++){String tmp = arr[i];arr[i] = arr[arr.length - i - 1]; arr[arr.length - i - 1] = tmp;           }

3、数组的查找（线性查找、二分法查找）
线性查找：从数组第一个元素开始比较，直到找到要找的元素，没有的话，会遍历数组直到最后一个元素。
二分法查找（要求数组已经有顺序，适用性较差）：从数组中间开始查找

package com.atguigu.java;public class ArrayTest2 {public static void main(String[] args) {String[] arr = new String[]{"JJ","DD","GG","MM"};//查找/搜索//线性查找String dest = "GG";boolean isFlag = false;for(int i = 0;i < arr.length;i++){//这里String类型判断用equals，不能直接用==if(dest.equals(arr[i])){System.out.println("找到了指定的元素位置为：" + i);isFlag = true;break;}}if(isFlag == false){System.out.println("很遗憾，没有找到唉！");}//二分法查找：(熟悉即可)//前提：所要查找的数组必须有序。int[] arr2 = new int[]{-98,-32,3,6,34,56,67,445,2323};int dest1 = 35;int head = 0;//初始的首索引int end  = arr2.length - 1;//初始的末索引boolean isFlag1 = false;while(head <= end){int middle = (head + end)/2;if(dest1 == arr2[middle]){System.out.println("找到了指定的元素位置为：" + middle);isFlag1 = true;break;}else if(arr2[middle] > dest1){end = middle - 1;}else{head = middle + 1;}}if(isFlag1 == false){System.out.println("很遗憾，没有找到唉！");}}
}

4.4 数组元素的排序算法

堆排序、归并排序：会说思想
冒泡排序、快速排序：会写程序

详情见（尚硅谷java零基础教程）学习笔记day7/8-数组元素的排序算法

5、Arrays工具类的使用

注：

不要忘记调用工具类包 import java.util.Arrays;
对于上述五个常用的 Arrays 方法，只有3，4返回值类型是 void ，其他的都需要定义一个相同类型的变量来接收，或者直接输出。

程序：

package com.atguigu.java;import java.util.Arrays;
/** java.util.Arrays类即为操作数组的工具类,* 包含了用来操作数组（比如排序和搜索）的各种方法。*/
public class ArraysToolTest {public static void main(String[] args) {//boolean equals(int[] a,int[] b);判断两个数组是否相等。int[] arr1 = new int[]{1,2,3,4};int[] arr2 = new int[]{1,3,2,4};//地址、空数组、长度、数组元素boolean isEquals = Arrays.equals(arr1, arr2);System.out.println(isEquals);//String toString(int[] a);输出数组信息。System.out.println(Arrays.toString(arr1));//void fill(int[] a,int val);将指定值填充到数组之中。Arrays.fill(arr1, 10);System.out.println(Arrays.toString(arr1));//void sort(int[] a);对数组进行排序System.out.println("排序前：" + Arrays.toString(arr2));Arrays.sort(arr2);//底层使用的是快速排序法System.out.println("排序后：" + Arrays.toString(arr2));//int binarySearch(int[] a,int key);对排序后的数组进行二分法检索指定的值。int[] arr3 = new int[]{-98,-32,3,6,34,56,67,445,2323};int index = Arrays.binarySearch(arr3, 56);//System.out.println(index);if(index >= 0){System.out.println(index);}else{System.out.println("未找到指定元素！");}}
}

运行结果:

false
[1, 2, 3, 4]
[10, 10, 10, 10]
排序前：[1, 3, 2, 4]
排序后：[1, 2, 3, 4]
5

6、数组使用中的常见异常

注：

空指针异常，最常见的是多维数组中，内层元素还未初始化，就调用的情况。
一旦程序出现异常，未处理时就终止程序。

（尚硅谷java零基础教程）学习笔记day7/8-数组相关推荐

尚硅谷Java零基础极速入门七天版笔记
Java零基础极速入门文章目录 Java零基础极速入门 1 Java快速入门 1.1计算机语言 1.2 Java语言 1.3 JVM 1.4 环境配置 2 基础语法 2.1 变量 2.2 标识符 2 ...
java objective-c_Objective-C基础教程学习笔记（附录）从Java转向Objective-C
Java接口与Objective-C正式协议类似,因为它们都需要实现一组方法.Java具有抽象类,但Objective-C没有.Java具有类变量,但在Objective-C中,可以使用文件范围内的全 ...
B站尚硅谷HTMLCSS核心基础教程全笔记
/* CSS语法: 结构:选择器+声明块({})选择器:通过选择器可以选中页面中指定的元素,并且将声明块中的应用样式应用到对应的素上.声明块:紧跟在选择器后面,用大括号括起来,实际上是一组一组的名值对 ...
Java零基础入门学习教程（纯干货知识点+视频资源）
Java 是由 Sun Microsystems 在 1995 年首先发布的编程语言和计算平台.Java 是一项用于开发应用程序的技术,可以让 Web 变得更有意思和更实用. 有许多应用程序和 Web ...
适合Java零基础小白学习的Java零基础教程
很多Java零基础小白,在刚刚快入门的时候玩命的学习,玩命的记住Java原理,天天早上五点起床背Java的一些英文词汇,然后遇见一些未知的困难,让自己打到癫狂状态,逐渐迷失自我放弃Java,为了解决这 ...
B站百万播放量Java零基础教程视频（适合Java 0基础，Java初学入门），史上最细Java零基础教学视频
是否还在为学习Java如何入门而烦恼? 是否还在为Java软件如何安装而烦恼? 是否还在找寻着适合零基础的Java视频教程? 动力节点教学总监老杜159集课堂实录Java零基础视频教程,从初学者角度出 ...
黑马程序员最新版JavaWeb基础教程-学习笔记
da@黑马程序员最新版JavaWeb基础教程-学习笔记 day06-HTML&CSS HTML HTML(HyperTest Markup Language):超文本标记语言是一门语言,所有 ...
Uniapp零基础开发学习笔记(5) -组件入门及容器组件使用
Uniapp零基础开发学习笔记(5) -组件入门及容器组件使用按照官网教程学习使用组件,并且重点把容器组件的应用进行了练习. 1.官网关于组件的介绍组件是视图层的基本组成单元,是一个单独且可复用的 ...
【程序源代码】每日种草-尚硅谷Java学科全套教程
关键字:<我是种草囤货君.每日种草系列> 资源包正文 | 内容 01 - [概述] "野火烧不尽,春风吹又生",最近小编我的种草欲总是挥之不去,不管别人劝阻还是自我放 ...

（尚硅谷java零基础教程）学习笔记day7/8-数组