Java-笔记5

/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。

说明：break关键字的使用：一旦在循环中执行到break，就跳出循环

*/

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();
        
        //获取最大公约数
        //1.获取两个数中的较小值
        int min = (m <= n)? m : n;
        //2.遍历
        for(int i = min;i >= 1 ;i--){
            if(m % i == 0 && n % i == 0){
                System.out.println("最大公约数为：" + i);
                break;//一旦在循环中执行到break，就跳出循环
            }
        }
        
        //获取最小公倍数
        //1.获取两个数中的较大值
        int max = (m >= n)? m : n;
        //2.遍历
        for(int i = max;i <= m * n;i++){
            if(i % m == 0 && i % n == 0){
                
                System.out.println("最小公倍数：" + i);
                break;
            
            }
        }
        
    }

}

/*
While 循环的使用

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

二、while循环的结构

①
while(②){
    ③;
    ④;
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！ 
  区别：for循环和while循环的初始化条件部分的作用范围不同。


算法：有限性。

*/
class  WhileTest{
    public static void main(String[] args) {
        
        //遍历100以内的所有偶数
        int i = 1;
        while(i <= 100){
            
            if(i % 2 == 0){
                System.out.println(i);
            }
            
            i++;
        }
        //出了while循环以后，仍可以调用。
        System.out.println(i);//101

    }
}

/*
do-while循环的使用

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

二、do-while循环结构：

①
do{
    ③;
    ④;

}while(②);

执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②

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

*/
class DoWhileTest {
    public static void main(String[] args) {
        
        //遍历100以内的偶数,并计算所有偶数的和及偶数的个数
        int num = 1;
        int sum = 0;//记录总和
        int count = 0;//记录个数
        do{
            
            if(num % 2 == 0){
                System.out.println(num);
                sum += num;
                count++;
            }

            num++;

        }while(num <= 100);
        

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

        //*************体会do-while至少执行一次循环体***************
        int number1 = 10;
        while(number1 > 10){
            System.out.println("hello:while");
            number1--;
        }

        int number2 = 10;
        do{
            System.out.println("hello:do-while");
            number2--;
        }while(number2 > 10);

    }
}

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为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;//记录负数的个数

        for(;;){//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);
        

    }
}

/*
嵌套循环的使用
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();
        }

        /*            i(行号)        j(*的个数)
        *            1            1
        **            2            2
        ***            3            3
        ****        4            4
        *****        5            5
        */

        for(int i = 1;i <= 5;i++){//控制行数
            for(int j = 1;j <= i;j++){//控制列数
                System.out.print("*");
            
            }
            System.out.println();
        }
        
        /*            i(行号)        j(*的个数)   规律：i + j = 5 换句话说：j = 5 - i;
        ****        1            4
        ***            2            3
        **            3            2
        *            4            1
        */    

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

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

        //略

/*

----* 
---* * 
--* * * 
-* * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    * 

*/

    //上半部分


    //下半部分
        
    }
}

/*
嵌套循环的应用1：

九九乘法表
1 * 1 = 1
2 * 1 = 2  2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81


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

            System.out.println();
        }


    }
}

/*
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++){//j:被i去除
                
                if(i % j == 0){ //i被j除尽
                    isFlag = false;
                }
                
            }
            //
            if(isFlag == true){
                System.out.println(i);
            }
            //重置isFlag
            isFlag = true;
        
        }
    }
}

/*
100000以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest1 {
    public static void main(String[] args) {
        
        boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
        int count = 0;//记录质数的个数

        //获取当前时间距离1970-01-01 00:00:00 的毫秒数
        long start = System.currentTimeMillis();

        for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
            
            //优化二：对本身是质数的自然数是有效的。
            //for(int j = 2;j < i;j++){
            for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
                
                if(i % j == 0){ //i被j除尽
                    isFlag = false;
                    break;//优化一：只对本身非质数的自然数是有效的。
                }
                
            }
            //
            if(isFlag == true){
                //System.out.println(i);
                count++;
            }
            //重置isFlag
            isFlag = true;
        
        }

        //获取当前时间距离1970-01-01 00:00:00 的毫秒数
        long end = System.currentTimeMillis();
        System.out.println("质数的个数为：" + count);
        System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

    }
}

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

continue:        循环结构中            结束当次循环                    关键字后面不能声明执行语句



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

        for(int i = 1;i <= 10;i++){
        
            if(i % 4 == 0){
                break;//123
                //continue;//123567910
                //System.out.println("今晚迪丽热巴要约我！！！");
            }
            System.out.print(i);
        }

        System.out.println("
");
        //******************************
        
        label:for(int i = 1;i <= 4;i++){
        
            for(int j = 1;j <= 10;j++){
                
                if(j % 4 == 0){
                    //break;//默认跳出包裹此关键字最近的一层循环。
                    //continue;

                    //break label;//结束指定标识的一层循环结构
                    continue label;//结束指定标识的一层循环结构当次循环
                }
                
                System.out.print(j);
            }
            
            System.out.println();
        }
    }
}

/*
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
    public static void main(String[] args) {
        
        
        int count = 0;//记录质数的个数

        //获取当前时间距离1970-01-01 00:00:00 的毫秒数
        long start = System.currentTimeMillis();

        label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
            
            for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
                
                if(i % j == 0){ //i被j除尽
                    continue label;
                }
                
            }
            //能执行到此步骤的，都是质数
            count++;
        
        }

        //获取当前时间距离1970-01-01 00:00:00 的毫秒数
        long end = System.currentTimeMillis();
        System.out.println("质数的个数为：" + count);
        System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

    }
}