第五章、数组
一、数组
数组的介绍：数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。简言之，数组就是一组数据
数组的定义与使用：
-
动态初始化
-
数组的定义
方法1： //声明时直接分配空间创建数组 数据类型 数组名[] = new 数据类型[数组长度]; int a[] = new int[5];//创建一个数组，名字为a，存放5个int 或者 数据类型[] 数组名 = new 数据类型[数组长度]; 方法2： 常在刚开始不知道数组大小的时候使用 //1. 先声明数组 数据类型 数组名[]; 或者 数据类型[] 数组名; int a[]; //2. 创建数组 数组名 = new 数据类型[数组长度]; a = new int[10] -
数组的引用(使用)
数组名[下标/索引]; a[0]//调用数组第0号元素。 -
案例：
import java.util.Scanner; public class Array02 { //编写一个main方法 public static void main(String[] args) { //演示 数据类型 数组名[]=new 数据类型[大小] //循环输入5个成绩，保存到double数组,并输出 //步骤 //1. 创建一个 double 数组，大小 5 //(1) 第一种动态分配方式 //double scores[] = new double[5]; //(2) 第2种动态分配方式， 先声明数组，再 new 分配空间 double scores[] ; //声明数组， 这时 scores 是 null scores = new double[5]; // 分配内存空间，可以存放数据 //2. 循环输入 // scores.length 表示数组的大小/长度 // Scanner myScanner = new Scanner(System.in); for( int i = 0; i < scores.length; i++) { System.out.println("请输入第"+ (i+1) +"个元素的值"); scores[i] = myScanner.nextDouble(); } //输出，遍历数组 System.out.println("==数组的元素/值的情况如下:==="); for( int i = 0; i < scores.length; i++) { System.out.println("第"+ (i+1) +"个元素的值=" + scores[i]); } } }
-
-
静态初始化
-
初始化数组
数据类型 数组名[] = {元素1, 元素2, …}; int a[] = {2,6,7,8};
-
-
注意：
- 数组中的元素可以是任意数据类型，包括基本数据类型和引用类型，但是不能混用。
- 数组创建后，如果没有赋值，有默认值
- 使用数组的步骤：(1)声明数组并开辟空间 (2)给数组的各个元素赋值 (3)使用
- 数组的下标必须在指定范围内使用，否则会报下标越界异常
- 数组是引用数据类型，数组型的数据是对象(object)
-
练习：
public class ArrayExercise01 { //编写一个main方法 public static void main(String[] args) { /* 创建一个char类型的26个元素的数组，分别 放置'A'-'Z'。 使用for循环访问所有元素并打印出来。 提示：char类型数据运算 'A'+1 -> 'B' 思路分析 1. 定义一个 数组 char[] chars = new char[26] 2. 因为 'A' + 1 = 'B' 类推，所以老师使用for来赋值 3. 使用for循环访问所有元素 */ char[] chars = new char[26]; for( int i = 0; i < chars.length; i++) {//循环26次 //chars 是 char[] //chars[i] 是 char chars[i] = (char)('A' + i); //'A' + i 是int , ★需要强制转换 } //循环输出 System.out.println("===chars数组==="); for( int i = 0; i < chars.length; i++) {//循环26次 System.out.print(chars[i] + " "); } } }public class ArrayExercise02 { //编写一个main方法 public static void main(String[] args) { //请求出一个数组int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标 //老韩思路分析 //1. 定义一个int数组 int[] arr = {4,-1,9, 10,23}; //2. 假定 max = arr[0] 是最大值 , maxIndex=0; //3. 从下标 1 开始遍历arr， 如果max < 当前元素，说明max 不是真正的 // 最大值, 我们就 max=当前元素; maxIndex=当前元素下标 //4. 当我们遍历这个数组arr后 , max就是真正的最大值，maxIndex最大值 // 对应的下标 int[] arr = {4,-1,9,10,23}; int max = arr[0];//假定第一个元素就是最大值 int maxIndex = 0; // for(int i = 1; i < arr.length; i++) {//从下标 1 开始遍历arr if(max < arr[i]) {//如果max < 当前元素 max = arr[i]; //把max 设置成 当前元素 maxIndex = i; } } //当我们遍历这个数组arr后 , max就是真正的最大值，maxIndex最大值下标 System.out.println("max=" + max + " maxIndex=" + maxIndex); } }
数组的赋值机制
数组在默认情况下是引用传递，赋的值是地址值。
public class ArrayAssign {
//编写一个main方法
public static void main(String[] args) {
//基本数据类型赋值, 赋值方式为值拷贝
//n2的变化，不会影响到n1的值
int n1 = 10;
int n2 = n1;
n2 = 80;
System.out.println("n1=" + n1);//10
System.out.println("n2=" + n2);//80
//数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值
//是一个地址 , arr2变化会影响到 arr1
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;//把 arr1赋给 arr2
arr2[0] = 10;
//看看arr1的值
System.out.println("====arr1的元素====");
for(int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);//10, 2, 3
}
System.out.println("====arr2的元素====");
for(int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);//10, 2, 3
}
}
}
数组拷贝
public class ArrayCopy {
//编写一个main方法
public static void main(String[] args) {
//将 int[] arr1 = {10,20,30}; 拷贝到 arr2数组,
//要求数据空间是独立的.
int[] arr1 = {10,20,30};
//创建一个新的数组arr2,开辟新的数据空间
//大小 arr1.length;
int[] arr2 = new int[arr1.length];
//遍历 arr1 ，把每个元素拷贝到arr2对应的元素位置
for(int i = 0; i < arr1.length; i++) {
arr2[i] = arr1[i];
}
//修改 arr2， 不会对arr1有影响.
arr2[0] = 100;
//输出arr1
System.out.println("====arr1的元素====");
for(int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);//10,20,30
}
//
System.out.println("====arr2的元素====");
for(int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);//
}
}
}
数组翻转
思路一：找规律反转
public class ArrayReverse {
//编写一个main方法
public static void main(String[] args) {
//定义数组
int[] arr = {11, 22, 33, 44, 55, 66};
//思路
//规律
//1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
//2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11}
//3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11}
//4. 一共要交换 3 次 = arr.length / 2
//5. 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i]
//代码
//优化
int temp = 0;
int len = arr.length; //计算数组的长度
for( int i = 0; i < len / 2; i++) {
temp = arr[len - 1 - i];//保存
arr[len - 1 - i] = arr[i];
arr[i] = temp;
}
System.out.println("===翻转后数组===");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");//66,55,44,33,22,11
}
}
}
思路二：使用逆序赋值方式
public class ArrayReverse02 {
//编写一个main方法
public static void main(String[] args) {
//定义数组
int[] arr = {11, 22, 33, 44, 55, 66};
//使用逆序赋值方式
//思路
//1. 先创建一个新的数组 arr2 ,大小 arr.length
//2. 逆序遍历 arr ,将 每个元素拷贝到 arr2的元素中(顺序拷贝)
//3. 建议增加一个循环变量 j -> 0 -> 5
int[] arr2 = new int[arr.length];
//逆序遍历 arr
for(int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
arr2[j] = arr[i];
}
//4. 当for循环结束，arr2就是一个逆序的数组 {66, 55, 44,33, 22, 11}
//5. 让 arr 指向 arr2数据空间, 此时 arr原来的数据空间就没有变量引用,会被当做垃圾，销毁
arr = arr2;
System.out.println("====arr的元素情况=====");
//6. 输出 arr 看看
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
数组扩容
import java.util.Scanner;
public class ArrayAdd2 {
public static void main(String[] args) {
/*
思路：
1.定义初始数组int[] arr = {1, 2, 3, 4}
2.定义一个新的数组int[] arr2 = new int[arr.length+1]
3.遍历arr数组，依次把arr的元素拷贝到arr2中
4.将添加的元素赋值给arr2[arr.length-1] 也就是赋值给arr2的最后一个元素
5.让arr只想arr2，那么原来的arr数组就会被销毁
先死后活：
1. 可以改变添加元素的个数多少
2. 可以自定义添加的元素
优化：
可以自定义添加的数字 Scanner
可以自定义添加的位置（不一定添加到最后）
可以持续添加。 死循环
*/
Scanner sc = new Scanner(System.in);
int[] arr = {1, 2, 3, 4};
for(;;) {
int[] arr2 = new int[arr.length+1];
for(int i = 0; i <= arr.length-1; i++) {
arr2[i] = arr[i];
}
System.out.println("请输入您要添加的数");
arr2[arr2.length-1] = sc.nextInt();
arr = arr2;
System.out.println("请输入是否继续添加\n1.继续添加\t2.不再添加");
int flag = sc.nextInt();
if(flag == 2) {
break;
}
}
System.out.println("最终结果为：");
for(int i = 0; i <= arr.length-1; i++) {
System.out.println(arr[i]);
}
}
}
//使用do-while 没用break 也可以do-while死循环用break和for(;;)一样;
import java.util.Scanner;
public class ArrayAdd2 {
public static void main(String[] args) {
/*
思路：
1.定义初始数组int[] arr = {1, 2, 3, 4}
2.定义一个新的数组int[] arr2 = new int[arr.length+1]
3.遍历arr数组，依次把arr的元素拷贝到arr2中
4.将添加的元素赋值给arr2[arr.length-1] 也就是赋值给arr2的最后一个元素
5.让arr只想arr2，那么原来的arr数组就会被销毁
先死后活：
1. 可以改变添加元素的个数多少
2. 可以自定义添加的元素
*/
Scanner sc = new Scanner(System.in);
int[] arr = {1, 2, 3, 4};
int flag;
do {
int[] arr2 = new int[arr.length+1];
for(int i = 0; i <= arr.length - 1; i++) {
arr2[i] = arr[i];
}
System.out.println("请输入您要添加的数");
arr2[arr2.length-1] = sc.nextInt();
arr = arr2;
System.out.println("请输入是否继续添加\n1.继续添加\t2.不再添加");
flag = sc.nextInt();
}while(flag != 2);
for(int i = 0; i <= arr.length - 1; i++) {
System.out.println(arr[i]);
}
}
}
//定位扩容
import java.util.Scanner;
import java.util.Arrays;
public class ArrayAdd02 {
public static void main(String[] args) {
/*
1.定义初始数组int[] arr = {10, 12 , 45, 90}
2.定义一个新的数组int[] arr2 = new int[arr.length+1]
3.遍历arr数组，依次把arr的元素拷贝到arr2中，插入位置的元素后面的元素全体后移。
4.将添加的元素赋值给插入位置
5.让arr指向arr2，那么原来的arr数组就会被销毁
*/
Scanner sc = new Scanner(System.in);
int[] arr = {10, 12 , 45, 90};
for(;;) {
int[] arr2 = new int[arr.length+1];
System.out.println("请输入您要插入的索引位置。");
int index = sc.nextInt();
//遍历arr数组，依次把arr的元素拷贝到arr2中，插入位置的元素后面的元素全体后移。
for(int i = 0; i < arr2.length; i++) {
if(i < index) {
arr2[i] = arr[i];
} else if(i == index) {
System.out.println("您要插入的元素为：");
arr2[i] = sc.nextInt();
} else if(i >= index) {
arr2[i] = arr[i-1];
}
}
arr = arr2;
System.out.println("请输入是否继续添加\n1.继续添加\t2.不再添加");
int flag = sc.nextInt();
if(flag == 2) {
break;
}
}
System.out.println(Arrays.toString(arr));
}
}
对于添加与删除，数据类型使用链表会更好
数组缩减
import java.util.Scanner;
public class ArrayReduce {
public static void main(String[] args) {
/*
思路：
1.声明新的数组arr2 大小为arr.length-1，
2.将arr中的元素 拷贝到arr2中
3.让arr指向arr2
4.当arr.length=1的时候，提示不能再缩减
*/
Scanner sc = new Scanner(System.in);
int[] arr = {1, 2, 3, 4};
for(;;) {
int[] arr2 = new int[arr.length-1];
for(int i = 0; i <= arr2.length - 1; i++) {
arr2[i] = arr[i];
}
arr = arr2;
System.out.println("请输入是否继续缩减\n1.继续\t2.停止");
int flag = sc.nextInt();
if(arr.length == 1 || flag ==2) {
if(arr.length == 1) {
System.out.println("不能继续缩减");
}
break;
}
}
for(int i = 0; i <= arr.length - 1; i++){
System.out.println(arr[i]);
}
}
}
二、排序
排序是将多个数据，依照指定的顺序进行排列的过程
排序的分类：
- 内部排序：
指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）- 外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）详细的排序方式在数据结构中说明
冒泡排序：
基本思想：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移到后。
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
/*
思路：
1. 第一轮比较：将最大的数字放在最后
2. 第二轮比较： 将第二大的数字放在倒数第二
3. 第三轮比较： 将第三大的数字放在倒数第三
……………………
4.需要一层循环控制轮数。需要一层循环控制次数，每次通过交换达到目标。
先死后活：
5.需要找到轮数和次数之间的关系：第一轮5次 第二轮4次 ，可见比较次数为arr.length - 轮数。；
6.轮数为arr.length-1
优化：
如果数组本来就是有序的，那么第一次比较时 会不发生交换。
所以一旦发现第一次比较没有发生交换可以直接break;
*/
int[] arr = {1, 2, 3, 4, 5, 6};
for(int i = 0; i < arr.length - 1; i++) {
int flag = 0;
for(int j = 0; j < arr.length - 1 - i; j++){
if(arr[j] >= arr[j+1]) {
int t = arr[j+1];
arr[j+1] = arr[j];
arr[j] = t;
flag++;
}
}
if(flag == 0) {
System.out.println("优化起作用");
break;
}
}
System.out.println(Arrays.toString(arr));
}
}
//排序定位+扩容
import java.util.Arrays;
public class SortAdd {
public static void main(String[] args) {
/*
一直有一个升序的数组，要求插入一个元素，该数组顺序依然是升序，比如：[10, 12, 45, 90] 添加23后 ，数组为[10, 12, 23 ,45 ,90]
两种思路：
1. 添加后再排序
2. 使用排序定位， 再按位置添加
使用第二种:
1. 先确定这个数插入到哪个位置
把这个数依次和数组中的元素进行比较，当遇到比这个数大的数，那么这个大的数的位置就是要找的位置。
2. 按位置添加
*/
int[] arr = {10, 12, 45, 90};
int index = arr.length;
int n = 23;
//先定位
for(int i = 0; i < arr.length; i++) {
if(arr[i] >= n) {
index = i;
//记得找到位置及时break 避免出错
break;
}
}
//将arr中的元素拷贝到arr2中并且要跳过index的值
int[] arr2 = new int[arr.length+1];
for(int i = 0, j = 0; i < arr2.length; i++) {
if(i != index) {
arr2[i] = arr[j];
//这个j++很巧秒，可以画图理解为双指针思想。用来实现错位
j++;
} else {
arr2[i] = n;
}
}
arr = arr2;
//输出
System.out.println(Arrays.toString(arr));
}
}
三、查找
常用的查找有两种：
- 顺序查找
- 二分查找
//顺序查找
import java.util.Scanner;
public class SeqSearch {
public static void main(String[] args) {
/*
思路分析：
1. 定义一个字符串数组
2. 接收用户输入的数据，遍历数组，发现相同的就提示信息，并退出
3. 没有查找到怎么办？
思路1：
若查找不到，则索引到达了最后 依然不满足if条件 可使用else if(索引到达了最后)进行提示
优化：
新的编程思想：设置一个索引，若查找到则将索引改为当前索引值。没找到则为-1。
*/
int index = -1;
String[] names = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要查找的法王");
String name = sc.next();
for(int i = 0; i < names.length; i++) {
//关于字符串的比较 1. == 比较的是地址值 2. equals()方法 比较字符串的内容
if(name.equals(names[i])) {
System.out.println("恭喜你找到了"+name+"\n该法王下标为"+i);
index = i;
break;
} /*else if(i == names.length - 1) {
System.out.println("没有找到");
}*/
}
if(index == -1) {
System.out.println("没有找到");
}
}
}
四、多维数组
最常用的是二维数组。
二维数组可以看成 一个一维数组中的每个元素都是一个一维数组
二维数组的应用场景：
比如开发一个五子棋游戏，棋盘就需要二维数组来表示
-
案例
public class TwoDimensionalArray01 { //编写一个main方法 public static void main(String[] args) { /* 请用二维数组输出如下图形 0 0 0 0 0 0 0 0 1 0 0 0 0 2 0 3 0 0 0 0 0 0 0 0 */ //什么是二维数组： //解读： //1. 从定义形式上看 int[][] //2. 可以这样理解，原来的一维数组的每个元素是一维数组, 就构成二维数组 int[][] arr = { {0, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0,2, 0, 3, 0, 0}, {0, 0, 0, 0, 0, 0} }; //关于二维数组的关键概念 //(1)得到二维数组的元素个数 System.out.println("二维数组的元素个数=" + arr.length); //(2) 二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组的值 // 还需要再次遍历 //(3) 如果我们要访问第 (i+1)个一维数组的第j+1个值 arr[i][j]; // 举例 访问 3, 他是第3个一维数组的第4个值 arr[2][3] System.out.println("第3个一维数组的第4个值=" + arr[2][3]); //3 //输出二维图形 for(int i = 0; i < arr.length; i++) {//遍历二维数组的每个元素 //遍历二维数组的每个元素(数组) //解读 //1. arr[i] 表示 二维数组的第i+1个元素 比如arr[0]：二维数组的第一个元素 //2. arr[i].length 得到 对应的 每个一维数组的长度 for(int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + " "); //输出了一维数组 } System.out.println();//换行 } } }
二维数组的定义与使用：
-
动态初始化：
-
数组的定义
方法一：声明时直接开辟空间 类型[][] 数组名 = new 类型[长度][长度]; int a[][] = new int[2][3]; 方法二：先声明后开辟空间 //1. 声明数组 int arr[][]; //2. 开辟空间 arr = new int[2][3]; 方法三：列数不确定(每个一维数组的元素个数不确定) public class TwoDimensionalArray03 { //编写一个main方法 public static void main(String[] args) { /* 看一个需求：动态创建下面二维数组，并输出 i = 0: 1 i = 1: 2 2 i = 2: 3 3 3 一个有三个一维数组, 每个一维数组的元素是不一样的 */ //创建 二维数组，一个有3个一维数组，但是每个一维数组还没有开数据空间 int[][] arr = new int[3][]; for(int i = 0; i < arr.length; i++) {//遍历arr每个一维数组 //给每个一维数组开空间 new //如果没有给一维数组 new ,那么 arr[i]就是null arr[i] = new int[i + 1]; //遍历一维数组，并给一维数组的每个元素赋值 for(int j = 0; j < arr[i].length; j++) { arr[i][j] = i + 1;//赋值 } } System.out.println("=====arr元素====="); //遍历arr输出 for(int i = 0; i < arr.length; i++) { //输出arr的每个一维数组 for(int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + " "); } System.out.println();//换行 } } } -
内存
-
-
静态初始化
-
数组的定义
类型 数组名[][] = {{1, 2, 3},{1, 2, 3}}; int[][] arr = {{1, 2, 3},{4, 5},{7}}; /* 1. 定义了一个二维数组arr 2. arr有三个元素（每个元素都是一维数组） 3. 第一个一维数组有3个人元素， 第二个一维数组有3个元素，第三个一维数组有1个。 */
-
使用二维数组打印一个10行的杨辉三角
public class YangHui {
public static void main(String[] args) {
/*
1. 第一行有1个元素，第n行有n个元素
2. 每一行第一个元素和最后一个元素都是1
3. 每一行第二个元素都为行数-1
4. 每一行第三个元素都为上一行第二个元素+上一行第一个元素
5. 也就是说每一行第n个元素都为上一行第n(除了第一个和最后一个)个元素+上一行第n-1个元素
6. 使用二维数组，没个一维数组的元素个数不确定，但是规律为二维数组下标+1
*/
int[][] arr = new int[10][];
for(int i = 0; i < arr.length; i++) {
arr[i] = new int[i+1];
for(int j = 0; j < arr[i].length; j++) {
if(j == 0 || j == arr[i].length - 1) {
arr[i][j] = 1;
}else {
arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
}
}
}
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
二维数组的使用细节和注意事项
-
二维数组的声明方式有：
int[][] y 或者 int[] y 或者 int y[][] -
二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。
练习：
import java.util.Arrays;
public class Exercise {
public static void main(String[] args) {
/*
随机生成10个整数（1~100的范围）保存到数组并倒序打印以及求平均值、求最大值和最大值的下标、并查找里面是否有8
*/
int[] arr = new int[10];
int max = arr[0];
int maxIndex = 0;
int sum = arr[0];
int index = -1;
int num = 8;
for(int i = 0; i < arr.length; i++) {
arr[i] = (int)((Math.random()*100)+1);
}
System.out.println("原序打印：" + Arrays.toString(arr));
for(int i = 0; i < arr.length; i++) {
sum += arr[i];
if(arr[i] > max) {
max = arr[i];
maxIndex = i;
}
}
for(int i = 0; i < arr.length - 1; i++) {
for(int j = 0; j < arr.length - 1 - i; j++) {
if(arr[j] < arr[j+1]) {
int t = arr[j+1];
arr[j+1] = arr[j];
arr[j] = t;
}
}
}
System.out.println("降序打印：" + Arrays.toString(arr));
System.out.println("平均值：" + (double)sum / arr.length);
System.out.println("最大值为：" + max + "\t下标为：" + maxIndex);
for(int i = 0; i < arr.length; i++) {
if(num == arr[i]) {
index = i;
System.out.println("存在" + "下标为：" + index);
break;
}
}
if(index = -1) {
System.out.println("不存在");
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
