1.数组组成结构
数组名
元素
角标、下标、索引
数组的长度：元素的个数
2. 数组的特点
- 数组属于引用类型的变量。数组的元素，既可以是基本数据类型，
也可以是引用数据类型。 - 创建数组对象会在内存中开辟一整块连续的空间；
- 数组的长度一旦确定，就不能修改 ;
- 数组是有序排列的。
- 数组的分类：
① 按照维数：一维数组、二维数组、三维数组⋯⋯， 对于二维数组的理解，我们可以看成是一维数组 array1 又作为另一个一维数组 array2 的元素而存在，以此类推。
其实，从数组底层的运行机制来看，其实没有多维数组。
② 按照数组元素类型：基本数据类型元素的数组、引用类型元素的数
组。
3.数组默认初始值
数组元素的默认初始化值（一维数组）
数组元素是整形：0
数组元素是浮点型：0.0
数组元素是 char 型：0 或 ‘\u0000’，而非 ‘0’
数组元素是 boolean 型 :false
数组元素是引用数据类型：null
对于二维数组
针对于初始化方式一：比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同
针对于初始化方式二：比如：int[][] arr = new int[4][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。
4.数组的使用
① 数组的声明和初始化
② 如何调用数组的指定位置的元素
③ 如何获取数组的长度
④ 如何遍历数组
⑤ 数组元素的默认初始化值
⑥ 数组的内存解析
示例：一维数组
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)
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]);
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
}
示例：二维数组
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] 为长度为 4 的字符数组
arr3[1] = new String[4];
System.out.println(arr3[1][0]); // 没有上句，会报错
//3. 获取数组的长度
System.out.println(arr4.length); //3
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();
}
}
4.数组Arrays工具类的使用
//1.boolean equals(int[] a,int[] b) --比较两个数组是否相等
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
Boolean b = Arrays.equals(arr1,arr2);
System.out.println("比较两个数组是否相等:"+b);//顺序不同
//2.String toString(int[] a) --输出数组信息
System.out.println("输出数组信息:"+Arrays.toString(arr1));
//3.void fill(int[] a,int val) --将指定值填入数组当中
Arrays.fill(arr2,5);
System.out.println("将指定值填入数组当中:"+Arrays.toString(arr2));
//4.void sort(int[] a) --对数组进行排序
int[] arr3 = new int[]{1,3,2,4,7,5,8,6,9};
Arrays.sort(arr3);
System.out.println("对数组进行排序:"+Arrays.toString(arr3));
//5.int binarySearch(int[] a,int key) --二分查找,前提有序，否则输出索引出错
// int index = Arrays.binarySearch(arr3,5);
System.out.println("二分查找:"+ Arrays.binarySearch(arr3,5));
5.数组中常见的异常
/**
* 数组中常见的异常
* 1.数组下标越界异常：ArrayIndexOutOfBoundsException
* 2.空指针异常：NUllPointerException
* 打开注释体会异常的原因和结果
*/
private void arrayException(){
//1.数组下标越界异常：ArrayIndexOutOfBoundsException
int[] a = new int[]{1,2};
//下标越界异常
// for (int i = 0;i <= a.length;i++){//循环条件错误，应为i < a.length 或 i <= a.length - 1
// System.out.println(a[i]);//错误
// }
// System.out.println(a[-3]);//错误
// System.out.println(a[3]);//错误
//2.空指针异常：NUllPointerException
//1.数组在使用之前被重新赋值或声明后就没有赋值
// int[] b = new int[]{1,2,3};
// b = null;
// System.out.println(b[0]);
//2.面向对象中常出的错 --方法调用前的对象为null
// String[] d = new String[]{"","hh","aa"};
// d[0] = null;
// System.out.println(d[0].toString());
//3.二维数组采用动态初始化，访问到内层没有赋值（或没有地址）的元素
// int[][] c = new int[4][];
// System.out.println(c[0][0]);
}
6.数组中涉及到的常见算法
1.算法的5大特征
1.输入：有0个或多个输入，这些输入必须有清楚的描述和定义
2.输出：至少有1个输出
3.有穷性：算法在经过有限的步骤后会自动结束而不会无限循环，且每一步都可以在接受的时间内完成
4.确定性：算法中的每一步都有明确的定义，不会出现二义性
5.可行性：算法的每一步都是清楚可行的，能让用户用纸笔计算而求出答案
2.数组元素的排序算法
通常来说，排序是为了更快速地查找。排序算法优劣：
1.时间复杂度：分析关键字的比较次数和数据的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个数据A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的
3.常见排序算法分类
内部排序：整个排序无需借助外部存储器，所有排序操作在内存完成
- 1.选择排序：直接选择排序、堆排序
- 2.交换排序：冒泡排序、快速排序
- 3.插入排序：直接插入排序、折半插入排序、希尔排序
- 4.归并排序
- 5.桶式排序
- 6.基数排序
外部排序：数据量较大，计算机无法把整个排序过程放在内存中完成，必须借助外部存储器。最常见的是多路归并排序
4.数组中涉及到的常见算法
1.数组元素赋值(杨辉三角、回型数等)
2.求数值型数组中元素的最大值、最小值、平均数、总和等
3.数组的复制、反转、查找(线性查找、二分法查找)
4.数组元素的排序方法
- 数组元素的赋值 ( 杨辉三角、回形数等 )。
System.out.println("-------------------1.使用二维数组打印杨辉三角");
/*
1
1 1
1 2 1
杨辉三角：
1.第一行有1个元素，第n行有n个元素
2.每一行的第一个元素和最后一个元素都是1
3.从第三行开始，对于非第一个元素和最后一个元素的元素
yangHui[i][j] = yangHui[i - 1][j - 1]+yangHui[i - 1][j]
*/
int n = 10;
//动态声明初始化
int[][] yangHui =new int[10][];
//给数组赋值
for (int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1];
//给首末元素赋值
yangHui[i][0]=yangHui[i][i]=1;
for (int j = 1;j <yangHui[i].length - 1;j++){
yangHui[i][j] = yangHui[i - 1][j - 1]+yangHui[i - 1][j];
}
}
//遍历输出
for (int i = 0;i < yangHui.length;i++){
//控制排版
for (int j = yangHui.length;j > i;j--){
System.out.print(" ");
}
//输出内容
for (int j = 0;j <yangHui[i].length;j++){
System.out.print(yangHui[i][j]+" ");
}
System.out.println();
}
System.out.println("\n-------------------2.回型数数组赋值");
int length = 10;//指定长度
if (length < 0) {
throw new RuntimeException("参数extent不能<0");}
int index = 1;//用于给数组赋值
int rightLength = length - 1; //数组右边界限定值
int bottomLength = length - 1; //数组下边界限定值
int leftLength = 0; //数组左边界限定值
int topLength = 0; //数组上边界限定值
//创建一个指定容量的二维数组
int[][] arr = new int[length][length];
//如果左边界<=右边界就执行循环体
while (leftLength <= rightLength) {
//上边赋值：从左边界开始，右边界结束，并且上边界加一
for (int i = leftLength; i <= rightLength; i++) {
arr[topLength][i] = index++;
}
topLength++; //上边界加一
//右边赋值：从上边界开始，下边界结束，并且右边界减一
for (int j = topLength; j <= bottomLength; j++) {
arr[j][rightLength] = index++;
}
rightLength--;
//下边赋值：从右边界开始，左边界结束，并且下边界减一
for (int i = rightLength; i >= leftLength; i--) {
arr[bottomLength][i] = index++;
}
bottomLength--;
//左边赋值：从下边界开始，上边界结束，并且左边界加一
for (int j = bottomLength; j >= topLength; j--) {
arr[j][leftLength] = index++;
}
leftLength++;
}
//遍历输出
for (int[] anInt : arr) {
for (int i : anInt) {
System.out.print(i + "\t");
}
System.out.println();
}
System.out.println();
在这里插入代码片
System.out.println("\n-------------------2.拓展“彩票问题” ");
/*
创建一个长度为6的int型数组，要求数组元素的值都在1~30之间，且是随即赋值。
同时要求元素的值各不相同
*/
int[] numbers = new int[6];
for (int i = 0;i <numbers.length;i++){
//定义一个随机数生成方法
numbers[i]=(int)(Math.random()*30)+1;
//循环检查是否有相同的元素
for (int j = 0;j < i;j++){
if(numbers[i] == numbers[j]){
i--;//返回上一次循环重新赋值
break;
}
}
}
for (int i = 0;i <numbers.length;i++){
System.out.print(numbers[i]+" ");
}
- 求数值型数组中元素的最大值、最小值、平均数、 总和等。
System.out.println("\n-------------------4.求数组中的特定值");
/*
求数组中元素的最大值、最小值、平均值、总和等
*/
System.out.println("\n---求一维数组中的特定值");
/*
定义一个包含十个元素的一维数组，分别赋一些随机的两位整数。
求出元素的最大值、最小值、平均值、总和
Math.random()*(99-10+1)+10;
*/
int[] arr2 = new int[10];
int max = 0,min = 99,sum = 0;
for (int i = 0;i < arr2.length;i++){
arr2[i] = (int)(Math.random()*90+10);
//最大值
if (arr2[i] > max){
max = arr2[i];
}
//最小值
if(arr2[i] < min){
min = arr2[i];
}
//总和
sum+=arr2[i];
}
for (int i = 0;i < arr2.length;i++){
System.out.print(arr2[i]+" ");
}
System.out.println("\n最大值:"+max+"\n最小值:"+min+"\n平均值:"+sum/10+"\n总和:"+sum);
System.out.println("\n---求二维数组中的特定值");
/*
定义一个包含10^2个元素的二维维数组，分别赋一些随机的两位整数。
求出元素的最大值、最小值、平均值、总和
Math.random()*(99-10+1)+10;
*/
int n1 = 5;
int[][] arr3 = new int[n1][n1];
int max1 = 0,min1 = 99,sum1 = 0;
for (int i = 0;i < arr3.length;i++){
for (int j = 0;j < arr3[i].length;j++){
arr3[i][j] = (int)(Math.random()*90+10);
//最大值
if (arr3[i][j] > max1){
max1 = arr3[i][j];
}
//最小值
if (arr3[i][j] < min1){
min1 = arr3[i][j];
}
//总和
sum1+=arr3[i][j];
}
}
//遍历输出
for (int i = 0;i < arr3.length;i++){
for (int j = 0;j < arr3[i].length;j++){
System.out.print(arr3[i][j]+" ");
}
System.out.println();
}
System.out.println("最大值:"+max1+"\n最小值:"+min1+"\n平均值:"+sum1/n1+"\n总和:"+sum1);
- 数组的复制、反转、查找 ( 线性查找、二分法查找 )。
System.out.println("\n-------------------5.对数组的操作");
System.out.println("//复制数组");
int[] arr4 = new int[]{1,2,3,4,5,6,7,8,9};
int[] arr5 = new int[arr4.length];
for (int i = 0;i < arr4.length;i++){
arr5[i] = arr4 [i];
}
for (int i = 0;i < arr4.length;i++){
System.out.print(arr5[i]+" ");
}
System.out.println("//反转数组arr4方式一\n");
// for (int i = 0;i < arr4.length / 2;i++){
// int temp = arr4[i];
// arr4[i] = arr4[(arr4.length - 1) - i];
// arr4[(arr4.length - 1) - i] = temp;
// }
System.out.println("//反转数组arr4方式二\n");
for (int i = 0,j = arr4.length - 1;i < j;i++,j--){
int temp = arr4[i];
arr4[i] = arr4[j];
arr4[j] = temp;
}
for (int i = 0;i < arr4.length;i++){
System.out.print(arr4[i]+" ");
}
System.out.println("\n//线性查找");
//查找(线性、二分法)
//线性查找,按顺序遍历查找
String[][] strs = new String[][]{
{"Hello","World","Thanks"},
{"Why","What","When","Where"},
{"Last","Future"},
{"Time"}};
String str = "Time";
boolean isFlag = true;
for (int i = 0;i < strs.length;i++){
for (int j = 0;j < strs[i].length;j++){
if (str.equals(strs[i][j])){
System.out.println("true,"+"在["+i+"]"+"["+j+"]未找到"+str);
isFlag = false;
break;
}
}
}
if (isFlag){
System.out.println("false,在所有位置上都未找到"+str);
}
System.out.println("//二分法查找\n");
//二分法查找，比线性查找快。
// 但是二分法使用的前提是数据需要有序，否则不知道该选择哪个范围作为一下次查找的目标
int[] arr6 = new int[1000];
//赋值
for (int i = 0;i < arr6.length;i++){
arr6[i] = i;
}
int num = 556;//目标数
boolean isFlag1 = true;
int head = 0;//初始首部索引
int end = arr6.length - 1;//初始尾部索引
while (head <= end){
int mid = (head + end)/2;
if(num == arr6[mid]){
System.out.println("true,在["+mid+"]位置上找到"+num);
isFlag1 = false;
break;
} else if (num < arr6[mid]) {
end = mid - 1;
}else{
head = mid + 1;
}
}
if (isFlag1){
System.out.println("false,在所有位置上都未找到"+num);
}
- 数组元素的排序方法
private void arraySort (){
//定义一个数组，元素在1~99随机生成
int[] arr1 = new int[20];
int max = 0,min = 99,sum = 0;
//遍历输出
for (int i = 0;i < arr1.length;i++){
arr1[i] = (int)(Math.random()*99+1);
System.out.print(arr1[i]+" ");
}
System.out.println();
//冒泡排序(BubbleSort)
/*思想：
1.比较相邻的两个元素。如果第一个元素比第二个元素大(升序)，就交换他俩
2.对每一对相邻元素做同样的工作，从开始第一对到结尾最后一对。这一步完成后最后的元素会是最大的数
3.针对所有元素重复以上步骤，每次都是除了最后i个
4.重复以上操作直至排序完成
*/
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("冒泡排序结果:");
for (int i = 0;i < arr1.length;i++){
System.out.print(arr1[i]+" ");
}
System.out.println();
//快速排序(BubbleSort)
/*
快速排序明显比其他算法更快，采用了分治的思想，其时间复杂度为O(nlog(n))。
*/
}
1825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
