- 第5章 程序控制结构
- 顺序控制
- 分支控制
- 分支控制if-else
- switch分支结构
- 循环控制
- for循环控制
- while循环控制
- do..while循环控制
- 多重循环控制（难点！重点！）
- 跳转控制语句-break
- 跳转控制语句-continue
- 跳转控制语句-return
- 章节课后题
- 第6章 数组、排序和查找
- 数组
- 数组的使用
- 排序
- 冒泡排序法
- 查找
- 多维数组-二维数组
- 章节课后习题
- 日期
- 在程序中，程序运行的流程控制决定是如何执行的，使我们必须掌握的，主要有三大流程控制语句。
1)顺序控制
2)分支控制
3)循环控制
- 顺序控制介绍
程序从上到下逐行地执行，中间没有任何判断和跳转。
-
分支控制if-else介绍
让程序有选择的执行，分支控制有三种
1)单分支
2)双分支
3)多分支 -
单分支
√基本语法
if(条件表达式){
执行代码块；（可以有多条语句）
}
说明：当条件表达式为true时，就会执行{}的代码。如果为fasle，就不执行。特别说明，如果{}中只有一条语句，则可以不用{}，建议写上{}
- 双分支
√基本语法
if(条件表达式){
执行代码块1；
}
else{
执行代码块2;
}
说明： 当条件表达式成立，即执行代码块1，否则执行代码块2.
- 多分支
√多分支的流程图（重要！）
- 嵌套分支
√基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支。规范：不要超过3层（多层可读性不好）
√基本语法
√基本语法
√流程图
- switch注意事项和细节讨论
√细节2实例：
double c = 1.1; //程序运行报错，switch中表达式的返回值不能为double型
switch(c){
case 1.1 :
System.out.println("ok1");
break;
case 2.1:
System.out.println("ok2");
break;
default :
System.out.println("ok3");
}
- switch和if的比较
- 如果判断的具体数值不多，而且符合byte、short、int、char、enum【枚举】、String这6种类型。虽然两个语句都可以使用，建议使用switch语句。
- 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
- for循环说明
- for关键字，表示循环控制
- for有四要素：（1）循环变量初始化（2）循环条件（3）循环操作（4）循环变量迭代
- 循环操作，这里可以有多条语句，也就是我们要循环执行的代码
- 如果 循环语句（语句）只有一条语句，可以省略{}，建议不要省略
- for循环执行流程
- 注意事项和细节说明
1)循环条件是返回一个布尔值的表达式
2)for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略。
3)循环初始值可以有多条初始化语句，但是要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
特殊实例：
for(;;){ //表示无限循环，死循环
System.out.println("ok~");
}
细节3实例：
int count = 3;
for(int i = 0,j = 0; i < count; i++ , j += 2){
System.out.println("i=" + i + "j=" + j);
}
while循环控制
- while循环执行流程
- do…while循环执行流程
- 注意事项和细节说明
1)循环条件是返回一个布尔值的表达式
2)do…while循环是先执行，再判断，因此它至少执行一次
- 介绍
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层，否则代码可读性差】
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可以结束外层的当次循环，开始外层的下次循环
- 设外层循环次数为m次，内层为n次，则内层循环体实际上需求执行m*n次
3的实例：
for(int i = 1; i <= 7; i++){ //第一层循环7
for(int j = 1; j <= 2; j++){ //第二层循环2
System.out.println("ok~~"); //内层循环执行2*7=14
}
}
- 习题：打印空心金字塔
代码如下:
public class Stars{
//编写一个main方法
public static void main(String[] args){
int totallevel = 5; //表示层数
for(int i = 1; i <= totallevel; i++){ //i表示层数
//在输出*之前，还有输出 对应空格
for(int k = 1; k <= (totallevel - i); k++){
System.out.print(" ");
}
//控制打印每层的*个数
for(int j = 1; j <= 2 * i - 1; j++){
//当前行的第一个位置是*,最后一个位置也是*,最后一层输出*
if(j == 1 || j == 2 * i - 1 || i == totallevel){
System.out.print("*");
}else{ //其他情况输出空格
System.out.print(" ");
}
}
//每打印完一层*后，就换行println本身会换行
System.out.println("");
}
}
}
跳转控制语句-break
-
基本介绍
break语句用于终止某个语句块的执行，一般使用在switch或者循环[for,while,do-while]中 -
基本语法：
{ …
break;
…
} -
以while使用break为例的流程图
-
注意事项和细节说明:
-
实例:
abc1:
for(int j = 0; j < 4; j++){ //外层for
abc2:
for(int i = 0; i < 10; i++){ //内层for
if(i == 2){
break; //等价break abc2
}
System.out.println("i = " + i);
}
}
- 运行结果：
-
基本介绍
1)continue语句用于结束本次循环，继续执行下一次循环。
2)continue语句出现在多层嵌套的循环语句中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用的规则一样。 -
基本语法:
{ …
continue;
…
} -
流程图
- 介绍
return使用在方法，表示跳出所在的方法，在讲解方法的时候，会详细的介绍。注意：如果return写在mian方法，退出程序…
- 题目：输出小写的a-z以及大写的Z-A
for(char c1 = 'a'; c1 <= 'z'; c1++){ //输出小写的a-z
System.out.print(c1 + " ");
}
System.out.println("");
for(char c2 = 'Z'; c2 >= 'A'; c2--){ //输出大写的Z-A
System.out.print(c2 + " ");
}
第6章 数组、排序和查找
数组
- 数组介绍
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即数组就是一组数据
- 使用方式1-动态初始化
√数组的定义
数组类型 数组名[] = new 数组类型[大小]
int a[] = new int[5]; //创建了一个数组，名字a，存放5个int
√数组的引用（使用、访问、获取数组元素）
数组名[下标/索引/index] 比如：你要使用a数组的第3个数 a[2]数组的下标从0开始
- 使用方式2-动态初始化
√先声明数组
语法：数据类型 数组名[];也可以 数据类型[]数组名；
int a[];或者 int[] a;
√创建数组
语法：数组名 = new 数据类型[大小];
a = new int[10];
-
使用方式3-静态初始化
√初始化数组
语法：数据类型 数组名[] = {元素值，元素值…} -
数组使用注意事项和细节
1.数组是多个相同类型数据的组合，实现对这些数据的统一管理
2 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3.数组创建后，如果没有赋值，有默认值int 0,short 0,byte 0,long 0,float 0,double 0.0,char u0000(十六进制),boolean false,String null
4.使用数组的步骤1.声明数组并开辟空间2.给数组各个元素赋值3.使用数组
5.数组的下标是从0开始的。
6.数组下标必须在指定范围内使用，否则报：下标越界异常，比如int[] arr = new int[5];则有效下标为0-4
7.数组属引用类型，数组型数据是对象(object) -
数组赋值机制
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;
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]);
}
}
}
实现相关的操作：
- 数组拷贝
要求：(内容复制) - 数组反转
要求：把数组的元素内容反转。 - 数组添加/扩容
要求：实现动态地给数组添加元素效果，实现对数组扩容。
- 排序的介绍
排序是将多个数据，依指定的顺序进行排列的过程
排序的分类：
1.内部排序
指将需要处理的所有数据都加载到内部存储器中进行排序，包括（交换式排序法、选择式排序和插入式排序法）
2.外部排序法
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）
冒泡排序的基本思想是：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。
查找- 介绍：
在java中，我们常用的查找有两种：
1.顺序查找
2.二分查找[二分法]
-
使用方式1：动态初始化
1）语法：类型[][]数组名 = new 类型[大小][大小]
2）比如：inta[][] = new int [2][3]
3）二维数组在内存的存在形式
-
使用方式2：动态初始化
1）先声明：类型 数组名[][]；
2）再定义（开辟空间） 数组名 = new 类型[大小][大小]
3）赋值（有默认值，比如 int 类型的就是0） -
使用方式3：动态初始化-列数不确定
代码：
public class TwoDimensionalArray03{
//编写一个main方法
public static void main(String[] args){
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(); //换行
}
}
}
运行结果：
- 使用方式4：静态初始化
定义 类型 数组名[][] = {{值1,值2…},{值1,值2…},{值1,值2…}}
比如：
int [][] arr = {{1,1,1},{8,8,9},{100}};
- 二维数组使用细节和注意事项
1.一维数组的声明方式有：
int[]x 或者 int x[]
2.二维数组的声明方式有：
int[][] y 或者 int [] y[] 或者 int y [][]
3.二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如：map[][]是一个二维数组，map[][] = {{1,2},{3,4,5}}
由map[0]是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组。
- 下面数组定义正确的有 BD
A.String strs[] = {'a', 'b', 'c'}; //error,char ->String
B.String[] strs = {"a", "b", "c"}; //ok
C.String[] strs = new String{"a" "b" "c"}; //error
D.String[] strs = new String[]{"a""b""c"}; //ok
E.String[] strs = new String[]{"a""b""c"}; //error,编辑不通过
- 已知有个升序的数组，要求输入一个元素，该数组顺序依然是升序，比如：[10, 12, 45, 90],添加23后，数组为[10, 12, 23, 45, 90]
代码：
public class Homework04{
//编写一个main方法
public static void main(String[] args){
//先定义原数组
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; i++){
if(insertNum <= arr[i]){
index = i;
break;
}
}
//判断index的值
if(index == -1){ //说明还没有找到位置
index = arr.length;
}
//System.out.println("index = " + index);
//扩容
//先创建一个新的数组，大小 arr.length + 1
int[] arrNew = new int[arr.length + 1];
//下面老师准备将arr的元素拷贝到 arrNew,并且要跳过index位置
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;
System.out.println("=====插入后,arr数组的元素情况=====");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "t");
}
}
}
运行结果：
第5章 2022年4月17日-2022年4月20日
第6章 2022年4月21日-2022年4月25日
