目录
- 复习
- 隐藏eclipse中的工程
- 3.2 一维数组的使用：数组元素的引用p10
- 3.2 一维数组的使用：数组元素的默认初始化值p12
- 3.2 一维数组的使用p21
- 3.2 一维数组的使用p22
- 3.3 多维数组的使用p24
- 3.3 多维数组的使用p25
- 引用类型的变量，保存的要么是地址值，要么是null
- 3.3 多维数组的使用p32
- 3.3 多维数组的使用p34
- 随机数
- 3.4 数组中涉及到的常见算法p37
- 3.4 数组中涉及到的常见算法p38
- 3.4 数组中涉及到的常见算法p40
- 3.4 数组中涉及到的常见算法p36
- 3.4 数组中涉及到的常见算法：排序算法p47
- 3.5 Arrays工具类的使用p56
- 3.6 数组使用中的常见异常p58
复习
一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3。编程 找出1000以内的所有完数。（因子：除去这个数本身的其它约数）
//3.一个数如果恰好等于它的因子之和，这个数就称为"完数"。
//例如6=1＋2＋3。编程 找出1000以内的所有完数。（因子：除去这个数本身的其它约数）
public class day05
{
public static void main(String[] args)
{
for(int i=1;i<1000;i++)
{
int factor=0;
for(int j=1;j<=i/2;j++)
{
if(i%j==0)
{
factor+=j;
}
}
if(i==factor)
{
System.out.println(i);
}
}
}
}
隐藏eclipse中的工程
3.2 一维数组的使用：数组元素的引用p10
package come.atguigu.java;
/*
*
* 一、数组的概述
* 1.数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合，
* 并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
*
* 2.数组的相关概念：
* >数组名
* >元素
* >角标、下标、索引
* >数组的长度：元素的个数
*
* 3.数组的特点：
* 1)数组属于引用类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
* 2)创建数组对象会在内存中开辟一整块连续的空间；
* 3)数组的长度一旦确定，就不能修改;
* 4)数组是有序排列的。
*
* 4.数组的分类：
* ① 按照维数：一维数组、二维数组、三维数组……
* ② 按照数组元素类型：基本数据类型元素的数组、引用类型元素的数组
*
* 5.一维数组的使用
* ① 一维数组的声明和初始化
* ② 如何调用数组的指定位置的元素
* ③ 如何获取数组的长度
* ④ 如何遍历数组
* ⑤ 数组元素的默认初始化值： 见ArrayTest1.java
* ⑥ 数组的内存解析： 见ArrayTest1.java
*/
public class ArrayTest {
public static void main(String[] args) {
//1. 一维数组的声明和初始化
int num; //声明
num = 10; //初始化
int id = 1001; //声明 + 初始化
int[] ids; //声明
//1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004}; //数组元素是基本数据类型
//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5]; //数组元素是引用数据类型
//错误的写法：
// int[] arr1 = new int[]; //未赋值、未指明长度
// int[5] arr2 = new int[5];//前边的[]永远都是空的
// int[] arr3 = new int[3]{1,2,3};//动静合二为一也不行
//也是正确的写法：
int[] arr7 = {1,2,3,5,4};//类型推断
/*总结：数组一旦初始化完成，其长度就确定了。
*/
//2.如何调用数组的指定位置的元素：通过角标的方式调用。
//数组的角标(或索引)从0开始的，到数组的长度-1结束
names[0] = "张郃";
names[1] = "王陵";
names[2] = "张学良";
names[3] = "王传志"; //charAt(0)//java只要是涉及到索引问题，几乎都是从0开始，包括字符串
names[4] = "李峰";
// names[5] = "周礼"; //如果数组超过角标会通过编译，运行失败。
//解释运行时才把程序真正加载到内存中，编译只是生成一个字节码文件
//并不是加载到内存
//3.如何获取数组的长度
//属性：length
System.out.println(names.length); //5
System.out.println(ids.length); //4
//4.如何遍历数组
// System.out.println(names[0]);
// System.out.println(names[1]);
// System.out.println(names[2]);
// System.out.println(names[3]);
// System.out.println(names[4]);
// ctrl+/全部注释，相同操作复原，
// ctrl+shift+/ 多行注释,ctrl+shift+\ 复原
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
}
}
3.2 一维数组的使用：数组元素的默认初始化值p12
package come.atguigu.java;
/*
* ⑤ 数组元素的默认初始化值
* > 数组元素是整形(byte,short,int,long)：0
* > 数组元素是浮点型(float,double)：0.0
* > 数组元素是char型：0或'\u0000'，而非'0'
* 'a'---->97
* 'A'---->65
* '0'---->……
* ……---->0 char的默认值是此 0；
*
* > 数组元素是boolean型:false
*
* > 数组元素是引用数据类型：null
*/
public class ArrayTest1 {
public static void main(String[] args) {
//5.数组元素的默认初始化值
int[] arr = new int[4];
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
System.out.println("*****************");
short[] arr1 = new short[4];
for(int i = 0;i < arr1.length;i++){
System.out.println(arr1[i]);
}
System.out.println("*****************");
float[] arr2 = new float[5];
for(int i = 0;i < arr2.length;i++){
System.out.println(arr2[i]);
}
System.out.println("*****************");
char[] arr3 = new char[5];
for(int i = 0;i < arr3.length;i++){
System.out.println("----" + arr3[i] + "****");//以空格的形式变现出来
}
if(arr3[0] == 0){
System.out.println("你好！");
}
System.out.println("*****************");
boolean[] arr4 = new boolean[5];
System.out.println(arr4[0]);
System.out.println("*****************");
String[] arr5 = new String[5];
System.out.println(arr5[0]);
//验证
if(arr5[0] == null){
System.out.println("北京天气好差！");
}
}
}
3.2 一维数组的使用p21
package come.atguigu.exer;
public class ArrayDemo {
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);
}
}
3.2 一维数组的使用p22
package come.atguigu.exer;
import java.util.Scanner;
/*
* 2. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
* 成绩>=最高分-10 等级为’A’
* 成绩>=最高分-20 等级为’B’
* 成绩>=最高分-30 等级为’C’
* 其余等级为’D’
* 提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
*/
//1.使用Scanner，读取学生个数
//2.创建数组，存储学生成绩：动态初始化
//3.给数组中的元素赋值
//4.获取数组中的元素最大值：最高分
//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
public class ArrayDemo1 {
public static void main(String[] args) {
//1.使用Scanner，读取学生的个数
Scanner scan = new Scanner(System.in);
System.out.print("请输入学生人数：");
int num = scan.nextInt();
//2.创建数组，存储学生成绩，动态初始化
int[] str = new int[num];
System.out.println("请输入" + num + "个学生成绩");
//3.给数组中的元素赋值
int maxnum = 0;
for(int i = 0;i < str.length;i++){
str[i] = scan.nextInt();
//4.获取数组元素中的最大值：最高分
if(maxnum < str[i]){
maxnum = str[i];
}
}
//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
char Grade; //成绩等级
for(int i = 0;i < str.length;i++){
if(maxnum - str[i] <= 10){
Grade = 'A';
}else if(maxnum - str[i] <= 20){
Grade = 'B';
}else if(maxnum - str[i] <= 30){
Grade = 'C';
}else{
Grade = 'D';
}
System.out.println("student " + i + "score is" + str[i] +
" grade is " + Grade);
}
}
}
}
*/
3.3 多维数组的使用p24
ArrayTest2
package come.atguigu.java;
/*
* 二维数组的使用
*
* 1.理解
* 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
* 其实，从数组底层的运行机制来看，其实没有多维数组都可以看作一维数组。
*
* 2.二维数组的使用：
* ① 二维数组的初始化
* ② 如何调用数组的指定位置的元素
* ③ 如何获取数组的长度
* ④ 如何遍历数组
* ⑤ 数组元素的默认初始化值:见ArrayTest3.java
* ⑥ 数组的内存解析:见ArrayTest3.java
*
*/
public class ArrayTest2 {
public static void main(String[] args) {
//1.二维数组的声明和初始化
int[] arr = new int[]{1,2,3};
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//错误的情况
// String[][] arr4 = new String[][];
// String[][] arr5 = new String[][4];
// String[][] arr6 = new String[4][3]{{1,2,3},{4,5,6},{7,8,9}};
//正确的情况：
int arr4[][] = new int[][]{{1,2,3},{4,5,12,6},{7,8,9}};
int[] arr5[] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
int[][] arr6 = {{1,2,3},{4,5,6},{7,8,9}};
//2.如何调用数组的指定位置的元素
System.out.println(arr1[0][1]); //2
System.out.println(arr2[1][1]); //null
arr3[1] = new String[4]; //定义arr3的[1]为长度为4的字符数组
System.out.println(arr3[1][0]); //null ,若没有上句，会报错
//3.获取数组的长度
System.out.println(arr4.length); //3，a4就是一维数组，只不过元素恰好也是一维数组而已
System.out.println(arr4[0].length); //3
System.out.println(arr4[1].length); //4
//4.如何遍历二维数组
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.3 多维数组的使用p25
引用类型的变量，保存的要么是地址值，要么是null
ArrayTest3
package come.atguigu.java;
/*
* 二维数组的使用：
* 规定：二维数组分为外层数组的元素，内层数组的元素
* 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，每一个元素是int型的数组，是引用类型，没有赋值，因此是null
* 内层元素的初始化值为：不能调用，否则报错。
*
* ⑥ 数组的内存解析
*/
public class ArrayTest3 {
public static void main(String[] args) {
int[][] arr = new int[4][3];
System.out.println(arr[0]); //[I@15db9742 输出int型一维地址值
System.out.println(arr[0][0]); //0
System.out.println(arr); //[[I@626b2d4a 输出int型二维地址值
System.out.println("***********************");
float[][] arr1 = new float[4][3];
System.out.println(arr1[0]); //[F@5e91993f
System.out.println(arr1[0][0]); //0.0
System.out.println("***********************");
String[][] arr2 = new String[4][2];
System.out.println(arr2[1]); //[Ljava.lang.String;@1175e2db
System.out.println(arr2[1][1]); //null
System.out.println("*********************");
double[][] arr3 = new double[4][];
System.out.println(arr3[1]); //null
// System.out.println(arr3[1][0]); //报错
}
}
3.3 多维数组的使用p32
package com.atguigu.exer;
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(sum);
}
}
3.3 多维数组的使用p34
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 YangHuiTest{
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] arr = new int[10][];
//2.给数组的元素赋值，遍历二维数组
for(int i = 0;i < arr.length;i++){
arr[i] = new int[i+1];
//2.1 给首末元素赋值
arr[i][0]=arr[i][i]=1;
//2.2 给每行的非首末元素赋值
// if(i > 1){
for(int j = 1;j < arr[i].length-1;j++){
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
// }
}
// 3.遍历数组
for(int i = 0;i < arr.length;i++){
for(int j = 0;j <arr[i].length;j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
随机数
* [10,99]
* 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
*
* 注：
* Math.random() :[0.0,1)
* Math.random()*90 :[0.0,90.0)
* (int)(Math.random()*90) :[0,89]
* (int)(Math.random()*90+10) :[10,99]
*
* 公式：获取[a,b]范围的随机数：(int)(Math.random())*(b-a+1))+a
3.4 数组中涉及到的常见算法p37
package com.atguigu.java;
/*
* 算法的考察：求数值型数组中元素的最大值、最小值、平均数、总和等
*
* 定义一个 int 型的一维数组，包含 10 个元素，分别赋一些随机整数，
* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
* 要求：所有随机数都是两位数。
*
* [10,99]
* 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
*
* 注：
* Math.random() :[0.0,1)
* Math.random()*90 :[0.0,90.0)
* (int)(Math.random()*90) :[0,89]
* (int)(Math.random()*90+10) :[10,99]
*
* 公式：获取[a,b]范围的随机数：(int)(Math.random())*(b-a+1))+a
*
*
*
*/
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
//数组赋值
for(int i = 0;i <arr.length;i++){
arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);//[0,1),[0,90),[10,100)
}
//遍历
for(int i =0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
System.out.println();
//求数组元素的最大值
int maxValue = arr[0];
for(int i = 1;i <arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
System.out.println("最大值：" + maxValue);
//求数组元素的最小值
int minValue = arr[0];
for(int i = 1;i <arr.length;i++){
if(minValue > arr[i]){
minValue = arr[i];
}
}
System.out.println("最小值：" + minValue);
//求数组元素的总和
int sum = 0;
for(int i = 1;i <arr.length;i++){
sum += arr[i];
}
System.out.println("总和：" + sum);
//求数组元素的平均数
double avgVales = (double)sum / arr.length;
System.out.println("平均数：" + avgVales);
}
}
3.4 数组中涉及到的常见算法p38
package com.atguigu.exer;
/*
* 使用简单数组
* (1)创建一个名为 ArrayExer2 的类，在 main()方法中声明 array1 和 array2 两个变量，他们是 int[]类型的数组。
* (2)使用大括号{}，把 array1 初始化为 8 个素数：2,3,5,7,11,13,17,19。
* (3)显示 array1 的内容。
* (4)赋值 array2 变量等于 array1，修改 array2 中的偶索引元素，使其等于索引值(如 array[0]=0,array[2]=2)。打印出 array1。
*
* 1、思考：上述 array1 和 array2 是什么关系？
* array1和array2地址相同，都指向了堆空间中的唯一的一个数组实体
*
*
* 拓展：修改题目，实现 array2 对 array1 数组的复制
*
*/
public class ArrayExer2 {
public static void main(String[] args) {
//声明 array1 和 array2 两个 int[]变量
int[] array1,array2;
//array1 初始化
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] + " ");
}
//赋值 array2 变量等于 array1
//不能称作数组的复制。
//如下操作，如同在桌面建立一个文件A的快捷方式，这个快捷方式中保存的是这个文件A的地址值。
array2 = array1;//是把array1的地址给了array2,array2指向的是堆中array1所指向的数组
//二者指向同一个数组,只是建立了一个快捷方式
//new一次就有一个数组，自始至终就new过一个，故只有一个数组
//将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体
//修改 array2 中的偶索引元素，使其等于索引值(如 array[0]=0,array[2]=2)。
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
array2[i] = i;
}
}
System.out.println();
//打印出 array1。
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}
}
}
3.4 数组中涉及到的常见算法p40
package com.atguigu.exer;
/*
* 拓展：修改题目，实现 array2 对 array1 数组的复制
*
* 其操作类似于网盘中的一个文件A，对他进行赋值，粘贴到桌面上，这样就有两套一模一样的文件了，对桌面
* 上的文件进行操作，不影响文件A，即这两个文件就是真正的两套东西。
*
*/
public class ArrayExer3 {
public static void main(String[] args) {
//声明 array1 和 array2 两个 int[]变量
int[] array1,array2;
//array1 初始化
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");
}
//数组的复制
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
//修改 array2 中的偶索引元素，使其等于索引值(如 array[0]=0,array[2]=2)。
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
array2[i] = i;
}
}
System.out.println();
//打印出 array1。
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + "\t");
}
}
}
3.4 数组中涉及到的常见算法p36
package com.atguigu.java;
/*
* 算法的考察：数组的复制、反转、查找(线性查找、二分法查找)
*/
public class ArrayTest2 {
public static void main(String[] args) {
String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
//数组的复制
//通过new的方式，在堆空间中新开辟一个新数组。将array1数组
//中的元素值一个一个地复制到array2数组中。
//区别于数组变量的赋值：arr1=arr
String[] arr1 = new String[arr.length];
for(int i = 0;i < arr1.length;i++){
arr1[i] = arr[i];
}
//数组的反转
//方法一：
// for(int i = 0;i < arr.length / 2;i++){
// String temp = arr[i];
// arr[i] = arr[arr.length - i - 1]; //i+(arr.length-i-1)=常数arr.length-1
// arr[arr.length - i - 1] = temp;
// }
//方法二：
for(int i = 0,j = arr.length - 1;i < j;i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
System.out.println();
//查找（或搜索）
//线性查找
String dest = "BB"; //要查找的元素
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){//int型用==可以，但是这是字符串，
System.out.println("找到了指定元素，位置为：" + i);
isFlag = false;
break;
}
}
if(isFlag){
System.out.println("很遗憾，没找到！");
}
//更进
/*
* String dest = "BB"; //要查找的元素
for(int i = 0;i < arr.length;i++){
if(dest.equals(arr[i])){//int型用==可以，但是这是字符串，
System.out.println("找到了指定元素，位置为：" + i);
break;
}
}
if(i==arr.length){
System.out.println("很遗憾，没找到！");
}
*/
//二分法查找：
//前提：所要查找的数组必须有序
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
int head = 0; //初始的首索引
int end = arr2.length - 1; //初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定元素，位置为：" + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else{ //arr2[middle] < dest1
head = middle + 1;
}
}
if(isFlag1){
System.out.println("很遗憾，没找到！");
}
}
}
3.4 数组中涉及到的常见算法：排序算法p47
package com.atguigu.java;
//p166
/*
* 数组的冒泡排序的实现
* 49 38 65 97 76 13 27 49
* 38 49 65 76 13 27 49 97
* 38 49 65 13 27 49 76 97
* 38 49 13 27 49 65 76 97
* 38 13 27 49 49 65 76 97
* 13 27 38 49 49 65 76 97
*
*
*/
public class BubbleSortTest {
public static void main(String[] args) {
int[] arr = new int[]{43,32,76,92,-65,85,71,-42};
//冒泡排序
//string排序按照ABCD顺序排，中文按照Unicode值排序
for(int i = 0;i < arr.length - 1;i++){//比较n-1轮
for(int j = 0;j < arr.length - 1 - i;j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
}
}
3.5 Arrays工具类的使用p56
package com.atguigu.java;
import java.util.Arrays;
/*
* java.util.Arrays:操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
*/
public class ArrayTest {
public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b)判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,2,9,3};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2.String toString(int[] a)输出数组信息。
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val)将指定值填充到数组之中。
Arrays.fill(arr1, 10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a)对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)对排序后的数组进行二分法检索指定的值。
int[] arr3 = new int[]{43,32,76,92,-65,85,71,-42};
Arrays.sort(arr3);//排序
System.out.println(Arrays.toString(arr3));//输出
int index = Arrays.binarySearch(arr3, 43);//返回的是个负数则没找到，返回下标
if(index >= 0){
System.out.println(index);
}else{
System.out.println("未找到。");
}
}
}
3.6 数组使用中的常见异常p58
package com.atguigu.java;
/*
* 数组中的常见异常：
* 1.数组角标越界的异常:ArrayIndexOutOfBoundsException
*
* 2.空指针异常:NullPointerException
*
*/
public class ArrayExceptionTest {
public static void main(String[] args) {
//1.数组角标越界的异常:ArrayIndexOutOfBoundsException
int[] arr = new int[]{1,2,3,4,5,6};
//错误1：
// for(int i = 0;i <= arr.length;i++){
// System.out.println(arr[i]);
// }
//错误2：
// System.out.println(arr[-2]);
// System.out.println("hello");
//2.空指针异常:NullPointerException
//情况一:
// int[] arr2= new int[]{1,2,3};
// arr2 = null;//相当于栈中的arr2变量的指向堆中的指针被赋值为null,则堆中的数组不会被指了
// System.out.println(arr2[0]);
//情况二:
// int[][] arr2 = new int[4][];
// System.out.println(arr2[0][0]);
//情况三:
// String[] arr3 = new String[]{"AA","QQ","YY","XX","TT","KK"};
// arr3[0] = null;
// System.out.println(arr3[0].toString());
}
}
![[NeurIPS 2018] Hyperbolic neural networks](https://img-blog.csdnimg.cn/8027b3fc89a242449675127ee2f7fe99.png#pic_center)
