JavaSE——Day3

1、流程控制

1.1 接受用户输入

在Java语言中有一个工具类Scanner，是一个简单的文本扫描程序，可以使用正则表达式解析基本类型和字符串，一般用户输入的键盘命令通过以下代码执行：

Scanner sc = new Scanner(System.in);
     String s = sc.next();  

关于Scanner类更详细的地方可以寻找API查看。

1.2 执行结构概述

任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本结构组合而成。
顺序结构：顺序结构是一种基本的控制结构，它按语句出现的顺序执行操作
分支结构：分支结构又被称为选择结构，根据条件成立与否来执行操作
循环结构：循环结构是一种重复的结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止

1.3 执行结构

1.3.1 if条件语句

if条件结构满足条件判断之后再处理：格式
if(条件语句){……}
if(条件语句){……} else if(条件语句)｛……｝
if(条件语句){……} else if(条件语句)｛……｝else｛……｝

1.3.2 switch结构

格式：
switch(表达式）｛
case 取值：
break;
case 取值：
break;
default 语句块 n+1;break;
｝
规则：
表达式的返回值必须是：int、byte、char、short、String；
case子句中的取值必须是常量，且所有case子句中的取值应该是不同的；
default子句是可选的；
break语句是用来执行一个case分支后使程序跳出switch语句，如果没写break，则继续往下面执行；
case后面的执行体可写可不写。

public static void main(String[] args) {
        while (true){
        System.out.println("请输入月份（1-12），来判断季节");
        Scanner inputMonth = new Scanner(System.in);
        int month = inputMonth.nextInt();
        if(month==0) break;
        switch (month) {
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;

            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;

            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;

            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
             default:
             	System.out.println("输入有误,请重新输入");
        }
    }}

1.3.2 循环语句-while循环

符合条件，循环执行；否则循环结束
特点：先判断，再执行
ps:一定要检查跳出语句能否正常执行，否则会造成死循环

语法：
while（条件表达式）｛
//语句块
}

1.3.3 循环语句-do-while循环

符合条件，循环执行；否则循环结束
特点：先执行，再判断
ps:一定要检查跳出语句能否正常执行，否则会造成死循环

语法：
do｛
//语句块
}while(条件表达式)

1.3.4 循环语句-for循环

for 格式：
for(定义循环变量；判断循环条件；更新循环变量){
//循环体
}
特殊格式：

for (;;){
            System.out.println("1");//一直输出1
        }

for (System.out.println("1");true;System.out.println(2)){
            System.out.println(3);//输出结构是1 3 2 3 2 3 2 ……
        }

ps：两个分好之间如果不填写默认为true，是一个死循环。

1.4 break与continue

break是用于终止本轮所有次循环，即不执行本次循环中break后面的语句，直接跳出循环
continue是用于终止本轮本次循环，即本次循环中continue后面的代码不执行，进入下一个循环入口的判断

1.5 如何结束多重循环

给想要退出的循环加一个别名：例

1.6 判断用户输入类型

如果要求输入数字时，用户输入非数字，则会报错，InputMismatchException 。加一个类型判断则满足交付标准

2、数组

2.1 数组格式

数组是相同数据类型的多个数据的容器。这些元素是线性顺序排列。
创建格式：
数据类型[] 数组名=new 数据类型[数组长度]；（常用）
数据类型[] 数组名={数据1，数据2……}（常用）
数据类型[] 数组名；（不常用）后续添加数据需使用new关键字
数据类型[] 数组名=new 数据类型[数组长度]{数据1，数据2……}；（不常用）

通过下标操作数组数据的方式
数组下标从0开始。
1、给数据某个下标赋值：数组名称[下标]=值；
2、从数组某个下标取值：数组名称[下标]

如何获取数组长度: 数组名称.length

2.2 数组问题

1、数组下标越界问题
2、空指针异常问题（数组未赋值）

2.3数组常用算法

冒泡排序：
原理：

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的
  数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

升序排列的口诀:
N个数字来排队
两两相比小靠前,
外层 循环length-1
内层循环length-i-1

降序排序的口诀:
N个数字来排队
两两相比大靠前,
外层 循环length-1
内层循环length-i-1

public static void main(String[] args) {
        int[] nums = {1, 3, 9, 5, 6, 7, 15, 4, 8};
        int temp;
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = 0; j < nums.length - i-1; j++) {
                if(nums[j]>nums[j+1]){
                    temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }

二分查找（折半查找）
概述：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺
序存储结构有序排列。
原理：
首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用
中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查
找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功，
直到子数组不存在为止，表示查找不成功

步骤：1、确定查找的范围 最小~最大
2、计算中间下标 (最小下标+最大下标)/2
3、比较中间下标数据，中间数据较大，则最大下标等于中间下标-1
比较中间下标数据，中间数据较小，则最小下标等于中间下标+1
4、当最小下标大于最大下标时，说明数据不存在

public static void main(String[] args) {
        int[] nums = {1, 3, 9, 5, 6, 7, 15, 4, 8};
        //冒泡排序
        int temp;
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");
        }
        //二分查找
        int n = 6;
        int minIndex = 0;//最小范围下标
        int maxIndex = nums.length - 1;//最大范围下标
        int centerIndex = (minIndex + maxIndex) / 2;//中间数据下标
        while (true) {
            if (nums[centerIndex] > n) {
                //中间数据大于n
                maxIndex=centerIndex-1;
            } else if (nums[centerIndex] < n) {
                //中间数据小于n
                minIndex=centerIndex+1;
            } else {
                //中间数据等于n
                break;
            }
            if (minIndex>maxIndex){
                centerIndex=-1;
            }
            //更新中间数据下标
            centerIndex=(minIndex+maxIndex)/2;
        }
        System.out.println("\n"+n+"排序后下标是"+centerIndex);

    }

2021年8月16日