小黑子—Java从入门到入土过程：第四章

Java系列第四章

1. 顺序结构

2. if语句

3. switch 语句

3.1 default的位置和省略

• 1.位置 : defaule不一定是写在最下面的，我们可以写在任意位置。只不过习惯会写在最下面
• 2.省略: defaule可以省略，语法不会有问题，但是不建议省略。

3.2 case 穿透

就是语句体中没有写break导致的。
执行流程:

1. 首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配。
2. 如果匹配上了，就会执行对应的语句体，如果此时发现了break，那么结束整个switch语句。
3. 如果没有发现break，那么程序会继续执行下一个case的语句体，一直遇到break或者右大括号为止。
4. 如果多个case的语句体重复了，那么我们考虑利用case穿透去简化代码。

3.3 switch 新特性 （jdk12开始）

支持箭头表达式返回

import org.junit.Test;

enum Gender {
    MALE, FEMALE, UNKNOWN;
}

public class TestX {
    private Gender gender = Gender.MALE;

    @Test
    public void show() {
        switch (gender) {
            case MALE:
                System.out.println("男");
                break;
            case FEMALE:
                System.out.println("女");
                break;
            default:
                throw new IllegalStateException(gender.toString());
                break;
        }
    }
}

Java 新特性 的 switch 表达式使用箭头表达时，不需要在每一个 case 后都加上 break。

	@Test
    public void show() {
        switch (gender) {
            case MALE -> System.out.println("男");
            case FEMALE -> System.out.println("女");
            default -> throw new IllegalStateException(gender.toString());
        }

4. for 循环

package com.itheima.demo1;

import java.util.Scanner;

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

        //分析:
        //1.键盘录入两个数字
        Scanner sc = new Scanner(System.in);
        System.out.print("请录入一个数字表示范围的开始：");
        int start = sc.nextInt();
        System.out.println("请录入一个数字表示范围的结束：");
        int end = sc.nextInt();

        // 统计变量
        //简单逻辑，统计符合要求的数字个数
        int count = 0;
        //2.利时循环获取这个范围中的每一个数字
        for (int i = start; i <= end; i++) {
            //3.对每一个数字进行判断，统计有多少个满足要求的数字
            if (i % 3 == 0 && i % 5 == 0) {
                count++;
            }
        }
        System.out.println(count);

    }
}

5. while 循环

for 和 while 的对比

package com.itheima.demo1;

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

        //分析:
        //1.定义数字
        int x = 123321;
        //定义一个临时变量用于记录×原来的值，用于最后进行比较
        int temp = x;
        //记录倒过来之后的结果
        int num = 0;
        //2.利用循环开始
        while (x != 0) {
            //从右往左获取每一位数字
            int ge = x % 10;
            //修改下x记录的值
            x= x/10;
            //把当前获取到的数字拼接到最右边
            num = num * 10 + ge;
        }
        System.out.println(num);
        System.out.println(x);
        System.out.println(num == temp);
    }
}

6.do…while 循环

7. 无限循环

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        // for 格式的无限循环
        for(;;){
            System.out.println("wdnmd");
        }
    }
}

可以按红色的方块暂停

8. 跳转控制语句

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if(i==3){
                continue;
            }
            System.out.println("wdnmd"+i+"fk");
        }
    }
}

2.

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if(i==3){
                break;
            }
            System.out.println("wdnmd"+i+"fk");
        }
    }
}

9. 练习

9.1 逢七过

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        for (int i = 1; i <=100; i++) {
            if(i%10==7||i/10%10==7||i%7==0){
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }
    }
}

9.2 平方根

package com.itheima.demo1;

import java.util.Scanner;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = sc.nextInt();
        for (int i = 1; i < number; i++) {
            if (i * i == number) {
                System.out.println(i + "就是" + number + "的平方根");
                break;
            } else if (i * i > number) {
                System.out.println((i - 1) + "就是" + number + "平方根的整数部分");
                break;
            }
        }
    }
}

9.3 求质数

1. 标记法

package com.itheima.demo1;

import java.util.Scanner;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = sc.nextInt();
        //定义一个变量，表示标记
        // 标记着number是否为一个质数
        // true:是一个质数
        //false :不是一个质数
        boolean flag = true;

        for (int i = 2; i < number; i++) {
            // i 表示依次表示这个范围之内的每一个数字
            //看number是否能被i整除就可以了
            if(number%i ==0){
                flag = false;
                break;
            }
        }
        //只有当这个循环结束了，表示这个范围之内所有的数字都判断完毕了
        // 此时才能断定number是一个质数
        if(flag){
            System.out.println(number+"是一个质数");
        }else{
            System.out.println(number+"不是一个质数");
        }
    }
}

2. 平方根法
   

10. 随机数

package com.itheima.demo1;

import java.util.Random;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //先获取一个随机数。
        // 范围:2~10
        //2.创建对象
        Random r = new Random();
        //3.生成随机数//判断技巧:
        //在小括号中，书写的是生成随机数的范围//这个范围一定是从e开始的。
        //到这个数-1结束
        //口诀:包头不包尾，包左不包右
        for(int i = 0;i<100;i++){
            int number = r.nextInt(10)+5;//0+5~9+5 //5~14
            System.out.println(number);
        }


    }
}

练习：

package com.itheima.demo1;

import java.util.Random;
import java.util.Scanner;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //需求:程序自动生成一个1-100之间的随机数字，使用程序实现猜出这个数宇是多少?
        // 扩展小需求:加一个保底机制,3次猜不中，直接提示猜中了。
        //注意点:
        //1.生成随机数的代码int number = r.nextInt(100) +1;
        // 不能写在循环的里面的，否则每一次都会产生一个新的随机数
        //2.抽奖机制
        //用点券去抽水晶
        // 保底360次

        //计数器
        //用来统计当前已经猜了多少次。
        int count = 0;
        //分析
        // 1．生成一个1-100之间的随机数字
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        System.out.println(number);
        // 2. 猜这个数字是多少
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入你要猜的数字：");
            int gussNumber = sc.nextInt();
            //3 .判断两个数字给出不同的提示
            // 猜的数字大了，提示大了
            //猜的数字小了，提示小了
            //猜的数字一样，提示猜中了
            count++;
            if(count == 3){
                System.out.println("猜中了");
                break;
            }
            if(gussNumber>number){
                System.out.println("大了");
            }else if(gussNumber<number){
                System.out.println("小了");
            }else{
                System.out.println("猜中了");
                break;
            }
        }


    }
}

11. 数组

11.1 数组的地址

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        double[] arr6={1.93,1.75,1.73,181};
        System.out.println(arr6);// [D@4554617c 地址值
        // 扩展：
        //解释一下地址值的格式含义[D@4554617c
        //[﹔表示当前是一个数组
        //D:表示当前数组里面的元素都是double类型的
        //@:表示一个间隔符号。(固定格式）
        // 4554617c:才是数组真正的地址值,(十六进制)
        // 平时我们习惯性的会把这个整体叫做数组的地址值。

    }
}

11.2 数组索引

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //利用索引对数组中的元素进行访问1/1.获取数组里面的元素
        //格式:
        //数组名[索引]
        int[]arr = {1,2,3,4,5};
        //获取数组中的第一个元素//其实就是e索引上对应的元素l / int number = arr[e];
        // system.out.println( number);//1
        //获取数组中1索引上对应的数据,并直接打印出来/ / system.out.println(arr[1]);//2
        //2.把数据存储到数组当中
        //格式:数组名[索引]=具体数据/变量;
        //细节:一旦覆盖之后，原来的数据就不存在了。
        arr[0] = 100;
        System.out.println(arr[0]);//100
    }
}

11.3 数组的遍历

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //利用循环改进代码//开始条件: 0
        //结束条件:数组的长度-1(最大索引)
        //在Java当中，关于数组的一个长度属性,length
        // 调用方式:数组名.length

        //扩展:
        //自动的快速生成数组的遍历方式/ lidea提供的
        //数组名.fori
        int[] arr = {1,2,3,4,5};
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

练习：
1.

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //分析:
        //1.定义一个数组存储1,2,3,4,5,6,7,8,9,10
        int [] arr={1,2,3,4,5,6,7,8,9,10};
        int count =0;
        for (int i = 0; i < arr.length; i++) {
            //i表示数组里面的每一个索引
            // arr[i]表示数组里面的每一个元素
            //3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
            if(arr[i]%3==0){
                count++;
            }
        }
        System.out.println("数组中能被3整除的数字有"+count+"个");
    }
}

2.

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //分析:
        //1.定义一个数组存储1,2,3,4,5,6,7,8,9,10
        int [] arr={1,2,3,4,5,6,7,8,9,10};
        for (int i = 0; i < arr.length; i++) {
            //i表示数组里面的每一个索引
            // arr[i]表示数组里面的每一个元素
            //3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
            if(arr[i]%2==0){
                // 偶数变二分之一
                arr[i]=arr[i]/2;
            }
            else{
                arr[i]=arr[i]*2;
            }
        }
        // 遍历数组
        // 一个循环尽量只做一件事情
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

11.4 数组的动态初始化

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //格式:
        //数据类型[门]数组名= new数据类型[数组的长度];
        //在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值
        String[] arr = new String[50];
        //添加学生
        arr[0] = "zhangsan";
        arr[1] = "lisi";
        System.out.println(arr[0]);//zhangsan
        System.out.println(arr[1]);//lisi
        System.out.println(arr[2]);//打印出来的是默认初始化值null
        //数组默认初始化值的规律
        //整数类型:默认初始化值0
        // 小数类型:默认初始化值0.0
        //字符类型:默认初始化值"/u0000" ->空格
        //布尔类型:默认初始化值 false
        //引用数据类型:默认初始化值null
        int[] arr2=new int[3];
        System.out.println(arr2[0]);//0
        System.out.println(arr2[1]);//0
        System.out.println(arr2[2]);//0
    }
}

数组常见问题
当访问了数组中不存在的索引，就会引发索引越界异常。

12. 数组练习

12.1 求最值

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //扩展问题:
        //1.根据求最大值的思路，自己改写一下求最小智
        //2.为什么max要记录为arr[0],默认值不能为0吗?
        // 不能写0
        // max的初始化值一定要是数组中的值。
        // 3.循环中开始条件一定是0吗?
        //循环的开始条件如果为0，那么第一次循环的时候是自己跟自己比了一下，对结果没有任何影响，但是效率偏低
        // 为了提高效率,减少一次循环的次数，循环开始条件可以写1.

        //1. 定义数组用来储存5个值
        int []arr={33,5,22,44,55};
        //2. 定义一个变量用来储存最大值
        //临时认为0索引的数据是最大的
        int max=arr[0];
        //3. 循环获取素组的每一个元素
        //拿每一个元素跟max进行比较
        for (int i = 0; i < arr.length; i++) {
            //i 索引 arr[i]元素
            if(arr[i]>max){
                max=arr[i];
            }
        }
        // 4. 当循环结束之后，max记录的就是数组中的最大值
        System.out.println(max);
    }
}

12.2 遍历数组求和

package com.itheima.demo1;

import java.util.Random;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        // 分析：
        //1.定义数组
        //动态初始化
        int[] arr = new int[10];
        //2.把随机数存入到数组当中
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            // 每循环一次，就会生成一个新的随机数
            int number = r.nextInt(100) + 1;
            // 相当于new Random().nextInt(100) 通过netInt方法的值输到随机数中
            //从0~99随机，要到100就在后面+1
            // 把生成的随机数添加到数组当中
            // 数组名[索引]=数据；
            arr[i] = number;
        }
        //1.求出所有数据的和
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum=sum+arr[i];
        }
        System.out.println("所有数据的和："+sum);
        //2.求出所有数据的平均数
        int avg = sum/arr.length;
        System.out.println("所有数据的平均数："+avg);
        //3.统计有多少个数据比平均值小
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<avg){
                count++;
            }
        }
        // 当循环结束之后，就表示我已经找到了所有的比平均值小的数据
        System.out.println("在数据中，一共有："+count+"个数据比平均数小");

        // 遍历数组，验证答案
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+" ");
        }
    }
}

12.3 交换数据

1. 定义交换

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        //把变量b的值，赋值给了变量a，那么变量a原来的值被覆盖了
        int temp =a;
        // 把变量b的值，赋值给了a，那么变量a原来记录的值就被覆盖了
        a=b;
        // 就是把变量a原来的值，赋值给了变量b
        b=temp;
        System.out.println(a);//20
        System.out.println(b);//10
    }
}

2. 遍历数组法

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        // 1.定义一个数组
        int[] arr ={1,2,3,4,5};
        //2.将数组中0索引和最大索引引出的值进行交换
`在这里插入代码片`        int temp = arr[0];
        arr[0] = arr[4];
        arr[4]=temp;
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

package com.itheima.demo1;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //1.定义数组存储数据
        int[] arr={1,2,3,4,5};
        //2.利用循环去交换数据
        for(int i=0,j=arr.length-1;i<j;i++,j--){
            //交换变量i和变量j指向的元素
            int temp = arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
        }
        // 当循环结束之后，那么数组中的数据就实现了头尾交换
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

12.4 打乱数据

package com.itheima.demo1;

import java.util.Random;

public class ArithmeticoperatorDemo1 {
    public static void main(String[] args) {
        //难点：
        //如何获取数组中的随机索引

        //1. 定义数组存储1~5
        int[] arr={1,2,3,4,5};
        // 2. 循环遍历数组，从0索引开始打乱数据的顺序
        Random r =new Random();
        for(int i=0;i<arr.length;i++){
            // 生成一个随机索引
            int randomIndex = r.nextInt(arr.length);
            //拿着随机索引指向的元素 跟 i 指向的元素进行交换
            int temp =arr[i];
            arr[i]=arr[randomIndex];
            arr[randomIndex]=temp;
        }
        // 当循环结束之后，那么数组中所有的数据已经打乱顺序了
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"");
        }
    }
}

13. 数组的内存图