Day5-循环高级和数组

         

1、无限循环

无限循环：循环一直停不下来。有三种格式，格式如下：
for(;;){
    System.out.println("学习");
}

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

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

2、跳转控制语句

continue：跳过本次循环，继续执行下次循环。

break：结束整个循环。

for( int i = 1 ; i <= 5 ; i++){
    if(i == 3){
        continue;
    }
    System.out.println("吃第" + i + "个包子");
}
输出结果为：
吃第1个包子
吃第2个包子
吃第4个包子
吃第5个包子


for( int i = 1 ; i <= 5 ; i++){ 
    if(i == 3){
        break;
    }
    System.out.println("吃第" + i + "个包子");
}
吃第1个包子
吃第2个包子

实战1：平方根。

键盘录入一个大于等于2的整数X，计算并返回X的平方根。结果只保留整数部分，小数部分将被舍去。

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;
            }
}

实战2：判断质数

package Test03;
import java.util.Scanner;

public class test05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number = sc.nextInt();  //记录输入的整数
        int i;
        for(i = 2 ; i <= number ; i++) {
            if (number % i == 0)
                break;  //找到能被number整除的数
        }
        if(i == number)    //判断这个数是不是number本身，如果是则number是质数
            System.out.println("是质数");
        else
            System.out.println("不是质数");
    }
}

3、随机数的生成

1、导包——Random这个类在哪
import java.util.Random;
导包的动作必须出现在类定义的上面

2、创建对象——表示我要开始用Random这个类了
Random r = new Random();
上面这个格式里面，只有r是变量名，可以变，其他的都不允许变。

3、生成随机数——真正开始干活了
int number = r.nextInt(随机数的范围);
上面这个格式里面，只有number是变量名，可以变，其他的都不允许变。

int number = r.nextInt(bound:100);    //生成的随机数范围为0-99，范围的默认起
                                        始点为0，终止点为所填数字的值减1。

int number = r.nextInt(bound:10) + 7;    //生成的随机数范围为7~16。因为原本生成的
范围是0~9，但是在这个范围的基础上加7之后，随机数的范围就变成了7~16

实战：猜数游戏

本次游戏有保底机制，即猜三次时，无论最后是否猜中，系统都提示猜中。

Random r = new Random();    //创建随机数对象
//在范围内生成一个随机数，此语句放在循环外，因为只生成一次随机数
int number = r.nextInt(bound:100)+1;    
Scanner sc = new Scanner(System.in);    //创建键盘录入对象
int count = 0;    //    记录猜数字的次数

while(true){    //利用循环，让用户一直猜。在循环条件中利用true，让循环无限
                  循环，只有遇到break的情况下循环才终止。猜数游戏才结束。
    System.out.println("请输入你要猜的数字");
    int guessNumber = sc.nextInt();

    count++;
    if(count == 3){
    System.out.println("猜中了");
    break;
    }

    if(guessNumber > number){
        System.out.println("大了");
    } else if(guessNumber < number){
            System.out.println("小了");
    }else {
    System.out.println("猜中了");
    break;    //猜中之后循环终止
    }
}

4、数组

1、数组的介绍

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

数组是一个定长的容器，必须指定数组的大小，代表存储元素的个数。

数组容器在存储数据的时候，需要结合隐式转换考虑。

例如：int类型的数组可以存储byte、short、int类型的数据；doulbe类型的数组可以存储byte、short、int、long、float、double类型的数据。

建议：数组容器的类型和存储的数据类型保持一致，有助于提高程序代码的可读性。

2、数组的定义

格式1：(常用)
数据类型[] 数组名      例如：int[] array

格式2：
数据类型 数组名[]       例如：int array[]

数组的初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。

数组初始化的方式一共有两种：静态初始化和动态初始化。

数组的长度一旦确定就不能被改变了。

数组的地址值表示：数组在内存中的位置。

数组的静态初始化格式如下：

完整格式：
数据类型[] 数组名 = new 数据类型 [] {元素1,元素2,元素3,......};
范例如下：
int[] array = new int [] {1,2,3,4,5,6};
double[] array2 = new double [] {1.2, 1.3, 1.4, 1.5};
String[] array3 = new String [] {"张三", "李四", "王二"};    //定义字符串类型的数组

简化格式：(常用)
数据类型[] 数组名 = {元素1,元素2,元素3,......};
范例如下：
int[] array = {1,2,3,4,5,6};
double[] array2 = {1.2, 1.3, 1.4, 1.5};
String[] array3 = {"张三", "李四", "王二"};    //定义字符串类型的数组

3、数组元素的访问

（1）、获取数组里面的元素。

格式为：
数组名[索引]    //索引的值的范围为  0 ~ 元素个数减1(即数组长度减1)

范例如下：
int[] arr = {1,2,3,4,5};
int number = arr[0];
System.out.println(number);    //1    
System.out.println(arr[1]);    //2

（2）、把数据存储到数组当中。

格式为：
数组名[索引] = 具体数据/变量;
细节：一旦覆盖之后，原来的数据就不存在了。

范例如下：
int[] arr = {1,2,3,4,5};
arr[0] = 100;
System.out.println(arr[0]);    //    100

4、数组的遍历

数组遍历是指：将数组中所有的内容取出来，取出来之后可以（打印、求和、判断...）

注意：遍历指的是取出数据的过程，不要局限的理解为遍历就是打印。‘

int[] arr = {1,2,3,4,5};
System.out.println(arr.length);    //打印数组长度的值
for(int i = 0 ; i < arr.length ; i++){
    System.out.println(arr[i]);
}

补充：
在Java当中，关于数组的一个长度属性，length
调用方式：数组名.length

扩展：
idea提供的快速生成数组的遍历方式
方法：数组名.fori+回车
例如：arr.fori+回车可快速打印以下内容：
for(int i = 0 ; i < arr.length ; i++){
    System.out.println(arr[i]);
}

5、数组的动态初始化

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

格式如下：
方式1：(常用)
数据类型[] 数组名 = new 数据类型[数组长度];

范例如下：
int[] arr = new int[3];

方式2：
数据类型 数组名[] = new 数据类型[数组长度];
范例如下：
int arr[] = new int[3];


以上两种方式，在创建的时候，由我们自己指定数组的长度，jvm虚拟机默认为数组中的每一个元素进行默认初始化赋值，根据不同的数组存储的数据类型的不同，初始值也不同
整数  0
小数  0.0
字符  \u0000
布尔  false
引用数据类型  null 表示地址为空，不指向任何类型

实战案例如下：

题目要求：

定义一个数组，用来存班级中50个学生的姓名，姓名未知，等学生报道之后，再进行添加。

String[] arr = new String[50];
//添加学生
arr[0] = "张三";
arr[1] = "李四";
System.out.println(arr[0]);    //张三
System.out.println(arr[1]);    //李四
System.out.println(arr[2]);    //null

补充扩展：
数组默认初始化值的规律：
整数类型：默认初始化值为0
小数类型：默认初始化值为0.0
字符类型：默认初始化值为'\u0000'，即空格
布尔类型：默认初始化值为false
引用数据类型：默认初始化值为null

6、数组动态初始化和静态初始化的区别

1、动态初始化：手动指定数组长度，由系统给出默认初始化值。
   只明确元素的个数，不明确具体数值，推荐使用动态初始化。

2、静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。
   需求中已经明确了要操作的具体数据，直接静态初始化即可。

7、数组常见的问题。

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

例如下面代码就会报错

int[] arr = {1,2,3,4,5};
//长度：5
//最小索引：0
//最大索引：4(数组长度减1)
System.out.println(arr[10]);

错误提示如下：

Exception：异常
in thread "main"：在main中
ArrayIndexOutOfBoundsException：数组索引超出范围异常
Index 10 out of bounds for length 5：索引10超出了数组的长度5
at com.itheima.arraydemo.ArrayDemo5.main(ArrayDemo5.java:10)表示：错误在某个包
某个类某个方法中，位置在第十行

 小结：

索引越界异常出现的原因是访问了不存在的索引，避免方式为要知道索引的范围。

最小索引范围：0

最大索引范围：数组长度减1

7.2、空指针异常

产生的原因，数组被赋值为null，还想要访问数组的内容。

package Test03;

public class test005 {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        arr = null;//设置数组为空引用null
        System.out.println(arr[1]); //此处发生错误，空指针错误

        int[] arr2 ={4,5,6};
        arr2 = null;
        //当数组为null的时候表示此事不指向任何位置
        //如果要强行访问某个元素，因为没有地址，找不到对应的内容,此事地址为空
        //就会出现索引越界异常
        //规避方式，访问之前判断是否为空
        if(arr2 != null){
            System.out.println(arr2[1]);
        }
    }
}

8、数组实战练习

（1）、求最大值

题目要求：定义数组求最大值：33，5，22，44，55

int[] arr = {33,5,22,44,55};    //定义数组来存储五个数
int max = arr[0];    //定义一个变量max，用来存储最大值
//循环获取数组中的每一个元素，拿着每一个元素跟max进行比较
for(int i = 1; i < arr.length; i++){
    if(arr[i] > max){    //如果数组元素的值比max中的值大，则把该数组元素的值记录到max当中
        max = arr[i];
    }
}
System.out.println(max);    //当循环结束之后，max记录的就是数组中的最大值。

解析：为什么max的初始值不能是0？
因为如果max的初始值定义为0，如果数组元素中最大元素的值为负数，则最大值结果将受到影响。
所以max的初始值一定要是数组当中的元素之一

解析：为什么循环的初始条件是1，而不是0？
答：循环的初始条件也可以为0，为0时，由于max记录的是arr[0]的值，于是相当于arr[0]与自身比较一
次，此次比较是非必要的，为了优化代码的执行时间，所以将循环条件设定为1，少执行一次不必要的循环

（2）、求和并统计数目

 题目要求：生成10个1~100之间的随机数存入数组。
                 1）求出所有数据的和
                 2)求所有数据的平均数
                 3)统计由多少个数据比平均数小

package lishuqiang;
import java.util.Random;

public class sss {
    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;    //设置随机数的范围为1~100
            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.print(arr[i] + " ");    //打印出所生成的随机数的值，方便验证答案
        }

        //System.out.print();输出的结果是在一行的，没有自动换行的效果
        //System.out.println();输出的结果具有自动换行的效果
    }
}

（3）、数据交换

要求如下：

定义一个数组，存入1，2，3，4，5.交换首尾索引对应的元素。

交换前：1，2，3，4，5。  交换后：5，4，3，2，1

//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.println(arr[i] + " ");
}

解析：i和j的作用，以及循环结束条件为i<j的原因
i从第一个元素开始，j从最后一个元素开始，两个元素通过temp为介质进行数据交换，
当元素个数为奇数的时候，循环会执行到i=j的情况，这个时候相当于最中间的元素与自身进行交换，
此时必须要让循环终止,原本循环执行的条件为i<j，所以不满足循环条件的时候，循环要终止

（4）、打乱数据

题目要求：

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

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);
    //拿着随即索引指向的元素 跟 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] + " ");
}

5、数组的内存图

p69 循环高级和数组-15-数组的内存图