Java学习Day5（第二章基本结束）

昨天的代码补充（if-else,随机数）

/*
编写程序，由键盘输入三个整数分别存入变量num1,num2,num3。
对它们进行排序(使用 if-else if-else)，并且从小到大输出

说明：
1.if-else结构可以相互嵌套使用
2.如果if-else结构中的执行语句中只有一行时，相应的一对{}大括号可以省略，但不建议这样做
*/

import java.util.Scanner;
class IfTest2 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入第一个整数");
        int num1 = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int num2 = scanner.nextInt();
        System.out.println("请输入第三个整数");
        int num3 = scanner.nextInt();

        if (num1 > num2){
            if(num3 > num1){
                System.out.println(num2 + "," + num1 + "," + num3);
            }else if (num3 <= num2){
                System.out.println(num3 + "," + num2 + "," + num1);
            }else{
                System.out.println(num2 + "," + num3 + "," + num1);            
            }

        }else{
            if(num3 > num2){
                System.out.println(num1 + "," + num2 + "," + num3);
            }else if (num3 <= num1){
                System.out.println(num3 + "," + num1 + "," + num2);            
            }else{
                System.out.println(num1 + "," + num3 + "," + num2);
            }        
        }

        //如何获取一个随机数：10 - 99
        double value = (int)(Math.random()*90) + 10;//[0.0,1.0) -->[10.0,100.0)-->[10,99]
        System.out.println(value);

        //公式:[a,b] : (int)(Math.random()*(b - a + 1) + a)
    }
}

2.5.3 switch-case结构

/*
分支结构之二：switch-case

1.格式
switch(表达式){
case 常量1：
    语句1；
    //break;
case 常量2：
    语句2:
    //break;
....
case 常量N:
    语句N:
    //break;
default:
    语句N;
    //break;
}

2.说明：
①根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入相应case结构中，调用其执行语句。
 当调用完执行语句后，则仍然继续向下执行其他case结构中的执行语句，
 直到遇到break关键字或此switch-case结构末尾结束为止

 ②break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

 ③switch结构的表达式，只能是如下的6种数据类型之一：
 byte,short,char,int,枚举类型(jdk5.0新增),String(7.0新增)

 ④case之后只能声明变量，不能声明范围

 ⑤break关键字是可选的

 ⑥default:相当于if-else中的else。
  default结构是可选的。
*/

class SwitchCaseTest {
    public static void main(String[] args) {

        int number = 5;
        switch(number){
        case 0:
            System.out.println("zero");
            break;
        case 1:
            System.out.println("one");
            break;
        case 2:
            System.out.println("two");
            break;
        case 3:
            System.out.println("three");
            break;
        default:
            System.out.println("other");


        }

    }
}

合并特性说明

/*
例题：对学生成绩大于60分的，输出"合格"，低于六十分的输出"不合格"

说明：
如果switch-case结构中的多个case执行语句相同，可以合并
*/

class  SwitchTest1{

    public static void main(String[] args) {

        /*
        int score = 78;
        switch(score){
        case 0:

        case 1:

        .....
        case 100:


        }*/

        int score = 78;
        switch(case/10){
        case 0 :
        case 1 :
        case 2 :
        case 3 :
        case 4 :
        case 5 :
            System.out.println("不及格");
            break
        case 6 :
        case 7 :
        case 8 :
        case 9 :
        case 10 :
            System.out.println("及格");
            break;
        }
    }
}

2.5.4循环结构

在某些条件满足的情况下，反复执行代码的功能。

/*
For循环结构的使用
一、循环结构的四个要素
①初始化条件
②循环条件 --->循环条件是boolean类型
③循环体
④迭代条件

二、for循环的结构

for(①;②;){
    ③
}

执行过程：① - ② - ③ - ④ - ② - ③ -.....- ②
*/
class ForTest {
    public static void main(String[] args) {

        for (int i = 1;i <= 5 ;i++ ){//i=1,2,3,4,5
            System.out.println("Hello World");
        }


        //练习：
        int num = 1;
        for (System.out.print('a');num <= 3 ;System.out.print('c'),num++){
            System.out.print('b');
        }
        //输出结果：abcbcbc

        //例题：遍历100以内的偶数,要输出所有偶数的和
        int sum = 0;//记录所有偶数的和
        for (int i = 1;i <= 100 ;i++ ){
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }    
        System.out.println("总和为:" + sum);
    }
}

练习题1：

/*
if else 练习题

说明：
else结构是可选的
2.针对于条件表达式:
  >如果多个条件表达式之间是"互斥"的关系(或没有交集的关系)，哪个判断和执行语句声明在上面还是在下面，无所谓
  >如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面
  >如果多个条件表达式之间有包含关系，通常情况下需要将范围小的声明在范围大的上面，否则范围小的就没有机会运行了

*/
import java.util.Scanner;
class IfTest {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你的成绩(0-100):");
        int score = scan.nextInt();
        if (score == 100){
            System.out.println("BMW");
        }else if (score > 80 && score <= 99){
            System.out.println("iphone");
        }else if (score > 60 && score <= 80){
            System.out.println("ipad");
        }else{
            System.out.println("none");
        }    
    }
}

练习题2：

/*
题目:输入两个正整数m和n,求其最大公约数和最小公倍数
*/
import java.util.Scanner;
class ForTest {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入第一个正整数:");
        int m = scan.nextInt();

        System.out.println("请输入第一个正整数:");
        int n = scan.nextInt();

        //获取最大公约数
        //获取两个数中的最小值
        int min = (m <= n)?m : n;
        for(int i = min;i >=1 ;i--){
            if (m % i==0 && n % i ==0){
                System.out.println(i);
                break;//一旦在循环中执行到break就跳出循环

            }
        }
        //获取最小公倍数
        //获取两个数中的较大值
        int max = (m >= n)?m:n;
        for(int i = max;i <= m * n;i++){
            if(i % m == 0 && i % n == 0){
            System.out.println(i);
            break;
            }
        }

    }
}

2.5.5Do-While循环

/*
do-while循环使用
一、循环结构的四个要素
①初始化条件
②循环条件 --->循环条件是boolean类型
③循环体
④迭代条件

二、do-while循环结构
1
do{
    3;
    4;
}while{2};

执行过程1-3-4-2-3-4.......-2

说明：
1.do-while循环至少会执行一次循环体
2.开发中，使用for和while更多一些，较少使用do-while

*/
class DoWhileTest {
    public static void main(String[] args) {

        //遍历100以内的偶数,并计算所有偶数的和及偶数的个数
        int sum = 0;//记录总和
        int count = 0;//记录个数
        int num = 1;
        do{
            if (num % 2 == 0){
                System.out.println(num);
                sum += num;
                count++;
            }
            num++;

        }while(num <=100);

        System.out.println("总和为" + sum);
        System.out.println("个数为" + count);


        //******************
        int number1 = 10;
        while(number1 > 10){
            System.out.println("Hello-while")    ;
            number1--;
        }

        int number2 = 10;
        do{
            System.out.println("Hello-do");
            number2--;

        }while(number2 > 10);
    }
}

2.5.6 while(true)

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时程序结束。

说明：
1.不在循环条件部分限制次数的结构；for(;;)或while(true)
2.结束循环有几种方式：
方式一：循环条件部分返回false
方式二：在循环体中，执行break
*/
import java.util.Scanner;
class ForWhileTest {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        int positiveNumber = 0;//记录正数的个数
        int negativeNumber = 0;//记录负数的个数

        while(true){


            int number = scan.nextInt();

            //判断number的正负情况
            if(number > 0){
                positiveNumber++;
            }else if (number < 0){
                negativeNumber++;    
            }else{
                //一旦执行break,跳出循环
                break;
            }        
        }

        System.out.println("输入的正数个数为:" + positiveNumber);
        System.out.println("输入的负数个数为:" + negativeNumber);
    }
}

2.5.7嵌套循环

/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

3.说明
内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
假设外层循环需要执行m次,内层循环需要执行n次，此时内层循环的循环体一共执行了m*n次

4.技巧：外层循环控制行数，内层循环控制列数

*/


class ForForTest{
    public static void main(String[] args) {
        //******
        System.out.println("******");
        for(int i = 1;i <= 6;i++){
            System.out.print("*");
        }
        System.out.println();

        //****************************
        for(int j = 1;j <= 4;j++){
            for(int i = 1;i <= 6;i++){
                System.out.print("*");
        }
        System.out.println();
        }



        //************************
        for (int i = 1;i <= 5 ;i++){//控制行数
            for (int j = 1;j <= i;j++ ){//控制列数
                System.out.print("*");
            }
        System.out.println();
        }

        //*************************
        for (int i = 1;i <= 5 ;i++){//控制行数
            for (int j = 1;j <= 5-i;j++ ){//控制列数
                System.out.print("*");
            }
        System.out.println();
        }


        //****************

        //上半部分


        //下半部分
    }
}

练习题3（质数）

/*
100以内所有质数的输出
质数：素数，只能被1和它本身整除的自然数.-->从2开始到这个数-1结束为止，都不能被这个数本身整除
最小的质数是2
*/
class PrimeNumberTest {
    public static void main(String[] args) {

        boolean isFlag = true;//表示i是否被j除尽

        for (int i = 2;i <= 100 ;i++ ){//遍历100以内的自然数

            for (int j = 2;j < i ;j++ ){//被i去除

                if (i % j == 0){//i被j除尽
                    isFlag = false;

                }

            }
            //
            if(isFlag == true){
                System.out.println(i);
            }
            //重置isFlag
            isFlag = true;
        }
    }
}

练习题3 优化算法

/*
100以内所有质数的输出
质数：素数，只能被1和它本身整除的自然数.-->从2开始到这个数-1结束为止，都不能被这个数本身整除
最小的质数是2

优化方法
无优化 17083ms
优化1  2659ms
优化2  1066ms 
*/
class PrimeNumberTest1 {
    public static void main(String[] args) {

        boolean isFlag = true;//表示i是否被j除尽

        //获取当前时间的毫秒数
        long start = System.currentTimeMillis();

        for (int i = 2;i <= 100000 ;i++ ){//遍历100以内的自然数

            for (int j = 2;j < Math.sqrt(i);j++ ){//被i去除

                if (i % j == 0){//i被j除尽
                    isFlag = false;
                    break;//优化一：只对本身非质数的自然数是有效的

                }

            }
            //
            if(isFlag == true){
                System.out.println(i);
            }
            //重置isFlag
            isFlag = true;
        }

        long end = System.currentTimeMillis();
        System.out.println("所花费的时间为:" + (end-start));
    }
}

2.5.8特殊关键字的作用

break continue

/*
break和continue关键字的使用
                使用范围             循环中使用的作用(不同点)        相同点
                switch-case                
break:          循环结构              结束当前循环                   关键字后面不再执行语句


continue:       循环结构              结束当次循环


*/
class BreakContinueTest {
    public static void main(String[] args) {

        for (int i = 1;i <= 10;i++ ){

            if (i % 4 == 0){
                break;
            }
            System.out.print(i);
        }

        System.out.println();
        for (int i = 1;i <= 10;i++ ){

            if (i % 4 == 0){
                continue;
            }
            System.out.print(i);
        }
    }

}