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型的默认值是false
System.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读取学生个数num
System.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.0
System.out.println("******************");
String[][] arr2 = new String[3][4];
System.out.println(arr2[0]); //[Ljava.lang.String;@7852e922
System.out.println(arr2[0][0]); // null
System.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-1
for(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、数组使用中的常见异常
注：
- 空指针异常，最常见的是多维数组中，内层元素还未初始化，就调用的情况。
- 一旦程序出现异常，未处理时就终止程序。
1593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
