java行侠仗义之循环结构

循环结构

讲之前先说一下循环结构的知识

循环四要素

• 1.循环初始化---->循环什么时候开始执行
• 2.循环继续条件---->循环什么时候继续执行何时结束
• 3.循环体---->需要被多次循环执行的代码块
• 4.循环的周期、步长、间距---->当前循环和下一次循环之间的变更

初始化语句：一条或多条语句，这些语句用于完成一些初始化工作，初始化语句在循环开始之前执行。

循环条件：这是一个 boolean 表达式，这个表达式能决定是否执行循环体。

循环体：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行。如果这个代码块只有一行语句，则这个代码块的花括号是可以省略的。

周期/步长语句：这个部分在一次循环体执行结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量，使得循环在合适的时候结束。

循环语句分为for循环和while循环

for循环

for循环主要用于一直循环次数的情况下

while主要用于知道什么时候结束但是不知道计算次数的情况下

先讲一下for循环

格式为

for（定义初始化；循环的条件；循环的周期）{

              循环体

}

上图解释

直接看一个累加的例子

public class Test04{
    public static void main(String[] args){
        int sum=0;
        for(int i=1;i<10;i++){
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

接下来看一个初学for循环爱遇到的打印*图形的问题

public class Test04{
    public static void main(String[] args){
        for (int i = 0;i<5;i++){
            System.out.print("*");
        }

    }
}

*****

第一次打印一个*

第二次打印一个*

直到打印到五个*

继续看如何打印正方形的*

可以直接打印五次上面的语句但因为是一样的所以可以这样

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

直接让它循环五次

这就是循环嵌套

接下来看打印图形的问题

打印三角

public class Test05{
    public static void main(String[] args){
        for(int j=1;j<=5;j++){                //控制行
            for(int i=1;i<=j;i++){            //控制每一行打印多少个星号
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

输出结果

*
**
***
****
*****

 

再看

public class Test05{
    public static void main(String[] args){
        for(int j=1;j<=5;j++){
            for(int k=1;k<=5-j;k++){
                System.out.print(" ");
            }

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





/*结果
    *
   **
  ***
 ****
*****

*/

打印图形的关键就是控制空格的和打印的是星号还是数字

看数字的情况

import java.util.Scanner;
public class Home03_14{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        System.out.print("请输入一个1到15之间的整数：");
        int number=input.nextInt();
        for(int i=1;i<=number;i++){     //打印，每行的数字
            for(int j=1;j<=number-i;j++){//打印每行的空格数
                System.out.print("  ");
            }
            for(int k=-(i-1);k<=i-1;k++){
                System.out.print(Math.abs(k)+1+" ");
            }
            System.out.println();
        } 
    }
}

看结果

请输入一个1到15之间的整数：7
            1
          2 1 2
        3 2 1 2 3
      4 3 2 1 2 3 4
    5 4 3 2 1 2 3 4 5
  6 5 4 3 2 1 2 3 4 5 6
7 6 5 4 3 2 1 2 3 4 5 6 7

 

接下来上技术活

打印金字塔形

public class Home03_16{
    public static void main(String[] args) {
        for(int i=1;i<=8;i++){      //行
            for(int j=1;j<=8-i;j++){
                System.out.print("    ");
            }
            for(int k=-(i-1);k<=i-1;k++){       //列的次方输出
                System.out.printf("%4.0f",Math.pow(2,i-1-Math.abs(k)));
            }
            System.out.println();
        }
    }
}

                               1
                           1   2   1
                       1   2   4   2   1
                   1   2   4   8   4   2   1
               1   2   4   8  16   8   4   2   1
           1   2   4   8  16  32  16   8   4   2   1
       1   2   4   8  16  32  64  32  16   8   4   2   1
   1   2   4   8  16  32  64 128  64  32  16   8   4   2   1

这里使用了for的循环嵌套。

第一层for循环打印的是每一行的数字

第二层for循环打印的是每一行的空格数

最后一个for循环就有难度了，这一层仔细观察，两边的数字都是对称的，只有中间不同，所可以使用绝对值，一共有八层，2的最大为7次方，所以定义k=-(i-1),i-1-Math.abs(k)来控制次方，比如说第八层，k=-7,次方为2^7=128。

while循环

while 语句是最基本的循环语句，是一种先判断的循环结构，可以在一定条件下重复执行一段代码。该语句需要判断一个测试条件，如果该条件为真，则执行循环语句（循环语句可以是一条或多条），否则跳出循环。

如果 while 循环一开始条件表达式就是假的，那么循环体就根本不被执行。

while 循环语句的语法结构如下：

循环初始化；
while(条件表达式) {
    循环体;
    循环的步长；
}

default

表示“默认”，即其他情况都不满足。default 后要紧跟冒号，default 块和 case 块的先后顺序可以变动，不会影响程序执行结果。通常，default 块放在末尾，也可以省略不写。

break

表示“停止”，即跳出当前结构。

如果在 case 分支语句的末尾没有 break 语句，有可能触发多个 case 分支。那么就会接着执行下一个 case 分支语句。这种情况相当危险，常常会引发错误。

 

 

习题

 

这个题的关键是while的使用

条件表达式直接为true直接进入循环体

输入一个数字

再判断数字是否为0

如果为0则退出

不是则继续

import java.util.Scanner;
public class Demo03_11{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        double sum=0;  //总和
        int positives=0;    //正数的个数
        int negatives=0;    //负数的个数
        System.out.print("请输入若干数字：");
        while(true){//不管三七二十一 先进来再说
            int num=scanner.nextInt();
            if(num!=0){
                sum+=num;
                if(num>0){
                    positives++;
                }else{
                    negatives++;
                }
            }else{
                break;  //跳出当前循环
            }
        }   
        if(positives+negatives==0){
            System.out.println("没有其他数字的输入，除了0");
        }else{
            System.out.println("正数的个数"+positives);
            System.out.println("负数的个数"+negatives);
            System.out.println("总和"+sum);
            System.out.println("平均值"+sum/(positives+negatives)); 
        }
    }
}

 

import java.util.Scanner;
    /*
    21  35
    7
    */
public class Home03_12{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        System.out.print("请输入两个整数：");
        int n1=input.nextInt();
        int n2=input.nextInt();
        int gcd=1;
        for(int i=n1<n2?n1:n2;i>=1;i--){
            if(n1%i==0&&n2%i==0){
                gcd=i;
                break;
            }
        }
        System.out.println(gcd);
    }
}

/*
120 2~120   ->2
60  2~60    ->2
30  2~30    ->2
15  2~15    ->3
5   2~5     ->5 
1
*/
import java.util.Scanner;
public class Home03_13{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num=input.nextInt();
        while(true){
            for(int i=2;i<=num;i++){
                if(num%i==0){
                    System.out.print(i+" ");
                    num=num/i;
                    break;
                }
            }
            if(num==1){
                break;
            }
        }
    }
}

/*
素数：除了1和本身之外没有其他数字可以整除
7
2 3 4 5 6
是素数
num 2~num-1  m  num%m==0,不是素数
没有找到的话就是素数

*/

public class Home03_17{
    public static void main(String[] args){
        int count=0;
        boolean flag=true;
        for(int num=2;num<=1000;num++){
            for(int m=2;m<=num-1;m++){  //重点是for是如何退出的
                if(num%m==0){
                flag=false;           //判断num不是素数
                break;
                }
            }
            if(flag){
                count++;
                System.out.print(num+" ");
                if(count%8==0){
                    System.out.println();
                }
            }
            flag=true;
        }
    }
}
/*如果for是正常结束的
如果是break结束的
*/

输入数据确定范围

计算次方使用Math.pow函数

利用for循环实现计算

import java.util.Scanner;
public class Home03_18{
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println();
        int max=input.nextInt();
        double sum=0;
        for(int i=1;i<=max;i++){
            sum=sum+Math.pow(-1.0,i+1)/(2*i-1);
        }
        double PI=4*sum;
        System.out.println(PI);
    }
}

 

输入数据

观察规律

定义一个变量储存阶乘

for循环

import java.util.Scanner;
public class Home03_19{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int imax=input.nextInt();
        double e=1;
        double item=1.0;
        for(int i=1;i<=imax;i++){
            item=item*i;    //n!=(n-1)*n
            e=e+1/item;
        }
        System.out.println(e);

    }
}

 

每四年一个闰年         判断条件 年%4==0

或者能被100整除的数        判断条件  年%100==0

或者世纪年可以被400整除     判断条件  年%400==0

public class Home03_20{
    public static void main(String[] args){
        int count=0;
        for(int i=101;i<=2100;i++){
            if(i%4==0 && i%100!=0 || i%400==0){
                count++;
                System.out.print(i+" ");
                if(count%10==0){
                    System.out.println();
                }
            }
        }
        System.out.println("\n闰年一共有"+count+"个");
    }
}

寻找到这个数本身的一般就不需要继续寻找了，超过一半必然不会存在整除的数了

for循环实现

/*
6   1 2 3 
28  1 2 4 7 14
n   1-n/2
*/
public class Home03_21{
    public static void main(String[] args) {
        int sum=0;
        for(int n=2;n<=10000;n++){
            for(int i=1;i<=n/2;i++){
                if(n%i==0){
                    sum=sum+i;
                }
            }
            if(n==sum){
                System.out.println("完全数"+n);
            }
            sum=0;
        }
    }
}

 

/*
相关数据：电脑随机产生一个数字com  用户输入一个数字usr
表示方法：
    0 1 2
    剪刀 石头 布
步骤：
1.提示用户输入一个数字
2.计算机随机产生一个数字
3.将两个数字进行对比，判断输赢
    平局  com==usr
    用户赢 usr=0 com=2 | usr=1 com=0 | usr=2 com=1
    用户输 剩下的都是用户输
*/
import java.util.*;
class Demo03_22{
    public static void main(String[] args){
        //1.提示用户输入一个数字
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入 剪刀0 石头1 布2：");
        int userWin=0;
        int comWin=0;
        while(true){
            int user = scanner.nextInt();
            //2.计算机随机产生一个数字
            Random random = new Random();
            int com = random.nextInt(3);
            //创建两个字符串，用来表示计算机和用户可能产生的情况
            String userStr = "";
            String comStr = "";
            switch(user){
                case 0:
                userStr="剪刀";
                break;
                case 1:
                userStr="石头";
                break;
                case 2:
                userStr="布";
                break;
            }
            switch(com){
                case 0:
                comStr="剪刀";
                break;
                case 1:
                comStr="石头";
                break;
                case 2:
                comStr="布";
                break;
            }
            if(user==com){
                System.out.printf("用户是%s,电脑是%s，平局",userStr,comStr);
            }else if(user==0&&com==2||user==1&&com==0||user==2&&com==1){
                System.out.printf("用户是%s，电脑是%s，用户赢",userStr,comStr);
                userWin++;
            }else{
                System.out.printf("用户是%s，电脑是%s，用户输",userStr,comStr);
                comWin++;
            }
            if(userWin==2||comWin==2){
                break;
            }
        }

            if(userWin==2){
                System.out.println("最终用户赢");
            }else{
                System.out.println("最终用户输");
            }
    }
}

这个程序的关键是如何把余数按从后往前排列的问题

直接定义一个空字符串变量

让字符串变量=每个数%2+字符串变量

这样就可以按顺序出来了

循环输出即可

import java.util.Scanner;
public class Home03_23{
    public static void main(String [] args){
        Scanner input=new Scanner(System.in);
        System.out.print("请输入一个数字：");
        int num=input.nextInt();
        String binStr="";
        while(true){
            binStr=num%2+binStr;
            num=num/2;
            if(num==0){
                break;
            }
        }
        System.out.println(binStr);
    } 
}

这个题的关键是输入的数大于下一个数就就交给大的数执行，相等的就定义一个变量储存次数，没遇到相等的就+1；遇到大的就交给大的数

import java.util.Scanner;
public class Home03_24{
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.print("请输入数字：");
        int num=0;
        int max=0;
        int count=0;
        while(true){
            num=input.nextInt();
            if(num==0){
                break;
            }else if(num>max){
                max=num;
                count=1;
            }else if(num==max){
                count++;
            }
        }
        System.out.println("max="+max+"count="+count);
    }
}