java基础4

A码

已于 2023-09-17 23:35:22 修改

阅读量40

点赞数

分类专栏： Java 文章标签： java 开发语言

于 2023-08-13 03:05:40 首次发布

本文链接：https://blog.csdn.net/qq_41255707/article/details/132256143

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文详细介绍了Java编程中的分支结构（if、else、if-else-if、switch）、循环结构（for、while），以及如何在代码中运用它们进行条件判断和重复执行任务。包括实例演示如折扣计算、分数等级统计、质数查找等。

摘要由CSDN通过智能技术生成

1. 分支语句

任何复杂的程序都是由“顺序结构”,“分支结构”，“循环结构”组成的。

2. 循环

Java语法中的分支结构包含以下四种
- 分支结构可以嵌套使用
- 1.if //如果…
- 2.if……else…… //如果…否则…
- 3.if…….else if……. //如果…否则如果……
- 4.switch……case…… //switch….情况1…情况2……
分支结构—if语句

分支结构—if…else…语句
分支结构—if…else…if语句

分支语句的嵌套

分支语句的嵌套是指，在分支预计的语句块中可以继续使用分支语句
分支结构—switch…case…语句

代码举例：

import java.util.Scanner;
public class IfDemo {
    public static void main(String[] args) {
        // 1：规定： 循环3次输入单价和数量。 如果购买的商品，超过500块，就8折。计算用户最后需要付多少钱。
        int i = 0;
        double sum = 0;
        Scanner scanner = new Scanner(System.in);
        while (i < 3) {
            System.out.println("请输入商品单价：");
            double danjia = scanner.nextDouble();
            System.out.println("请输入商品数量：");
            double count = scanner.nextDouble();
            sum += danjia*count;
            // System.out.println(sum);
            i++;
        }
        if (sum > 500){
            sum *= 0.8;
        }else {
            sum *= 0.9;
        }
        System.out.println("打折后需要付"+sum+"元");
    }
}

分数等级统计的案例：

int score = 77;
if (score > 100 || score < 0) {
    System.out.println("分数错误。");
}else {
    if (score >= 90) {
        System.out.println("A");
    } else if (score >= 80) {
        System.out.println("B");
    } else if (score >= 70) {
        System.out.println("C");
    } else if (score >= 60) {
        System.out.println("D");
    } else {
        System.out.println("E");
    }
}

switch…case语句案例：

 int score = 67;
 // 除法运算：
 //           100 / 10 = 10
 //           [90 , 99] / 10 = 9
 //           [80 , 89] / 10 = 8
 //           [70 , 79] / 10 = 7
if (score > 100 || score < 0) {
     System.out.println("分数错误！");
 }else{
    switch (score/10) {
        case 10:  // 满足这个case的时候，直接执行下一个case

        case 9:
            System.out.println("A");
            break;
        case 8:
            System.out.println("B");
            break;
        case 7:
            System.out.println("C");
            break;
        case 6:
            System.out.println("D");
            break;
        default:
            System.out.println("E");
    }
 }

3. 循环结构

循环是程序设计语言中反复执行某些代码的一种计算机处理过程，是一组相同或相似的语句被有规律地执行。
循环三要素
1. 循环变量初始化
2. 循环条件（以循环变量为判断条件）
3. 循环变量的改变（向着循环结束变）

3.1 循环结构—for循环

for循环是最经典的循环语法，也是使用最多的循环方式。

for语法规则：

for(表达式1；表达式2；表达式3){

// 语句序列

}

表达式1：初始化表达式，负责完成循环条件的初始化

表达式2：循环条件表达式，值为boolean的表达式，指定循环条件

表达式3：循环后的操作表达式，负责修改变量，改变循环条件
for循环代码执行流程
for循环流程图

for循环——经典案例

计算1+2+3…+100的和;
计算1+1/2+1/3…+1/888的和;
计算10的阶层;（123*4…*10）
求和：9+99+999+9999+99999+……+999999999,9的个数可以改为由键盘输入来控制

import java.util.Arrays;
import java.util.Scanner;
public class Test {
   public static void main(String[] args) {
      exercise1();
      exercise2();
      exercise3();

   }
    private static void exercise1() {
        // 输出2-100之间的质数（是直接输出，这里将找出来的质数都放在数组里面去，最后一次输出）
        int count = 0;
        for (int num = 2; num <= 100; num++) {// 从2取数到100
            boolean flag = true;//表示是素数
            for(int divisor = 2; divisor <= Math.sqrt(num); divisor++) {//取除数，从2开始到num开根号位置，因为其他再比较都是重复比较
                if(num % divisor == 0){ //被除数 ÷ 除数 是否能除尽
                    flag = false;
                    break; // 能整除，说明不是质数，不再比较后面的内容
                }
            }
            if(flag){
                System.out.println(num);
            }
        }
    }
   private static void exercise2() {
      // 分解质因数，把因子存储在数组中。遍历数组，把质因子的平方和计算出来。
      int data = 90;
      int[] arr = new int[0]; // 因为不能确定该数由多少个质因子，所以需要动态修改数组长度
      int count = 0; // 记录分解次数，如果为为1，则说明 data 不能被 2 到 data-1 整除，直到和自己相除得到了一次，则自己就是一个质数
      int temp = data;  //临时数据
      for(int i = 2; i <= temp; i++){
         if(temp % i == 0){// 如果能整除
            temp = temp / i; //那么执行整除操作，将临时数据变小
            arr = Arrays.copyOf(arr, arr.length+1); //数组长度动态加1
            arr[arr.length-1] = i; //将这个质因子存到数组
            i--;  // 因为可以整除，所以保持这个除数不变,用下一个用继续除
            count++;  // 统计分解的次数
         }
      }
      if(count == 1){
         System.out.println(data + "是质数，不能分解");
      }else{
         // 遍历数组，计算质因子的平方
         int sum = 0;
         for(int i = 0; i < arr.length; i++) {
            sum += (int)Math.pow(arr[i], 2);  // Math.pow(arr[i], 2)计算的结果为double类型
         }
         System.out.println(data + "的质因子" + Arrays.toString(arr) + "的平方和：" + sum);
      }
   }
   private static void exercise3() {
      // for循环练习
      // 计算1+2+3......+100的和;
      System.out.println("计算1+2+3......+100的和;");
      int sum = 0;
      for(int i = 1; i <= 100; i++) {
         sum += i;
      }
      System.out.println("sum:" + sum);
      // 计算1+1/2+1/3.....+1/888的和;
      System.out.println("计算1+1/2+1/3.....+1/888的和;");
      double sum1 = 0;
      for(double n = 1; n <= 888; n++) {
         sum1 += 1/n;
      }
      System.out.println("sum1:" + sum1);
      // 计算10的阶层;(1*2*3*4...*10)
      int number = 10;
      int jiecheng = 1;
      for(int i = 1; i <= 10; i++) {
         jiecheng *= i;
      }
      System.out.println(number + "的阶乘是：" + jiecheng);
      // 求和:9+99+999+9999+99999......+999999999,9的个数可以改为由键盘输入来控制。
      System.out.println("求和:9+99+999+9999+99999......+999999999,9的个数可以改为由键盘输入来控制");

      Scanner sc = new Scanner(System.in);
      System.out.println("请输入个数：");
      int m = sc.nextInt();//个数（m）
      int n = 9;  // 定义基数
      String str = "";
      String strs = "";
      int sum2 = 0;
      for(int i = 1; i <= m; i++) {
         str += n;  // 记录 9,99,999,9999...
         strs += str;  // 记录9+99+999+...
         if (i<m){ strs += " + "; }
         sum2 += Integer.parseInt(str);  // 解析数字字符串并求和
      }
      System.out.println(strs+" = "+ sum2);
   }
}

for循环——特殊写法

for(;表达式2；表达式3)
for(;表达式2;）
for(;;)
for(int a = 0, b=5 ; a<b; a++,b--) {
	System.out.println(a+",,,"+b);
}

for循环案例

package Day4;
import java.util.Random;
public class ForDemo {
   public static void main(String[] args) {
      /*
      for(int i = 0; i < 100; i++);
      {
         System.out.println(i);  // 编译错误：  i 没有定义，不能使用
      }
      */
      /*
      *** 尽量避免死循环
      for(int i = 0; i < 100; i--); // i < 100 是一直为真。for循环无法结束（死循环）
      System.out.println("hello");
      */

//    for(int i = 1; i <= 5; i++) {
//       System.out.println();
//    }

      // 练习： for(;;) ， 产生1~20的随机整数，然后把随机数的和相加，和大于100之后，就结束程序
      /*int sum = 0;
      int count = 0;
      Random random = new Random();
      for(;sum < 100;){
         int number = random.nextInt(20)+1; // 不能等于0
         sum += number;
         System.out.print(number+" ");
         count++;
         }
      System.out.println("sum："+sum);
      System.out.println("循环"+count+"次");
      */
      int sum = 0;
      int count = 0;
      Random random = new Random();
      for(; sum < 100;){
         sum += random.nextInt(20) + 1;
         System.out.print(sum+" ");
         count++;
      }
      System.out.println("sum:"+sum);
      System.out.println("count:"+count);
   }
}

3.2 循环结构—while循环

while语法规则

循环结构—while循环练习

public static void main(String[] args){
   Random random = new Random();
   int number = random.nextInt(100) + 1; //不要0
   Scanner sc = new Scanner(System.in);
   System.out.println(number);
   int count = 0;
   while(true){
      count++;
      System.out.println("请输入一个整数：");
      int x = sc.nextInt();
      if (x > number) {
         System.out.println("大了");
      }else if (x < number){
         System.out.println("小了");
      }else{
         System.out.println("对了");
         break;
      }
   }
   System.out.println("count: " + count);
}

3.3 break使用规则

break可用于循环语句或switch语句。
break用于循环，可使程序终止循环从而执行循环后面的语句。常常与条件语句一起使用。

3.4 continue的使用

continue 用于循环语句中，表示跳过循环体剩余语句，继续执行下一次循环。

continue 只能在循环语句中使用。

int num = 100; //定义变量
while(num<=100){
if(num%2==0){
continue; //如果num是偶数，则退出本次循环
}
System.out.println(num);
num --; //num自减
}

对比break 和 continue的使用

// continue : 循环中，使用continue关键字， 结束本次循环
public class ContinueDemo {
   public static void main(String[] args){
      // 1~100 中不能被5整除的数据的和
      int sum = 0;
      for(int i = 0; i <= 100; i++){
         if(i % 5 == 0){
            continue;  // 结束本次循环（后续的代码不执行了），进入到下一次循环
         }
         sum += i;
      }
      System.out.println("sum: " + sum);

      System.out.println("--------------------------------");
      int sum1 = 0;
      for(int i = 0; i <= 100; i++){
         if(i % 5 == 0){
            break;
         }
         sum1 += i;
      }
      System.out.println("sum1"+sum1);
   }
}

4. exercise

数组打乱

import java.util.Arrays;
import java.util.Random;

public class Home2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};

        Random random = new Random(); //产生随机数的类型

        for (int i = 0; i < arr.length/2; i++) {// i 控制循环的次数  arr.length/2:减少循环次数
            // 思路：  产生两个随机的下标， 把这两个位置是元素交换
            int index1 = random.nextInt(arr.length);
            int index2 = random.nextInt(arr.length);
            int temp = arr[index1];
            arr[index1] = arr[index2];
            arr[index2] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

public static void home4{
    int i = 6;  // 假设最少桃子是6
    while (true) {
        int x = i;  // 更新桃子数量
        boolean flag = true;  // 由它退出while
        for(int j = 1; j <= 5; j++) {  // 有5只猴子，每只猴子都需要将现阶段桃子-1个 ，再均分5份，自己拿一份
            if((x-1)%5 == 0) {  // 能把桃子分为5份
                x = x - (x-1)/5 - 1;  // x：（这个x是总嘞桃子） - (x-1)/5：（这个整体算嘞是总数-1之后刚好可以分成5份） - 1：（现在把多余嘞那一个桃子给甩了） ==> 求出来嘞结果就剩下没有被拿走嘞桃子
            }else{ // 如果这个数不满足上面均分嘞条件,那么就更新标志位，退出循环
                flag = false;
                break;
            }
        }
        // 循环结束之后，判断标志位，如果为真，则说明条件满足，输出该数
        if (flag) {
            System.out.println("桃子的个数："+i);
            break;  // 找到并输出了满足条件的最小数，结束循环
        }else{ // 否则该数 +1 继续下一次验算
            i++;
        }
}