目录
1.boolean equals(int[] a,int[] b)
5.int binarySearch(int[] a,int key)
1.数组角标越界异常：ArrayIndexOutOfBoundsException
一、数组的概念
1.数组(Array)，是多个相同类型数据一定顺序排列的集合，
并使用一个名字命名，并通过编号的方式对这些数据进行统一管理
2.数组相关的概念：
>数组名
>元素
>角标、下标、索引
>数组的长度：元素的个数
3.数组的特点：
1)数组是序排列的
2)数组属于引用类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
3)创建数组对象会在内存中开辟一整块连续的空间
4数组的长度一旦确定就不能修改
4.数组的分类：
①照维数：一维数组、二维数组、....
②照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
5.注：数组是一个连续的空间，删除一个数组元素不能设为null,只能由后一个元素覆盖掉前一个
二、一维数组
1.一维数组的声明与初始化
正确的方式：
int num;//声名
num = 10;//初始化
int id = 1001;//声名+初始化
int[] ids;//声名
//1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[] {1001,1002,1002,1004};
//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
简单写法：int[] arr4 = {1,2,3,4,5};
错误的方式：
//int[] arr1 = new int[];
//int[5] arr2 = new int[5];
//int[] arr3 = new int[3] {1,2,3};
2.一维数组元素的引用：通过角标的方式调用
names[0] = "王明";
names[1] = "王赫";
names[2] = "张学良";
names[3] = "杨虎城";//charAt(0)
names[4] = "周扬";
3.数组的属性：length
System.out.println(names.length);//5
System.out.println(ids.length);
说明：
数组一旦初始化，其长度就是确定的。arr.length
数组的长度一旦确定，就不可更改
4.一维数组的遍历
for(int i = 0;i<names.length;i++) {
System.out.println(names[i]);
}
4.1增强for循环
增强for循环:专门用来遍历数组和集合的,遍历过程中，不能对集合的元素进行增删操作。
for( 元素的数据类型 变量名 : 数组名/集合名{
}
例子：
public static void main(String[] args) { // 定义一个数组 int[] array = new int[5]; array[0] = 73; array[1] = 84; array[2] = 99; array[3] = 10; array[4] = -10; //增强for循环 //i:代表数组的元素，不是下标 for(int i:array) { System.out.println(i); } }
5.一维数组元素的默认初始化值
>数组元素是整数型：0
>数组的元素是浮点型：0.0
>数组元素是char类型：0(ASCII码的0)或'\u0000'而非字符'0'
>数组元素是boolean型：false（false代表0，true代表1
>数组元素为引用数据类型：例如String类型：null(空)
6.一维数组的内存结构
三、二维数组
1.如何理解二维数组？
数组属于引用数据类型
数组的元素也可以是引用数据类型
一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组
2.二维数组的声明与初始化
正确的方式：
int[] arr = new int[]{1,2,3,4,5};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{4,5,6},{5,2},{1,2,3}};
//动态初始化1
String[][] arr2 = new String[3][2];//二维数组长度为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}};
错误的方式：
// String[][] arr4 = new String[][4];
// String[4][3] arr5 = new String[];
// int[][] arr6 = new int[4][3]{{1,2,3},{4,5}};
3.如何调用二维数组元素:
System.out.println(arr1[0][1]);/5
System.out.println(arr2[1][1]);//null
arr3[1] = new String[4];
System.out.println(arr3[1][0]);//null
System.out.println(arr3[0]);//null
4.二维数组的属性：
System.out.println(arr4.length);//3
System.out.println(arr4[0].length);//3
System.out.println(arr4[1].length);//2
5.遍历二维数组元素
for(int i = 0;i<arr4.length;i++) {
for(int j = 0;j<arr4[i].length;j++) {
System.out.println(arr4[i][j]+" ");
}
System.out.println();
}
6.二维数组元素的默认初始化值
规定二维数组为外层数组的元素，内层数组的元素
int[] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[]0[0],arr[1][2]
引用数据类型的值要么是地址值要么是null二选一
⑤数组元素的默认初始化值
针对于初始化方式一：比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同
正对初始化方式二：比如：int[][] arr = new int[4][];
外层元素初始化为：null
内层元素的初始值为：不能调用，否则报错
⑥数组的内存解析（内存中是如何分配数据结构的
7.二维数组的内存结构
四、数组的常见算法
1.数组的创建与元素赋值：
杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复
2.针对于数值型的数组：
最大值，最小值，总和，平均数等
3.数组的赋值与复制
int[] array1,array2;
array1 = new int[]{1,2,3,4};
3.1 赋值：
array2 = array1;
如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。
3.2 复制：
int[] array2 = new int[array1.length];
for(int i = 0;i<array2.length;i++){
array2[i] = array1[i];
}
如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间，将array1数组中的元素值，一个一个的赋值给array2数组中。
4.数组元素的反转
//数组的反转
//方式一：
/*for(int i = 0;i<arr.length/2;i++) {
String temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}*/
//方式二
for(int i = 0,j = arr.length-1;i<j;i++,j--) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
5.数组中指定元素的查找：搜索、检查
5.1 线性查找：
实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
适用性：具有普遍适用性
5.2 二分法查找：
实现思路：每次比较中间值，折半的方式检索
适用性：（前提：数组必须有序（升序排列才行））
6.数组的排序算法
理解：
1）衡量排序算法的优劣：
时间复杂度，空间复杂度，稳定性
2）排序的分类：内部排序（只使用内存） 与 外部排序（需要借助于磁盘）
3）不同排序算法的时间复杂度
冒泡排序的实现：--需要能手写出来
int[] arr1 = new int[] {34,5,22,-98,6,-76,0,-3};
//冒泡排序
for(int i = 0;i<arr1.length-1;i++) {//控制循环几轮
for(int j=0;j<arr1.length-1-i;j++) {//控制角标
if(arr1[j]>arr1[j+1]) {
int temp = arr1[j];
arr1[j]=arr1[j+1];
arr1[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr1));
五、Arrays工具类的
1.boolean equals(int[] a,int[] b)
//1.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);//false2.String toString(int[] a)
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));3.void fill(int[] a,int val)
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1, 10);
System.out.println(Arrays.toString(arr1));4.void sort(int[] a)
//4.void sort(int[] a):对数组进行排序。升序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));5.int binarySearch(int[] a,int key)
对排序（升序排列）后的数组进行二分法检索指定的值。
//5.int binarySearch(int[] a,int key):对排序后的数组进行二分法检索指定的值。
int[] arr3 = new int[] {-98,-34,2,34,54,66,79,105,210,333};
//Arrays.binarySearch()它的返回值是正负数：正数则是找到了这个是数，返回值是负数则是没找到
int index = Arrays.binarySearch(arr3, 210);
if(index>=0) {
System.out.println("这个数的位置是："+index);
}else {
System.out.println("没找到！");
}
六、数组常见的异常
1.数组角标越界异常：ArrayIndexOutOfBoundsException
//1.数组角标越界异常：ArrayIndexOutBoundsExcetion
int[] arr = new int[] {1,2,3,4,5};
// for(int i = 0;i<=arr.length;i++) {
// System.out.println(arr[i]);
// }
// System.out.println(arr[-2]);2.空指针异常：NullPointerException
//2.空指针异常：NullPointerException
// 如果是在整个数组中的遍历时不会报错，当你对这个空的位置进行操作时，会包空指针异常
//情况一：
// int[] arr1 = new int[] {1,2,3};
// arr1 = null;//地址变成了空，再去找第一个元素找不到，则为空指针
// System.out.println(arr1[0]);
//情况二：
// int[][] arr2 = new int[4][];
// System.out.println(arr2[0]);//null
// System.out.println(arr2[0][1]);//空指针异常
//情况三：
String[] arr3 = new String[] {"AA","BB","CC"};
// arr3[0] = null;
System.out.println(arr3[0].toString());
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
