Java笔记_03（循环、数组）

一、判断与循环

1.1、顺序结构

顺序结构语句是Java程序默认的执行流程，按照代码的先后顺序，从上到下依次执行

1.2、分支结构

1.1.1、if语句

1. if语句的第一种格式

if (/*判断条件*/){
	//执行代码
};

注意点

• 大括号的开头可以另起一行书写，但是建议写在第一行的末尾
• 在语句体中，如果只有一句代码，大括号可以省略不写，个人建议，大括号还是不要省略
• 如果对一个布尔类型的变量进行判断，不要用==号，直接把变量写在小括号即可

2. if语句的第二种格式

if (/*判断条件*/){
	//执行代码
}else{
//执行代码
};

练习1

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身上的钱");
        int money = sc.nextInt();
        if (money >= 100){
            System.out.println("吃网红餐厅");
        }else{
            System.out.println("吃沙县小吃");
        }
    }
}

练习2

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入票号");
        int ticket = sc.nextInt();
        if (ticket >= 0 & ticket <= 100) {
            if (ticket % 2 == 1) {
                System.out.println("坐左边");
            } else {
                System.out.println("坐右边");
            }
        }
    }
}

3. if的第三种格式

if (/*判断条件*/){
	//执行代码
}else if{
//执行代码
}else if{
	//执行代码
}else{
	//执行代码
}
;

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        /*
        根据不同的分数送不同的礼物
        如果是90~100分，送自行车一辆
        如果是90~94分，游乐场玩一天
        如果是80~89分，送变形金刚一个
        如果是80分一下，揍一顿*/
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入小明的考试成绩");
        int score = sc.nextInt();
        if(score <= 100 && score >= 0){
            if (score >=95 && score <= 100){
                System.out.println("送自行车一辆");
            }else if (score >=90 && score <= 94){
                System.out.println("游乐场玩一天");
            } else if (score >=80 && score <= 89) {
                System.out.println("送变形金刚一个");
            }else {
                System.out.println("揍一顿");
            }
        }else {
            System.out.println("该成绩不合法");
        }
    }
}

练习

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        /*商场都会有vip的会员制，根据不同的会员会有不同的折扣
        假设商品的总价为1000，
        键盘录入会员级别，并计算出实际支付的钱，
        会员级别1级：打9折。
        会员级别2级：打8折。
        会员级别3级：打7折。
        非会员：不打折
         */
        int price = 1000;
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入会员级别");
        int vip = sc.nextInt();
        if (vip == 1){
            System.out.println("实际支付的钱为" + (price * 0.9));
        }else if (vip == 2){
            System.out.println("实际支付的钱为" + (price * 0.8));
        }else if (vip == 3){
            System.out.println("实际支付的钱为" + (price * 0.7));
        }else {
            System.out.println("实际支付的钱为" + price);
        }
    }
}

1.1.2、switch语句

1. 格式

switch(表达式){
	case值1:
		语句体1;
		break;
	case值2:
		语句体2;
		break;
	default:
	语句体n+1;
	break;
}

2. switch其他知识点

• default的位置和省略
  • 位置：default不一定是写在最下面，我们可以写在任意位置，只不过习惯会写在最下面
  • 省略：default可以省略，语法不会有问题，但是不建议省略
• case穿透

就是语句体中没有写break导致的

执行流程：

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

• switch新特性（JDK12才可以使用）
  case后面跟上的{}可以替换成->
• switch和if第三种格式各自的使用场景
  • if的第三种格式：一般用于对范围的判断
  • switch：把有限个数据一一列举出来，让我们任选其一

1.3、循环结构

1.3.1、for语句

格式:
for (int i = 1 ;i <= 10 ;i++ ){
	system.out.println( "Helloworld" );
}

• 核心：
  • 初始化语句只执行一次
  • 判断语句为true，循环继续
  • 判断语句为false，循环结束
• 扩展小点
  • 求和的变量不能定义在循环的里面，因为变量只在所属的大括号中有效
  • 如果我们把变量定义在循环的里面，那么当前变量只能在本次循环中有效，当本次循环结束之后，变量就会从内存中
• 练习
  

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个数表示范围的开始");
        int start = sc.nextInt();
        System.out.println("请录入一个数表示范围的结束");
        int end = sc.nextInt();
        int count = 0;
        for (int i = start; i <= end; i++) {
            if (i % 3 ==0 && i % 5 ==0) {
                count++;
            }
        }
        System.out.println(count);
    }
}

1.3.2、while循环

格式:
初始化语句;
whi1e(条件判断语句){
	循环体语句;
	条件控制语句;
}

1. for和while的对比

• 相同点：运行规则都是一样的
• for和while的区别
  • for循环中：知道循环次数或者循环的范围
  • while循环中：不知道循环的次数和范围，只知道循环的结束条件

2. 练习
   

public class Test1 {
    public static void main(String[] args) {
        int x = 12345;
        int temp = 12345;
        int num = 0;
        while (x != 0){
            int ge = x % 10;
            x = x / 10;
            num = num * 10 + ge;
        }
        System.out.println(num == temp);
    }
}

public class Test1 {
    public static void main(String[] args) {
        int dividend = 100;
        int count = 0;
        int divisor = 3;
        while (dividend >= divisor){
            dividend = dividend - divisor;
            count++;
        }
        System.out.println("商是：" + count);
        System.out.println("余数是：" + dividend);
    }
}

1.3.3、do…while循环

格式:
初始化语句;
do {
	循环体语句;
	条件控制语句;
	}while(条件判断语句);

1.4、循环高级

1.4.1、无限循环

for (;;){
            System.out.println("学习");

while (true){
            System.out.println("学习");

do {
	System.out.println("学习");
} while(true);

注意事项：无限循环的下面不能再写其它代码了，因为循环永远停不下来，那么下面的代码永远执行不到

1.4.2、跳转控制语句

1. continue：跳过本次循环，继续执行下次循环
2. break：结束整个循环

1.5、逢七过

public class Test1 {
    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);
        }
    }
}

1.6、平方根

import java.util.Scanner;

public class Test1 {
    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;
            }
        }
    }
}

1.7、判断是否为质数

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数");
        int number = sc.nextInt();
        boolean flag = true;
        for (int i = 2; i < number - 1; i++) {
            if (number % i == 0){
                flag = false;
                break;
            }
        }if(flag){
            System.out.println(number + "是一个质数");
        }else {
            System.out.println(number + "不是一个质数");
        }
    }
}

1.8、猜数字小游戏

1. 获取随机数

Java帮我们写好一个类叫Random，这个类可以生成一个随机数

判断技巧：在小括号中，书写的是生成随机数的范围，这个范围一定是从0开始的，到这个数-1结束
口诀：包头不包尾，包左不包右
2. 练习

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

public class Test1 {
    public static void main(String[] args) {
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你猜的数字");
        while (true) {
            int guessNumber = sc.nextInt();
            if (guessNumber > number) {
                System.out.println("大了");
            } else if (guessNumber < number) {
                System.out.println("小了");
            } else {
                System.out.println("猜对了");
                break;
            }
        }
    }
}

注意点：生成随机数的代码不能不能写在循环里面，否则每一次都会产生一个新的随机数

二、数组

2.1、数组介绍

数组是一种容器，可以用来存储同种数据类型的多个值

• 数组容器在存储数据的时候，需要结合隐式转换考虑
• 例如：int类型的数组容器（byte short int）
• 例如：double类型的数组容器（byte short int long float double）
• 建议：容器的类型，和存储的数据类型保持一致

2.2、数组的定义与静态初始化

• 数组的定义：
  • 数据类型 【】数组名
  • 数据类型 数组名 【】
• 静态初始化
  • 初始化:就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程
  • 完整格式:数据类型[]数组名= new数据类型[]{元素1，元素2，元素3... };
  • 简化格式:数据类型[]数组名={元素1，元素2，元素3...};

2.3、数组的地址值和元素访问

定义一个数组，直接打印该数组拿到的是数组的地址值

• 解释一下地址值的格式含义[D@776ec8df
• [:表示当前是一个数组
• D:表示当前数组里面的元素都是double类型的
• @:表示一个间隔符号。(固定格式）
• 776ec8df:才是数组真正的地址值，（十六进制）
• 平时我们习惯性的会把这个整体叫做数组的地址值。

索引

• 索引：也叫做下标，角标
• 索引的特点:从0开始，逐个+1增长，连续不间断

2.4、数组的遍历

• 数组遍历:将数组中所有的内容取出来，取出来之后可以（打印，求和，判断…)
• 注意:遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印!

通过数组.length可以打印直接得出数组的长度，利用for循环就可以遍历数组

练习

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i = 0; i < arr.length; i++) {
            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]);
        }
    }
}

2.5、数组的动态初始化和常见问题

初始化时只指定数组长度，由系统为数组分配初始值

• 格式:数据类型[]数组名= new数据类型[数组长度];
• 范例: int[]arr = new int[3];

数组默认初始化值的规律:

• 整数类型:默认初始化值0
• 小数类型:默认初始化值0.0
• 字符类型:默认初始化值'\u0000'空格
• 布尔类型:默认初始化值false
• 引用数据类型:默认初始化值null

动态初始化和静态初始化的区别

• 动态初始化：手动指定数组长度，由系统给出默认初始化值
  • 只明确了元素个数，不明确具体数值，推荐使用动态初始化
• 静态初始化：手动指定数组长度，系统会根据元素个数，计算出数组的长度
  • 需求中已经明确了要操作的具体数据，直接静态化初始即可

数组常见问题

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

2.6、数组的常见操作

2.6.1、求最值

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {33,5,22,44,55};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println(max);
    }
}

2.6.2、遍历数组求和

import java.util.Random;

public class Test2 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int number = r.nextInt(100) + 1;
            arr[i] = number;
        }
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        System.out.println("随机数的和为：" + sum);
        int avg = sum / arr.length;
        int count = 0;
        System.out.println("随机数的平均数为：" + avg);
        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.print(arr[i] + "  ");
        }
    }
}

2.6.3、交换数组中的数据

int[] arr={1,2,3,4,5};
for(int i =0,j=arr.length-1;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]+"");
}

头尾交换

public class Test3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i = 0,j = arr.length - 1;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] + "  ");
        }
    }
}

2.6.4、打乱数组中的数据

import java.util.Random;

public class Test3 {
    public static void main(String[] args) {
        int[] arr ={1,2,3,4,5};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int randomIndex = r.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = arr[i];
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }
}

2.7、数组的内存图

Java内存分配

1. 只要是new出来的一定是在堆里面开辟了一个小空间
2. 如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据
3. 当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。