java入门day05：无限循环，跳转控制语句，数组，java内存简单说明

我有JavaScript基础哈，笔记完全按自己需要写的。小伙伴们有觉得笔记不清楚的，在评论里说，记得写上具体的小标题序号。欢迎交流~

1.无限循环-了解

for无限循环是小括号内的语句都不写。

while的无限循环是小括号内一直为true，do...while同理。

无限循环常用： while 因为判断条件不明，初始值不明

tips:无限循环下面不能写其他语句了，因为循环会一直执行。循环外的语句永远执行不了

2.跳转控制语句

2.1跳过某一次循环 

2.2 结束循环

小老虎吃包子，吃到第三个的时候吃饱了 

3.综合练习：

范围：循环，分支语句

3.1 逢七过

游戏规则:从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数时都要说过:过
需求:使用程序在控制台打印出1-100之间的满足逢七必过规则的数据

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

3.2 平方根

需求:键盘录入一个大于等于2的整数x，计算并返回x的平方根结果只保留整数部分，小数部分将被舍去。
分析: 平方根16的平方根4  4的平方根2
10
1*1=1<10
2*2=4<10
3*3=9<10
4*4=16 >10
推断:10的平方根是在3~4之间

import java.util.Scanner;

public class xunhuan2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        for(int i = 1; i <= num; i++) {
            if(i * 1 == num ) {
                System.out.println(i + "是" + num + "的平方根");
                break; // 一定要加，不然会一直循环到i>num为止
            }else if(i * i > num) {
                System.out.println((i - 1) + "是" + num + "的平方根的整数");
                break;
            }
        }
    }
}

3.3 求质数

键盘录入 1 个正整数x，判断该整数是否为一个质数。

质数概念：这个数只能被1和它本身整除（所以我们写代码时，不能从1开始）

import java.util.Scanner;

public class xunhuan3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        boolean flag = true; //表示一个数是质数
        for(int i = 2; i < num; i++) {
            if(num % i == 0) {
                flag = false; //可以整除，说明不是质数，修改flag值
                break;
            }
//            是不是质数的打印  不能写在循环里，要执行完循环后，才知道num是不是质数
        }
        if(flag) {
            System.out.println(num + "是质数");
        }else {
            System.out.println(num + "不是质数");
        }
    }
}

3.4 猜数字

自动生成1-100之间的随机数字（java中的random类，参考Scanner的使用步骤）

前置知识和练习：

random的使用步骤： 

import java.util.Random;

public class suyijishu1 {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt(10); //包头不包尾  0-9之间的随机数
        System.out.println(num);

        for (int i = 0;i <= 100; i++) { 
            int res = r.nextInt(101);//生成0-100之间的随机数
            System.out.println(res);
        }
    }
}

随机生成7~15之间的随机数

import java.util.Random;

public class suijishu2 {
    public static void main(String[] args) {
        Random r = new Random();
//      让范围的头尾都减去一个值（这里减头）  例：7~15  0~8
//      尾巴+1        例： 8+1=9
//      随机数的代码后面加上减去的头，就是我们要的范围的随机数
        
        int num = r.nextInt(9) + 7; //此时范围： 头0+7=7  尾 9+7=16（不包尾，所以尾是15）
        
    }
}

前置知识和练习结束=======================================================

猜数字：程序生成一个1-100的随机数，用户猜测并输入一个数。对比两个数是否一样，一样就是用户猜中了.如果不一样，用户需要继续猜（用循环，但我们不知道循环次数，所以用什么呢~思考一下）

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

public class suijishu3 {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt(100) + 1; //不能写在循环内，不然猜一次，随机数换一次，猜中概率大大降低（需要运气爆棚）
        //System.out.println(num);//放开注释，用来测试猜中的情况是否会推出循环
        //用户输入
        while (true) {
            System.out.println("请输入猜测的数字");
            Scanner sc = new Scanner(System.in);
            int num1 = sc.nextInt();

            if(num1 > num) {
                System.out.println("猜大了");
            } else if (num1 < num) {
                System.out.println("猜小了");
            } else {
                System.out.println("猜中啦！！！！");
                break; //猜中了要推出循环，不能再继续猜
            }
        }


    }
}

拓展： 游戏中，抽卡抽奖，有多少次必中   我们这个案例中，用猜测6次必中来代替

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

public class suijishu3 {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt(100) + 1;
        //System.out.println(num);//放开注释，用来测试猜中的情况是否会推出循环
        //用户输入
        int count = 0;
        while (true) {
            System.out.println("请输入猜测的数字");
            Scanner sc = new Scanner(System.in);
            int num1 = sc.nextInt();
            count ++;
            if(count == 6) {
                System.out.println("猜中啦！！！！");
                break; //猜到第6次不论是否真的猜中，都提示猜中了，推出循环
            }
            if(num1 > num) {
                System.out.println("猜大了");
            } else if (num1 < num) {
                System.out.println("猜小了");
            } else {
                System.out.println("猜中啦！！！！");
                break; //猜中了要推出循环，不能再继续猜
            }
        }


    }
}

4. 数组

4.1什么是数组？

4.2数组的定义

4.3 数组的初始化

4.3.1 数组的静态初始化

完整格式（少用-可略过）

简写格式（常用-多练练）

创建完数组后，数组长度就不会发生改变了

注意点：注意我们要存什么类型数据，要用不同的数据类型进行定义

4.3.1.1地址值

 

4.3.1.2访问数组

格式： 数组名:[ 索引];

例如：

4.3.1.3 存储数据到数组中

 4.3.1.4 遍历数组

数组有长度，从1开始。数组名.length  就是数组的长度，那么我们for循环的范围就是数组的长度

tips：数组的索引从0开始，但是长度是从1开始计算。

public class bianliArray {
    public static void main(String[] args) {
        int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]); //中括号内是索引
        }
    }
}

tips：idea提供了遍历数组的快捷方式 fori + tab/回车，生成以下架子：

for (int i = 0; i < ; i++) {
            
}

练习1：

自己写一个int数组，求数组内所有数字的和

int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int sum = 0;
for (int i = 0; i < arr1.length; i++) {
   sum += arr1[i];
}
System.out.println(sum);

练习2：

自定义一个int数组，遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字

int arr2[] = {1,2,3,4,5,6,7,8,9,10};
int count = 0;
for (int i = 0; i < arr2.length; i++) {
    if(arr2[i] % 3 == 0) {
       count++;
    }
}
System.out.println("数组中能被3整除的个数有" + count); //3

 练习3：

遍历数组得到每一个元素。
要求:
1，如果是奇数，则将当前数字扩大两倍
2，如果是偶数，则将当前数字变成二分之一

int arr2[] = {1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < arr2.length; i++) {
   if(arr2[i] % 2 == 0) {
        arr2[i] = arr2[i] / 2; //这里的赋值，是改变原数组的数据的
        System.out.println("这是偶数的二分之一" + arr2[i]);
   }else {
        arr2[i] = arr2[i] * 2;
        System.out.println("这是奇数的两倍" + arr2[i]);
   }
}

4.3.2 数组的动态初始化

举例说明：

动态初始化和静态初始化的区别以及使用场景

 4.4 数组的常见问题

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

例如：数组长度为5 ，而我们访问arr[10]时，运行后会出现报错

提示我们，在main中有异常并且下标10超过了数组长度5，后面提示的是在哪个文件，第几行代码

4.5数组的常见操作

1. 求最值

需求1：求数组中的最大值

可用三元运算进行简化，并得到最大值的下标（索引）：

public class array03 {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5};
        int max = 0;
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            max = max > arr[i] ? max : arr[i]; //arr[i]表示的是值
            index = i; // i初始值是0，和数组的第一个下标相同。所以遍历第几次，下标就是几
        }
        System.out.println(max);
        System.out.println("最大值的下标是" + index);
    }
}
}

2. 求和

需求:生成10个1~100之间的随机数存入数组
1)求出所有数据的和
2)求所有数据的平均数
3)统计有多少个数据比平均值小

import java.util.Random;

public class sumArray {
    public static void main(String[] args) {
//      动态初始化一个长度为10的数组
        int arr[] = new int[10];
//        生成随机数，并存入数组
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int num = r.nextInt(100) + 1; //需要每循环一次，生成一个随机数，所以放在循环里
            arr[i] = num;
        }

//        求和/平均数
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println(sum);
        int meanNum = sum / arr.length;
        System.out.println("平均数" + meanNum);

//        统计有几个数比平均数小
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < meanNum) {
                count++;
            }
        }
        System.out.println("比平均数小的有"+ count +"个");

//        自己看数字验证以上是否正确
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " "); //在一行打印，并且用空格隔开
        }

    }
}

3. 交换数据

需求:定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素

交换前:1,2',4,5

交换后:5,2,3,4,1

public class changeArray {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5};
        //定义两个变量，一个存第一个数，一个存最后一个数
        //判断条件是i必须比j大，i= 1  j=5 ； i=2 j= 4 以此类推，如果i比j小或等于，那么说明，不需要互换了，3无论怎么换，都是在中间的
        //i++的同时j--,否则无法按顺序互换
        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]+" "); //5 4 3 2 1
        }
    }
}

4. 打乱数据

定义一个数组，存入1~5。要求打乱数组中所有数据的顺序。

思路：在交换练习的基础上，让第一个和随机出来的数组的索引进行交换

import java.util.Random;

public class daluanArray {
    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 rindex = r.nextInt(arr.length);//每次都要随机一个下标。范围就是数组的长度
            int temp = arr[i];
            arr[i] = arr[rindex];
            arr[rindex] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+ " ");
        }
    }
}

4.6 数组的内存图

4.6.1java内存

java运行时，虚拟机也会占用一块电脑的内存空间

下图，红色区域是目前学习会用到的，方法马上也会学习

堆内存和栈内存

例：java运行的可视化图

代码中没有new，所以只用到栈内存，main为主入口，当代码都执行完成后，会从栈内存中出去

4.6.2数组的内存

第一个式子，分为3步

1.栈内存中存了一个数组名

2.堆内存中存了一个数组，生成地址值

3.通过等号，把地址值赋值到了栈内存的数组名上。（这样，我们才能通过 数组名[索引] 访问到堆内存中对应的数据）

特殊情况：两个数组指向同一个内存空间

小总结：

1.只要是new出来的一定是在堆里面开辟了一个小空间（有地址值）

2.如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据

3.当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了（下图特殊情况中说明）