java零基础Ⅰ-- 5.数组、排序和查找
java零基础Ⅰ-- 数组、排序和查找
- 数组
-
- 数组介绍
- 数组快速入门
- 数组使用方式1 - 动态初始化
- 数组使用方式2 - 动态初始化
- 数组使用方式3 - 静态初始化
- 数组使用注意事项和细节
- 数组应用案例
- 数组赋值机制
- 数组拷贝
- 数组反转
- 数组添加/扩容
- 排序
-
- 排序的介绍
- 冒泡排序法
- 冒泡排序法案例
- 查找
-
- 介绍
- 多维数组
-
- 二维数组
- 快速入门案例
- 使用方式1：动态初始化
- 使用方式2：动态初始化
- 使用方式3：动态初始化 - 列数不确定
- 使用方式4：静态初始化
- 应用案例
- 二维数组使用细节和注意事项
- 二维数组练习
- 作业
连接视频
数组
为什么需要数组
一个养鸡场有6只鸡，它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50gk。请求问这6只鸡总体重是多少？平均体重是多少？请你编写一个程序。
//数组的引出
public class Array01{
//编写一个main方法
public static void main(String[] args){
/*
一个养鸡场有6只鸡，它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50gk。
请求问这6只鸡总体重是多少？平均体重是多少？
思路分析：
传统方法： 定义6个变量 double，加起来 求总体重 和 平均体重
传统方法的问题：
6只鸡 -> 100只鸡 -> 1000只鸡
引出新的技术： 数组
*/
double hen1 = 3;
double hen2 = 5;
double hen3 = 1;
double hen4 = 3.4;
double hen5 = 2;
double hen6 = 50;
double totalWeight = hen1 + hen2 + hen3 + hen4 + hen5 + hen6;
double avgWeeight = totalWeight / 6;
System.out.println("总体重=" + totalWeight);
System.out.println("平均体重=" + avgWeeight);
}
}
数组介绍
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型 。
即：数（数据）组（一组）就是一组数据
数组快速入门
比如，我们可以用数组来解决上一个问题。
//数组的引出
public class Array01{
//编写一个main方法
public static void main(String[] args){
/*
一个养鸡场有6只鸡，它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50gk。
请求问这6只鸡总体重是多少？平均体重是多少？
思路分析：
传统方法： 定义6个变量 double，加起来 求总体重 和 平均体重
传统方法的问题：
6只鸡 -> 100只鸡 -> 1000只鸡
引出新的技术： 数组
*/
// double hen1 = 3;
// double hen2 = 5;
// double hen3 = 1;
// double hen4 = 3.4;
// double hen5 = 2;
// double hen6 = 50;
// double totalWeight = hen1 + hen2 + hen3 + hen4 + hen5 + hen6;
// double avgWeeight = totalWeight / 6;
// System.out.println("总体重=" + totalWeight);
// System.out.println("平均体重=" + avgWeeight);
//比如，我们可以用数组来解决上一个问题。
//
//定义一个数组
//1. double[] 表示 是double[]类型的数组，数组名 hens
//2. {3,5,1,3.4,2,50} 表示数组的值/元素
// 依次表示数组的的第几个元素
double[] hens = {3,5,1,3.4,2,50};
// 遍历数组得到数组的所有元素的和 for循环
// 1. 我们可以通过 hens[下标] 来访问数组的元素
// 下标是 0 开始编号的，比如第1个元素就是 hens[0]
// 第2个元素就是 hens[1] 依次类推
// 2. 通过for循环就可以访问数组的元素/值
// 3. 使用一个变量 totalWeight 将各个元素累积
System.out.println("===使用数组解决=====");
double totalWeight = 0;
// 可以通过 数组名.length 得到数组的大小/长度
int length = hens.length;
System.out.println("数组的长度=" + length);
for(int i = 0; i < length; i++){
//System.out.println("第" + (i+1) + "个元素的值=" + hens[i]);
totalWeight += hens[i];
}
System.out.println("总体重=" + totalWeight);
System.out.println("平均体重=" + totalWeight / length);
}
}
数组使用方式1 - 动态初始化
数组的定义
数据类型 数组名[] = new 数据类型[大小]
int a[] = new int[5];//创建了一个数组，名字a，存放5个int
说明：这是定义数组的一种方法，
数组的引用(使用/访问/获取数组元素)
数组名[下标/索引/index] 比如：你要使用a数组的第3个数 a[2]
数组的下标是从 0 开始的
快速入门案例
循环输入5个成绩，保存到double数组，并输出
import java.util.Scanner;
public class Array02{
//编写一个main方法
public static void main(String[] args){
//演示： 数据类型 数组名[] = new 数据类型[大小]
// 循环输入5个成绩，保存到double数组，并输出
// 步骤
//1. 创建一个 double 数组 大小为 5
double[] scores = new double[5];
//2. 循环输入
// scores.length 表示数组的大小/长度
Scanner sc = new Scanner(System.in);
for(int i = 0; i < scores.length; i++){
System.out.println("请输入第 " + (i+1) +" 个元素的值");
scores[i] = sc.nextDouble();
}
//输出，遍历数组
System.out.println("===数组的元素/值的情况如下：===");
for(int i = 0; i < scores.length; i++){
System.out.println("第 " + (i+1) +" 个元素的值=" + scores[i]);
}
}
}
数组使用方式2 - 动态初始化
先声明数组
语法：数据类型 数组名[]; 也可以 数据类型[] 数组名;
int a[]; 或者 int[] a;
创建数组
语法：数组名 = new 数据类型[大小];
a = new int[10];
案例演示
//先声明数组，再 new 分配空间
double scores[]; //声明数组 这时 scores[] 是 null
scores = new double[5];// 分配内存空间，可以存放数组
//2. 循环输入
// scores.length 表示数组的大小/长度
Scanner sc = new Scanner(System.in);
for(int i = 0; i < scores.length; i++){
System.out.println("请输入第 " + (i+1) +" 个元素的值");
scores[i] = sc.nextDouble();
}
数组使用方式3 - 静态初始化
初始化数组
语法：数据类型 数组名[] = {元素值,元素值…};
int a[] = {1,2,3,4,5}; 如果知道数组有多少元素，具体值
上面的用法相当于：
int a[] = new int[5];
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4] = 5;
快速入门案例
double hens[] = {3,5,1,3.4,2,50};
等价
double hens[] = new double[6];
hens[0] = 3;hens[1] = 5;hens[2] = 1;hens[3] = 3.4;hens[4] = 2;hens[5] = 50;
double hens[] = {3,5,1,3.4,2,50};
//等价
double hens[] = new double[6];
hens[0] = 3;
hens[1] = 5;
hens[2] = 1;
hens[3] = 3.4;
hens[4] = 2;
hens[5] = 50;
数组使用注意事项和细节
- 数组是多个相同类型数据的组合，实现对这些数据的统一管理
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
- 数组创建后，如果没有赋值，有默认值 int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000，boolean false，String null
- 使用数组的步骤：1.声明数组并开辟空间大小 2.给数组各个元素赋值 3.使用数组
- 数组的下标是从 0 开始的
- 数组下标必须在指定范围内使用，否则报：下标越界异常；比如 int[] arr = new int[5]; 则有效下标为0-4
- 数组属引用类型，数组型数据是对象（Object）
public class ArrayDetail{
//编写一个main方法
public static void main(String[] args){
//1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
//int[] arr1 = {1,2,3,4,20,1.1};//错误 double -> int
//int[] arr1 = {1,2,3,4,20,"helo"};//错误 String -> int
double[] arr2 = {1.1,2.2,3.3,20};//正确 int -> double
//2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
String[] arr3 = {"北京","jack","zzp"};
//3. 数组创建后，如果没有赋值，有默认值
//int 0，short 0，byte 0，long 0，
//float 0.0，double 0.0，char \u0000
//boolean false，String null
short[] arr4 = new short[3];// arr4[0]=0 arr4[1]=0 arr4[2]=0
System.out.println("== 数组arr4 ==");
for(int i = 0; i < arr4.length; i++){
System.out.println(arr4[i]);// 0
}
//6.数组下标必须在指定范围内使用，
//否则报：下标越界异常；
//比如 int[] arr = new int[5]; 则有效下标为0-4
//即数组的下标/索引 最小 0 最大 数组长度-1（4）
int[] arr = new int[5];
System.out.println(arr[5]);//编译正确 运行异常 数组越界 下标越界异常
}
}
数组应用案例
1、创建一个char类型的26个元素的数组，分别放置’A’-‘Z’。使用for循环访问所有的元素并打印出来。提示：char类型数据运算 ‘A’ + 1 -> ‘B’
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++){
System.out.print(chars[i] + " ");
}
}
}
2、请求出一个数组int[]的最大值 {4,-1,9,10,23}，并得到对应的下标。
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];// 假定 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);
System.out.println("maxIndex = " + maxIndex);
}
}
数组赋值机制
1、基本数据类型赋值，这个值就是具体的数据，而且相互不影响
int n1 = 2; int n2 = n1;
2、数组在默认情况下是引用传递，赋的值是内存地址。
案例：
int[] arr1 = {1,2.3};
int arr2 = arr1;
public class ArrayAssign{
//编写一个main方法
public static void main(String[] args){
//基本数据类型赋值 赋值方式为值拷贝
//n2 的变化，不会影响到n1的值
int n1 = 10;
int n2 = n1;//拷贝 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.print(arr1[i] + " ");//10,2,3
}
System.out.println();
//arr2的值
System.out.println("==arr2的元素==");
for(int i = 0; i < arr2.length; i++){
System.out.print(arr2[i] + " ");//10,2,3
}
}
}
示意图：
数组拷贝
实现数组拷贝
将 int[] arr1 = {10,20,30}; 拷贝到 arr2数组 要求数据空间是独立的
public class ArrayCopy{
//编写一个main方法
public static void main(String[] args){
// 将 int[] arr1 = {10,20,30}; 拷贝到 arr2数组 要求数据空间是独立的
int[] arr1 = {10,20,30};
//int[] arr2 = arr1;//拷贝 不行
//创建一个新的数组arr2，开辟新的空间
//大小 = arr1.length;
int[] arr2 = new int[arr1.length];
//遍历arr1，把每个元素拷贝对应的元素位置
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.print(arr1[i] + " ");//10,20,30
}
System.out.println();
//arr2的值
System.out.println("==arr2的元素==");
for(int i = 0; i < arr2.length; i++){
System.out.print(arr2[i] + " ");//100,20,30
}
}
}
示意图：
数组反转
要求：把数组的元素内容反转。
arr {11,22,33,44,55,66} -> {66,55,44,33,22,11}
方式1：通过找规律反转
方式2：使用逆序赋值方式
public class ArrayReverse{
//编写一个main方法
public static void main(String[] args){
//要求：把数组的元素内容反转。ArrayReverse.java
//arr {11,22,33,44,55,66} -> {66,55,44,33,22,11}
int[] arr = {11,22,33,44,55,66};
//思路：
//方式1：通过找规律反转
//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 < len; i++){
System.out.print(arr[i] + " ");//66,55,44,33,22,11
}
int[] arr1 = {11,22,33,44,55,66};
//方式2：使用逆序赋值方式
//思路
//1. 先创建一个新的数组 arr2 大小 arr1.length
//2. 逆序遍历 arr1 ，然后将每个元素拷贝到 arr2的元素（顺序）
//3. 建议增加一个循环变量 j -> 0 -> 5
int[] arr2 = new int[arr.length];
for(int i = arr1.length - 1,j = 0; i >= 0; i--,j++){//逆序遍历 arr1
arr2[j] = arr1[i];
}
//4. 当for 循环结束，arr2 就是一个逆序的数组 {66,55,44,33,22,11}
//5. 让 arr1 指向arr2 数组空间 此时 arr1原来的数据空间就没有变量引用
// 会被当做垃圾，销毁
arr1 = arr2;
System.out.println();
//6. 输出
System.out.println("==使用逆序赋值 arr1数组==");
for(int i = 0; i < arr1.length; i++){
System.out.print(arr1[i] + " ");//66,55,44,33,22,11
}
}
}
数组添加/扩容
要求：实现动态的给数组添加元素效果，实现对数组扩容。
1）原始数组使用静态分配 int[] arr = {1,2,3};
2）增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
public class ArrayAdd{
//编写一个main方法
public static void main(String[] args){
/*
要求：实现动态的给数组添加元素效果，实现对数组扩容。
1）原始数组使用静态分配 int[] arr = {1,2,3};
2）增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
3）用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？ y/n
思路分析：
1. 定义初始数组 int[] arr = {1,2,3};
int[3] = 4; //不行 下标越界
2. 定义一个新的数组 int arrNew = new int[arr.length];
3. 遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
4. 将 4 赋值给 arrNew[arrNew.length - 1] = 4;把4赋给arrNew最后一个元素
5. 让 arr指向 arrNew ； arr = arrNew; 那么 原来的arrNew数组就被销毁了
*/
int[] arr = {1,2,3};
int[] arrNew = new int[arr.length + 1];
//遍历 arr数组 依次将arr的元素拷贝到 arrNew数组
for(int i = 0; i < arr.length; i++){
arrNew[i] = arr[i];
}
//把4赋给arrNew最后一个元素
arrNew[arrNew.length - 1] = 4;
//让 arr指向 arrNew,
arr = arrNew;
System.out.println("==arr数组扩容后的元素==");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
}
}
3）用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？ y/n
import java.util.Scanner;
public class ArrayAdd02{
//编写一个main方法
public static void main(String[] args){
/*
要求：实现动态的给数组添加元素效果，实现对数组扩容。
1）原始数组使用静态分配 int[] arr = {1,2,3};
2）增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
3）用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？ y/n
思路分析：
1. 定义初始数组 int[] arr = {1,2,3};
int[3] = 4; //不行 下标越界
2. 定义一个新的数组 int arrNew = new int[arr.length];
3. 遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
4. 将 4 赋值给 arrNew[arrNew.length - 1] = 4;把4赋给arrNew最后一个元素
5. 让 arr指向 arrNew ； arr = arrNew; 那么 原来的arrNew数组就被销毁了
6. 创建一个 Scanner 可以接收用户输入
7. 因为用户时候退出，不确定，使用 do while() + break 来控制
*/
Scanner sc = new Scanner(System.in);
//初始化数组
int[] arr = {1,2,3};
do{
int[] arrNew = new int[arr.length + 1];
//遍历 arr数组 依次将arr的元素拷贝到 arrNew数组
for(int i = 0; i < arr.length; i++){
arrNew[i] = arr[i];
}
System.out.println("请输入你要添加的元素");
int addNum = sc.nextInt();
//把4赋给arrNew最后一个元素
arrNew[arrNew.length - 1] = addNum;
//让 arr指向 arrNew,
arr = arrNew;
System.out.println("==arr数组扩容后的元素==");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
//问用户是否继续添加
System.out.println("是否继续添加 y/n");
char key = sc.next().charAt(0);
if(key == 'n'){//如果输入n 就退出
break;
}
}while(true);
System.out.println("你退出的程序...");
}
}
练习
有一个数组 {1,2,3,4,5} ，可以将该数组进行缩减，提示用户是否继续缩减，每次减最后那个元素。当只剩最后一个元素，提示，不能再缩减。
import java.util.Scanner;
public class ArrayReduce{
//编写一个main方法
public static void main(String[] args){
/*
有一个数组 {1,2,3,4,5} ，可以将该数组进行缩减，
提示用户是否继续缩减，每次减最后那个元素。
当只剩最后一个元素，提示，不能再缩减。
*/
//初始化数组
int[] arr = {1,2,3,4,5};
Scanner sc = new Scanner(System.in);
do{
if(arr.length == 1){
System.out.println("不能再缩减");
break;
}
System.out.println("否继续缩减 y/n");
char key = sc.next().charAt(0);
if(key == 'n'){//如果输入n 就退出
break;
}
int[] arrNew = new int[arr.length - 1];
//遍历 arr数组 依次将arr的元素拷贝到 arrNew数组
for(int i = 0; i < arrNew.length; i++){
arrNew[i] = arr[i];
}
arr = arrNew;
System.out.println("==arr数组缩减后的元素==");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
}while(true);
System.out.println("你退出的程序...");
}
}
排序
排序的介绍
排序是将多个数据，依指定的顺序进行排序的过程
排序的分类：
1、内部排序：
指将需要处理的所有数据都加载内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）；
2、外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）。
冒泡排序法
冒泡排序法（Bubble Sorting）的基本思想是：通过对待排序列从后到前（从下标较大元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。
冒泡排序法案例
下面我们举一个具体的案例来说明冒泡法。我们将五个无序：24,69,80,57,13 使用冒泡排序法将其排成一个从小到大的有序数列
public class BubbleSort{
//编写一个main方法
public static void main(String[] args){
//我们将五个无序：24,69,80,57,13
//使用冒泡排序法将其排成一个从小到大的有序数列
//
//思路：
//化繁为简，先死后活
/*
数组 [24,69,80,57,13]
第1轮排序： 目标把最大数放在最后
第1次比较[24,69,80,57,13]
第2次比较[24,69,80,57,13]
第3次比较[24,69,57,80,13]
第4次比较[24,69,57,13,80]
*/
int[] arr = {24,69,80,57,13};
int temp = 0;//用于辅助交换的变量
boolean flag = true;//设置默认是有序的状态 true
// 将多轮排序使用外层循环包括起来即可
//先死后活 => 4 就是 arr.length - 1
for(int i = 0; i < arr.length - 1; i++){//外层循环4次
for(int j = 0; j < arr.length - 1 - i; j++){
//如果前面的数 > 后面的数，就交换
if(arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false;// 交换了 false
}
}
System.out.println("\n==第"+ (i+1) +"轮==");
for(int j = 0; j < arr.length; j++){
System.out.print(arr[j] + " ");
}
//如果
if(flag){//判断是否有序的
break;
}
}
// for(int j = 0; j < 4; j++){
// //如果前面的数 > 后面的数，就交换
// if(arr[j] > arr[j + 1]){
// temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
// }
// }
// System.out.println("==第1轮排序==");
// for(int j = 0; j < arr.length; j++){
// System.out.print(arr[j] + " ");
// }
// /*
// 第2轮排序： 目标把第二大数放在倒数第二位置
// 第1次比较[24,69,57,13,80]
// 第2次比较[24,57,69,13,80]
// 第3次比较[24,57,13,69,80]
// */
// for(int j = 0; j < 3; j++){
// //如果前面的数 > 后面的数，就交换
// if(arr[j] > arr[j + 1]){
// temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
// }
// }
// System.out.println("\n==第2轮排序==");
// for(int j = 0; j < arr.length; j++){
// System.out.print(arr[j] + " ");
// }
// 第3轮排序： 目标把第3大数放在倒数第3位置
// 第1次比较[24,57,13,69,80]
// 第2次比较[24,13,57,69,80]
// for(int j = 0; j < 2; j++){
// //如果前面的数 > 后面的数，就交换
// if(arr[j] > arr[j + 1]){
// temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
// }
// }
// System.out.println("\n==第3轮排序==");
// for(int j = 0; j < arr.length; j++){
// System.out.print(arr[j] + " ");
// }
// /*
// 第4轮排序： 目标把第4大数放在倒数第4位置
// 第1次比较[13,24,69,57,80]
// */
// for(int j = 0; j < 1; j++){
// //如果前面的数 > 后面的数，就交换
// if(arr[j] > arr[j + 1]){
// temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
// }
// }
// System.out.println("\n==第4轮排序==");
// for(int j = 0; j < arr.length; j++){
// System.out.print(arr[j] + " ");
// }
}
}
查找
介绍
在java中，我们常用的查找有两种：
- 顺序查找
- 二分查找
案例演示：
1、有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数的游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】要求：如果找到了，就提示找到，并给出下标值
import java.util.Scanner;
public class SeqSearch{
//编写一个main方法
public static void main(String[] args){
/*
有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数的游戏：
从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
要求：如果找到了，就提示找到，并给出下标值
思路分析：
1. 定义一个字符串数组
2. 接收用户输入，遍历数组，逐一比较，如果有 则提示信息 并退出
*/
Scanner sc = new Scanner(System.in);
//定义一个字符串数组
String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
System.out.println("请输入名称");
String findName = sc.next();
//逐一比较，如果有 则提示信息 并退出
int index = -1;
for(int i = 0; i < names.length; i++){
//比较 字符串比较 equals 如果要找的名字就是当前元素
if(findName.equals(names[i])){
System.out.println("你找到 " + findName );
System.out.println("下标为= " + i );
index = i;
break;//退出
}
}
if(index == -1){//未找到
System.out.println("没有找到：" + findName);
}
}
}
2、请对一个有序数组进行二分查找{1,8,10,89,1000,1234}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示“没有这个数”。
import java.util.Scanner;
public class SeqSearch02{
//编写一个main方法
public static void main(String[] args){
/*
请对一个有序数组进行二分查找{1,8,10,89,1000,1234}，
输入一个数看看该数组是否存在此数，并且求出下标，
如果没有就提示“没有这个数”
*/
Scanner sc = new Scanner(System.in);
//定义一个字符串数组
int[] numbers = {1,8,10,89,1000,1234};
System.out.println("请输入一个整数");
int number = sc.nextInt();
int count = numbers.length / 2;
int index = -1;
for(int i = 0; i < count; i++){
if(numbers[count] <= number){
if(numbers[numbers.length -1 - i] == number){
index = numbers.length -1 - i;
}
}else {
if(numbers[i] == number){
index = i;
}
}
}
if(index == -1){//未找到
System.out.println("没有找到：" + number);
}else{
System.out.println("找到该数：" + number + " 下标=" + index);
}
}
}
多维数组
二维数组
二维数组的应用场景
比如我们开发一个五子棋，棋盘就是需要二维数组来表示
快速入门案例
请用二维数组输出如下的图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
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();//换行
}
}
}
使用方式1：动态初始化
1）语法：
类型[][] 数组名 = new 类型[大小][大小]
2）比如：
int a[][] = new int[2][3];
3）使用演示
4）二维数组在内存的存在形式
public class TwoDimensionalArray02{
//编写一个main方法
public static void main(String[] args){
int arr[][] = new int[2][3];
arr[1][1] = 8;
//遍历arr数组
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();
}
}
}
内存示意图：
使用方式2：动态初始化
1）先声明：
类型 数组名[][];
2）再定义（开辟空间）
数组名 = new 类型[大小][大小]
3）赋值（有默认值，比如 int 类型的就是0）
int arr[][];//先声明二维数组
arr = new int[2][3];//在开辟空间
使用方式3：动态初始化 - 列数不确定
1）看一个需求：动态创建下面二维数组，并输出
2）完成该案例
public class TwoDimensionalArray03{
//编写一个main方法
public static void main(String[] args){
/*
看一个需求：动态创建下面二维数组，并输出
i = 1: 1
i = 1: 2 2
i = 2: 3 3 3
一有三个一维数组，每一个一维数组的元素是不一样的
*/
int[][] arr = new int[3][];//创建二维数组 一共有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++){
for(int j = 0; j < arr[i].length; j++){//对每个一维数组遍历
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
使用方式4：静态初始化
1、定义
类型 数组名[][] = {{值1,值2,值3…},{值1,值2,值3…}{值1,值2,值3…}…};
2、使用即可[固定方式访问]
比如：
int[][] arr = {{1,1,1},{8,8,9},{100}};
1. 定义了一个二维数组
2. arr有三个元素（每个元素都是一维数组）
3. 第一个一维数组有3个元素，
第二个一维数组有3个元素，
第三个一维数组有1个元素
案例：
int[][] arr = {{4,6},{1,4,5,7},{-2}}; 遍历该二维数组，并得到和
public class TwoDimensionalArray04{
//编写一个main方法
public static void main(String[] args){
// int[][] arr = {{4,6},{1,4,5,7},{-2}}; 遍历该二维数组，并得到和
int[][] arr = {{4,6},{1,4,5,7},{-2}};
int sum = 0;
//遍历arr数组
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){//对每个一维数组遍历
System.out.print(arr[i][j] + " ");
sum += arr[i][j];
}
System.out.println();
}
System.out.println("sum = " + sum);
}
}
应用案例
1、使用二维数组打印一个 10 行杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
...
提示：
1、第一行有 1 个元素，第 n 行有 n 个元素
2、每一行的第一个元素和最后一个元素都是 1
3、从第三行开始，对于非第一个元素和最后一个元素的值，arr[i][j]
arr[i][j] = arr[i - 1][j] + arr[i-1][j-1];//规律
public class YangHui{
//编写一个main方法
public static void main(String[] args){
/*
使用二维数组打印一个 10 行杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
...
提示：
1、第一行有 1 个元素，第 n 行有 n 个元素
2、每一行的第一个元素和最后一个元素都是 1
3、从第三行开始，对于非第一个元素和最后一个元素的值，arr[i][j]
arr[i][j] = arr[i - 1][j] + arr[i-1][j-1];//规律
*/
int[][] yanhui = new int[10][];
for(int i = 0; i < yanhui.length; i++){//遍历数组的每个元素
//给每个一维数组开辟空间
yanhui[i] = new int[i + 1];
//给每个一维数组赋值
for(int j = 0; j < yanhui[i].length; j++){
//每一行的第一个元素和最后一个元素都是 1
if(j == 0 || j == yanhui[i].length - 1){
yanhui[i][j] = 1;
}else{//中间的元素
yanhui[i][j] = yanhui[i-1][j] + yanhui[i-1][j-1];
}
}
}
//输出杨辉三角
for(int i = 0; i < yanhui.length; i++){
for(int j = 0; j < yanhui[i].length; j++){//对每个一维数组遍历
System.out.print(yanhui[i][j] + "\t");
}
System.out.println();
}
}
}
二维数组使用细节和注意事项
1、一维数组的声明方式有
int[] x 或者 int x[]
2、二维数组的声明方式有
int[][] y 或者 int[] y[] 或者 int y[][]
3、二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。 比如：
int map[][] 是一个二维数组
int map[][] = {{1,2},{3,4,5}};
由 map[0] 是一个含有两个元素的一维数组，map[1] 是一个含有三个元素的一维数组构成，我们也称之为列数不等的二维数组。
二维数组练习
声明：int[] x,y[]; 以下选项允许通过编译的是：（ b,e）
说明： x 是int类型一维数组，y 是int类型的二维数组
a) x[0] = y;//错误 int[][] -> int
b) y[0] = x;//正确 int[] -> int[]
c) y[0][0] = x;//错误 int[] -> int
d) x[0][0] = y;//错误 x[0][0] 是错误
e) y[0][0] = x[0];//正确 int -> int
f) x = y;//错误 int[][] -> int[]
作业
1、下面数组定义正确的有：（B,D）
A. String strs[] = {'a','b','c'};//错误 char -> String
B. String[] strs = {"a","b","c"};//正确 String -> String
C. String[] strs = new String{"a","b","c"};//错误 不能new String
D. String strs[] = new String[]{"a","b","c"};//正确
E. String[] strs = new String[3]{"a","b","c"};//错误 new String[3]写了大小 就不能静态赋值 编译不通过
2、写出结果
String foo = "blue";
boolea[] bar = new boolean[2];//默认值是 false dar[0] = false
for(bar[0]){//false
foo = "green";
}
System.out.println(foo);//blue
3、以下代码的输出结果为
int num = 1;
while(num < 10){
System.out.println(num);
if(num > 5){
break;
}
num += 2;
}
//输出结果:
1
3
5
7
4、已知有个升序的数组，要求插入一个元素，该元素顺序依然是升序，比如：[10,12,45,90],然后为 [10,12,23,45,90]
public class HomeWork04{
//编写一个main方法
public static void main(String[] args){
/*
已知有个升序的数组，要求插入一个元素，该元素顺序依然是升序，
比如：[10,12,45,90],然后为 [10,12,23,45,90]
思路分析：本质数组扩容 + 定位
1. 我们先确定 添加数应该插入到哪个索引
2. 然后扩容
*/
//先定义原数组
int[] arr = {10,12,45,90};
int insertNum = 23;
int index = -1; //index就是要插入的位置
//遍历arr数组，如果发现 insertNum <= arr[i],说明 i 就是要插入的位置
//使用 index 保留 index = i;
//如果遍历完后，没有发现 insertNum <= arr[i]，说明 index = arr.length;
//即：添加到arr最后
for(int i = 0; i < arr.length - 1; i++){
if(insertNum <= arr[i]){
index = i;
break;//找到位置，就退出
}
}
//判断index 的值
if(index == -1){//说明没有找到位置
index = arr.length;
}
//System.out.print("index = " + index);
//扩容
//先创建一个新的数组，大小 arr.length + 1
int[] arrNew = new int[arr.length + 1];
//将arr的元素拷贝到 arrNew ，并且要跳过 index位置
/*
分析：
int[] arr = {10,12,45,90};
arrNew = { };
*/
//i 控制arrNew的下标 j 用来控制arr数组的下标
for(int i = 0,j = 0; i < arrNew.length; i++){
if(i != index){//说明可以把 arr的元素拷贝arrNew
arrNew[i] = arr[j];
j++;
}else {//i 这个位置就是要插入的数
arrNew[i] = insertNum;
}
}
//让arr 指向 arrNew ，原来的数组就成为垃圾 销毁
arr = arrNew;
//遍历arr数组
System.out.println("==插入后arr数组的元素==");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i]+ " ");
}
}
}
5、随机生成10整数（1-100的范围）保存到数组，并倒序打印及求平均值、求最大值和最大下标、并查找里面是有 8
public class HomeWork05{
//编写一个main方法
public static void main(String[] args){
/*
随机生成10整数（1-100的范围）保存到数组，
并倒序打印及求平均值、求最大值和最大下标、
并查找里面是有 8
*/
int[] arr = new int[10];
//(int)(Math.random() * 100) + 1 生成 随机数 1-100
for(int i = 0; i < arr.length; i++){
arr[i] = (int)(Math.random() * 100) + 1;
}
System.out.println("==arr的元素的值===");
for(int i = 0; i < arr.length; i++){
System.out.print( arr[i] +" ");
}
System.out.println("\n==arr的元素倒序打印===");
for(int i = arr.length -1; 0 <= i; i--){
System.out.print( arr[i] +" ");
}
//平均值、求最大值和最大下标
int sum = arr[0];
int max = arr[0];
int maxIndex = 0;
for(int i = 1; i < arr.length; i++){
sum += arr[i];
if(max < arr[i]){//说明max不是最大值，就变化
max = arr[i];
maxIndex = i;
}
}
System.out.println("\n最大值=" + max);
System.out.println("最大下标=" + maxIndex);
System.out.println("平均值=" + (sum / arr.length));
//并查找里面是有 8 使用顺序查找
int findNum = 8;
int index = -1;//如果找到，就把下标记录到 i
for(int i = 1; i < arr.length; i++){
if(findNum == arr[i]){
index = i;
System.out.println("找到数" + findNum + " 下标=" + i);
break;
}
}
if(index == -1){
System.out.println("未找到数 " + findNum);
}
}
}
6、试写出一下代码的打印结果
char[] arr1 = {'a','z','b','c',};
char[] arr2 = arr1;
arr1[2] = '中';
for(int i = 0; i < arr2.length; i ++){
System.out.println(arr1[i] + ", " + arr2[i])
}
public class HomeWork06{
//编写一个main方法
public static void main(String[] args){
char[] arr1 = {'a','z','b','c',};
char[] arr2 = arr1;
arr1[2] = '中';
for(int i = 0; i < arr2.length; i ++){
System.out.println(arr1[i] + "," + arr2[i]);
}
}
}
7、写出冒泡排序的代码
public class HomeWork07{
//编写一个main方法
public static void main(String[] args){
//冒泡排序
//要求从大到小
int[] arr = {9,6,20,21,5};
int temp = 0;//辅助交换
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]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//输出
System.out.print(" ==从大到小排序=\n");
for(int i = 0; i < arr.length; i ++){
System.out.print(arr[i] + " ");
}
}
}
