学习目标

能够知道数组的定义格式   
	动态初始化:指定数组的长度,有默认初始化值
	静态初始化:创建数组并附初始化值
能够使用两种方式完成数组元素的初始化 
	动态初始化:int[] arr = new int[10];
	静态初始化:int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10};
    静态初始化:int[] arr = {1,2,3,4,5,6,7,8,9,10};
能够知道数组在内存中的初始化过程
     栈:运行方法(main方法入栈执行),在方法中定义变量 int[] arr
     堆:存储对象,new出来的 new int[10];
     方法区:存储运行后的.class文件
能够完成数组的遍历操作(重点)            
	int[] arr = {1,2,3,4,5,6,7,8,9,10};  数组名.fori==>arr.fori
	for(int i=0; i<arr.length; i++){
		System.out.println(arr[i]);
	}
能够完成数组的获取最值操作
	int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10};
	int max = arr[0];
	int min = arr[0];
    for(int i=0; i<arr.length; i++){
		if(arr[i]>max){
            max = arr[i];
        }
        if(arr[i]<min){
            min = arr[i];
        }
	}
	System.out.println(max);
	System.out.println(min);
能够知道数组在运行过程中出现的异常
	1.数组的索引越界异常,访问了数组不存在的索引  int[] arr = {1,2,3}; sout(arr[3]);
	ArrayIndexOutOfBoundsException
	2.数组的空指针异常,数组的值为null,不能在使用数组了  int[] arr = null; sout(arr.length);
	NullPointerException

第一章：数组的定义格式

1.数组的概述

• 数组:是引用数据类型的一种,是一个容器,可以存储同种数据类型的多个数据
• 数组可以存储的数据类型有基本数据类型(4类8种),也可以存储引用数据类型(字符串String,自定义类型Person)
• 数组的长度是固定的,不能改变

2.数组的定义格式

package com.itheima.demo01Array;

/*
    数组的定义
 */
public class Demo01Array {
    public static void main(String[] args) {
        //1.动态初始化创建数组:指定数组的长度,数组中有默认初始化值
        //创建一个长度为3的int类型的数组
        int[] arr1 = new int[3];//{0,0,0}

        /*
            数组也是定义了一个引用数据类型的变量
            数据类型    变量名  = 创建对象;
            int[]       arr1    = new int[3];
            等号的左边:
                int:数组中元素的类型
                []:定义数组的固定格式
                arr1:给数组起了一个名字
            等号右边:
                new:创建对象的关键字
                int:数组中元素的类型(必须和左边一样)
                []:定义数组的固定格式
                3:指定数组的长度
            =:赋值运算符:把右边的对象赋值给左边的数组类型的变量
         */

        //创建一个长度为5的double类型的数组
        double[] arr2 = new double[5];//{0.0,0.0,0.0,0.0,0.0}

        //2.静态初始化创建数组:在创建数组的时候,给数组赋指定的初始值
        //创建一个int类型的数组,给数组赋值1,2,3,4,5
        int[] arr3 = new int[]{1,2,3,4,5};

        //创建一个String类型的数组,给数组赋值"沈腾","贾玲","小岳岳"
        String[] arr4 = new String[]{"沈腾","贾玲","小岳岳"};

        //静态初始化简化格式
        int[] arr5 = {1,2,3,4,5};
        String[] arr6 = {"沈腾","贾玲","小岳岳"};
    }
}

3.数组的使用格式

package com.itheima.demo01Array;

/*
    数组的使用
        1.可以使用数组的名字和数组的索引(房间号),来操作数组中存储值(元素)
            格式: 数组名[索引] arr[0] arr[1]...
            String[] arr = new String[]{"沈腾","贾玲","小岳岳"};
            a.取出数组中的元素的值
                直接输出值: System.out.println(arr[0]); //"沈腾"
                把值赋值给一个变量:  数组的数据类型 变量名 = 数组名[索引]
                    String s1 = arr[1]; System.out.println(s1);//贾玲
            b.给数组中的元素赋值
                数组名[索引] = 新的值;
                给数组中2索引处的元素重新赋一个值"郭德纲"  arr[2] = "郭德纲";
                System.out.println(arr[2]);
       2.数组有一个属性叫length,可以获取数组的长度(存储的元素个数)
                arr.length;==>3
 */
public class Demo02Array {
    public static void main(String[] args) {
        //定义一个数组
        String[] arr = new String[]{"沈腾","贾玲","小岳岳"};
        //a.取出数组中的元素的值
        //直接输出
        System.out.println(arr[0]);//沈腾
        System.out.println(arr[1]);//贾玲
        System.out.println(arr[2]);//小岳岳
        //把值赋值给一个变量
        String s1 = arr[1];
        System.out.println("s1:"+s1);//s1:贾玲

        //b.给数组中的元素赋值
        // 给数组中2索引处的元素重新赋一个值"郭德纲"
        arr[2] = "郭德纲"; //{"沈腾","贾玲","郭德纲"};
        System.out.println(arr[2]);//郭德纲

        //2.数组有一个属性叫length,可以获取数组的长度
        System.out.println(arr.length);//3
    }
}

数组定义和使用练习

package com.itheima.demo01Array;

/*
    数组使用练习:
    1.创建一个长度为5的int类型的数组
    2.取出数组3索引处的元素并打印
    3.给数组3索引处的元素重新赋值88
    4.取出数组3索引处的元素并打印
    5.把数组3索引处的元素赋值给一个变量a,打印变量a的值
    6.打印数组的长度

    3索引:第4个元素
    数组的索引[0,数组长度-1]
 */
public class Demo03ArrayTest {
    public static void main(String[] args) {
        //1.创建一个长度为5的int类型的数组
        int[] arr = new int[5];//{0,0,0,0,0}
        //2.取出数组3索引处的元素并打印
        System.out.println(arr[3]);//0
        //3.给数组3索引处的元素重新赋值88
        arr[3] = 88;//{0,0,0,88,0}
        //4.取出数组3索引处的元素并打印
        System.out.println(arr[3]);//88
        //5.把数组3索引处的元素赋值给一个变量a,打印变量a的值
        int a = arr[3];
        System.out.println("a:"+a);//a:88
        //6.打印数组的长度
        System.out.println(arr.length);//5
    }
}

4.数组的遍历

package com.itheima.demo01Array;

/*
    数组遍历(遍历数组):依次打印数组中的元素
 */
public class Demo04Array {
    public static void main(String[] args) {
        //定义一个String类型的数组,并进行静态初始化赋值
        String[] arr = {"科比","乔丹","韦德","姚明","蔡徐坤","詹姆斯"};
        //依次打印数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println(arr[5]);
        System.out.println("------------------------------");
        //使用循环来遍历数组:循环的作用就是依次获取数组的索引 [0,arr.length-1]
        for (int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

5.数组操作的常见问题(避免)

package com.itheima.demo01Array;

/*
    数组操作的常见问题
 */
public class Demo05ArrayError {
    public static void main(String[] args) {
        //1. 定义错误：
        //动态初始化定义数组,必须指定长度
        //int[] arr = new int[];//错误，没有指定长度
        //静态初始化,不能写长度
        //int[] arr = new int[3]{10,20,30,40};//错误，这种格式下，不能指定长度

        /*
            2. 索引越界异常: 使用索引,超出了索引的范围,就会抛出索引越界异常
            索引越界异常:在程序运行的时候会抛出
         */
        int[] arr = new int[3];//{0,0,0}  索引:0,1,2
        //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3

        /*
            3. 空指针异常:给数组变量赋了一个值null(空),那么对象就不存在了(房子被拆了)
                在使用数组,就会抛出空指针异常
         */
        arr = null;
        System.out.println(arr[0]);//NullPointerException
    }
}

6.数组练习

package com.itheima.demo01Array;

/*
    数组遍历练习
 */
public class Demo06ArrayTest {
    public static void main(String[] args) {
        //1. 请定义5个长度的数组，可以存储并打印(遍历)以下5名学员的姓名：
        //“杨幂”，“刘恺威”，“古力娜扎”，“柳岩”，“郭德纲”
        String[] arr1 = new String[5];
        arr1[0] = "杨幂";
        arr1[1] = "刘恺威";
        arr1[2] = "古力娜扎";
        arr1[3] = "柳岩";
        arr1[4] = "郭德纲";
        for(int i=0; i<arr1.length;i++){
            System.out.println(arr1[i]);
        }
        System.out.println("---------------------------------------");
        //2. 请定义5个长度的数组，可以存储并打印(遍历)5名学员的性别：
        //    ‘女’，  ‘男’，  ‘女’，  ‘女’，  ‘男’
        char[] arr2 = {'女','男','女','女','男'};
        //遍历的快捷键: 数组名.fori==>回车
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        System.out.println("---------------------------------------");
        //3. 请定义5个长度的数组，可以存储并打印(遍历)5名学员的身高：
        //1.65,   1.85,   1.70,   1.68,   1.85
        double[] arr3 = {1.65,1.85,1.70,1.68,1.85};
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }
        System.out.println("---------------------------------------");
        //4. 请将以上三个数组“反向遍历”，并打印每个元素！！
        for(int i= arr1.length-1; i>=0 ; i--){
            //System.out.println(arr1[i]);//i=4,3,2,1,0
            System.out.print(arr1[i]+" ");
        }
        System.out.println();//换行
    }
}

第二章：数组的内存图解

1.初识 JVM 运行时内存

• 方法区:加载运行后的.class文件

• 栈内存:运行方法(main方法),方法中的变量存储的都是局部变量,在出了变量的作用域,就会在内存中消失

• 堆内存:存储对象(new出来的)

  • 每个堆内存中的对象都有一个十六进制的地址值

  • 我们可以使用这个地址值,来找到这个对象

  • 堆内存中存储数据都有默认初始化值

    • 基本数据类型:4类8种

      整数:byte,short,int,long初始化值为0

      小数:float,double初始值为0.0

      字符:char初始值为’\u0000’,也就是一个空格 ’ ’

      布尔:boolean初始值为false

    • 引用数据类型:数组,集合,类(自定义,java提供的(String,Scanner,Random))

      所有的引用数据类型,默认初始化值都是null(null常量)

• 寄存器:即将交给CPU执行的指令

• 本地方法区:存储native修饰的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fLSbjqKv-1619531404871)(img/1617677874374.png)]

2.一个数组的内存图

package com.itheima.demo02Array;

/*
    一个数组的内存图
 */
public class Demo01Array {
    public static void main(String[] args) {
        //定义一个长度为3的int类型数组
        int[] arr = new int[3];
        //依次打印数组的名字和数组中元素 十六进制(0-9 a-f(10-15))
        System.out.println(arr);//[I@4554617c
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0
        //给数组中元素赋值
        arr[1] = 88;
        arr[2] = 99;
        //依次打印数组的名字和数组中元素
        System.out.println(arr);//[I@4554617c
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//88
        System.out.println(arr[2]);//99
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ii1kyLTY-1619531404874)(img/1617678673749.png)]

3.两个数组的内存图

package com.itheima.demo02Array;

/*
    两个数组的内存图
 */
public class Demo02Array {
    public static void main(String[] args) {
        double[] arr1 = new double[3];
        double[] arr2 = {1.1,2.2,3.3};
        //依次打印数组名和数组中的元素
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        //改变数组中元素的值
        arr1[1] = 100.0;
        arr2[2] = 8.8;
        //依次打印数组名和数组中的元素
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jsHUdz11-1619531404876)(img/1617679358892.png)]

4.两个数组指向一个对象内存图

package com.itheima.demo02Array;

/*
    两个数组指向一个对象内存图
 */
public class Demo03Array {
    public static void main(String[] args) {
        String[] arr1 = new String[]{"迪丽热巴","古力娜扎","佟丽娅"};
        //依次打印数组名和数组中元素
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        //定义一个数组,把arr1的地址赋值新数组
        String[] arr2 = arr1;
        //改变数组中元素的值
        arr2[1] = "柳岩";
        //依次打印数组名和数组中元素
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MWXDvV63-1619531404877)(img/1617680177107.png)]

第三章：数组的常见操作

1.挑选数组中符合条件的元素

需求:有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印：大于等于130斤以上的体重值。

package com.itheima.demo03Test;

/*
    常见操作一：挑选
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印：大于等于130斤以上的体重值。
    分析:
        1.定义一个数组,存储学员的体重
        2.遍历数组,获取数组中的每一个元素
        3.判断获取到的元素是否大于等于130
        4.是则打印
 */
public class Demo01Test {
    public static void main(String[] args) {
        //1.定义一个数组,存储学员的体重
        int[] arr = {120,130,110,125,128,164};
        //2.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //3.判断获取到的元素是否大于等于130
            if(arr[i]>=130){
                //4.是则打印
                System.out.println(arr[i]);
            }
        }
    }
}

2.数组中元素求和

需求:有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印这6名学员的总体重。

package com.itheima.demo03Test;

/*
    常见操作二：求和
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印这6名学员的总体重。
    分析:
        1.定义一个数组,存储学员的体重
        2.定义一个初始化变量,值为0,记录累加求和
        3.遍历数组,获取数组中的每一个元素
        4.累加求和
        5.输出求和结果
 */
public class Demo02Test {
    public static void main(String[] args) {
        //1.定义一个数组,存储学员的体重
        int[] arr = {120,130,110,125,128,164};

        //2.定义一个初始化变量,值为0,记录累加求和
        int sum = 0;

        //3.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.累加求和
            sum+=arr[i];
        }
        
        //5.输出求和结果
        System.out.println("sum:"+sum);
    }
}

3.数组中元素求平均值

需求:有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印这6名学员的平均体重。

package com.itheima.demo03Test;

/*
    常见操作三：求平均值
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印这6名学员的平均体重。
    分析:
        1.定义一个数组,存储学员的体重
        2.定义一个初始化变量,值为0,记录累加求和
        3.遍历数组,获取数组中的每一个元素
        4.累加求和
        5.循环结束使用和/数组的长度,平均值
        6.输出平均值
 */
public class Demo03Test {
    public static void main(String[] args) {
        //1.定义一个数组,存储学员的体重
        int[] arr = {120,130,110,125,128,164};
        //2.定义一个初始化变量,值为0,记录累加求和
        int sum = 0;
        //3.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.累加求和
            sum+=arr[i];
        }
        //5.循环结束使用和/数组的长度,平均值
        int avg = sum/ arr.length;
        //6.输出平均值
        System.out.println("平均的体重为:"+avg);
    }
}

4.求数组中元素的最大值

需求:有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印这6名学员的最大体重。

package com.itheima.demo03Test;

/*
    常见操作四：求最大值|最小值
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印这6名学员的最大体重。
    分析:
       1.定义一个数组,进行静态初始化赋值
       2.定义一个变量作为最大值,把数组的第一个元素赋值给最大值
       3.遍历数组,获取数组中的其他元素
       4.使用遍历得到的元素和最大值比较
       5.如果遍历得到的元素大于最大值,把元素赋值给最大值
       6.输出最大值
 */
public class Demo04Test {
    public static void main(String[] args) {
        //1.定义一个数组,进行静态初始化赋值
        int[] arr = {120,130,110,125,128,164};
        //2.定义一个变量作为最大值,把数组的第一个元素赋值给最大值
        int max = arr[0];
        //3.遍历数组,获取数组中的其他元素
        for (int i = 1; i < arr.length; i++) {
            //4.使用遍历得到的元素和最大值比较
            if(arr[i]>max){
                //5.如果遍历得到的元素大于最大值,把元素赋值给最大值
                max = arr[i];
            }
        }
        //6.输出最大值
        System.out.println("max:"+max);
        System.out.println("---------------------------");
        //计算最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]<min){
                min = arr[i];
            }
            //min = arr[i]<min?arr[i]:min;
        }
        System.out.println("min:"+min);
    }
}

5.统计符合条件元素的个数

需求:有以下数组，存储了6名学员的体重：
int[] arr = {120,130,110,125,128,164};
请编程计算并打印：大于、等于130的元素的个数。

package com.itheima.demo03Test;

/*
    常见操作五：统计
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印：大于、等于130的元素的个数。
    分析:
        1.定义一个数组,进行静态初始化赋值
        2.定义一个变量,值为0,记录统计的个数
        3.遍历数组,获取数组中的每一个元素
        4.判断获取到的元素大于等于130
        5.是,则统计变量++
        6.输出结果
 */
public class Demo05Test {
    public static void main(String[] args) {
        //1.定义一个数组,进行静态初始化赋值
        int[] arr = {120,130,110,125,128,164};
        //2.定义一个变量,值为0,记录统计的个数
        int count=0;
        //3.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.判断获取到的元素大于等于130
            if(arr[i]>=130){
                //5.是,则统计变量++
                count++;
            }
        }
        //6.输出结果
        System.out.println("count:"+count);
    }
}

6.从控制台接收数据

需求:有以下数组：int[] arr = new int[5];

请编程从控制台接收5名学员的年龄，并存储到数组中。
遍历数组，打印每个年龄值。

package com.itheima.demo03Test;

import java.util.Scanner;

/*
    常见操作六：从控制台接收数据
        有以下数组：int[] arr = new int[5];
        请编程从控制台接收5名学员的年龄，并存储到数组中。
        遍历数组，打印每个年龄值。
    分析:
        1.定义一个长度为5的int类型数组
        2.创建Scanner对象,为Scanner变量赋值
        3.遍历数组,获取数组中的每一个元素
        4.使用Scanner对象中的方法nextInt,获取用户键盘输入的年龄,
        5.把用户输入的年龄,给数组中的元素依次赋值
        6.遍历数组，打印每个年龄值
 */
public class Demo06Test {
    public static void main(String[] args) {
        //1.定义一个长度为5的int类型数组
        int[] arr = new int[5];
        //2.创建Scanner对象,为Scanner变量赋值
        Scanner sc = new Scanner(System.in);
        //3.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.使用Scanner对象中的方法nextInt,获取用户键盘输入的年龄
            System.out.println("请输入第"+(i+1)+"位学生的年龄:");
            //int age = sc.nextInt();
            //5.把用户输入的年龄,给数组中的元素依次赋值
            //arr[i] = age;
            arr[i] = sc.nextInt();
        }
        System.out.println("----------------------------------------------");
        //6.遍历数组，打印每个年龄值
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

7.随机数填充数组

需求:有以下数组：int[] arr = new int[5];请编程随机生成5个1—100的整数，并存储到数组中。
遍历数组，打印每个值。

package com.itheima.demo03Test;

import java.util.Random;

/*
    常见操作七：随机数填充数组
        有以下数组：int[] arr = new int[5];请编程随机生成5个1—100的整数，并存储到数组中。
        遍历数组，打印每个值。
   分析:
        1.定义一个长度为5的int类型的数组
        2.创建Random对象,给Random变量赋值
        3.遍历数组,获取数组中的每一个元素
        4.随机产生一个1-100之间的整数,给遍历得到的元素赋值
        5.遍历数组，打印每个值
 */
public class Demo07Test {
    public static void main(String[] args) {
        //1.定义一个长度为5的int类型的数组
        int[] arr = new int[5];
        //2.创建Random对象,给Random变量赋值
        Random r = new Random();
        //3.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.随机产生一个1-100之间的整数,给遍历得到的元素赋值
            arr[i] = r.nextInt(100)+1;
        }
        //5.遍历数组，打印每个值
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

综合案例

综合案例1-成绩分析系统

需求:

分析学员的成绩，计算：平均分、最高分、最低分

现以一个班级10个同学的数学成绩为例，进行统计。求这个班级的数学平均成绩，最高分，最低分。

思路分析:

1.定义一个数组，对这10个同学的数学成绩进行保存
2.定义一个变量sum,初始值为0,记录累加求和
3.定义一个变量max,记录最高分,把数组第一个元素赋值给max
4.定义一个变量min,记录最低分,把数组第一个元素赋值给min
5.遍历数组,获取每一个同学的成绩
6.把遍历得到的成绩累加求和
7.判断遍历得到的成绩>max,则赋值给max
8.判断遍历得到的成绩<min,则赋值给min
9.根据成绩总和,计算平均值
10.输出平均成绩,最高分,和最低分

package com.itheima.demo04Test;

/*
    综合案例1-成绩分析系统
        分析学员的成绩，计算：平均分、最高分、最低分
        现以一个班级10个同学的数学成绩为例，进行统计。求这个班级的数学平均成绩，最高分，最低分。
   分析:
        1.定义一个数组，对这10个同学的数学成绩进行保存
        2.定义一个变量sum,初始值为0,记录累加求和
        3.定义一个变量max,记录最高分,把数组第一个元素赋值给max
        4.定义一个变量min,记录最低分,把数组第一个元素赋值给min
        5.遍历数组,获取每一个同学的成绩
        6.把遍历得到的成绩累加求和
        7.判断遍历得到的成绩>max,则赋值给max
        8.判断遍历得到的成绩<min,则赋值给min
        9.根据成绩总和,计算平均值
        10.输出平均成绩,最高分,和最低分
 */
public class Demo01Test {
    public static void main(String[] args) {
        //1.定义一个数组，对这10个同学的数学成绩进行保存
        int[] arr = {99,88,100,90,87,66,32,100,96,59};
        //2.定义一个变量sum,初始值为0,记录累加求和
        int sum = 0;
        //3.定义一个变量max,记录最高分,把数组第一个元素赋值给max
        int max = arr[0];
        //4.定义一个变量min,记录最低分,把数组第一个元素赋值给min
        int min = arr[0];
        //5.遍历数组,获取每一个同学的成绩
        for (int i = 0; i < arr.length; i++) {
            //6.把遍历得到的成绩累加求和
            sum+=arr[i];

            //7.判断遍历得到的成绩>max,则赋值给max
            if(arr[i]>max){
                max = arr[i];
            }
            //8.判断遍历得到的成绩<min,则赋值给min
            if(arr[i]<min){
                min = arr[i];
            }
        }
        //9.根据成绩总和,计算平均值
        int avg = sum/arr.length;

        //10.输出平均成绩,最高分,和最低分
        System.out.println("平均成绩:"+avg);
        System.out.println("最高分:"+max);
        System.out.println("最低分:"+min);
    }
}

综合案例2-双色球开奖核心算法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WUbLPMgj-1619531404879)(img/1614874354014.png)]

1、出奖号码由6个红球 + 1蓝球组成
2、每个红球是1—33之间的一个数字
3、蓝球是1—16之间的一个数字
4、本题目咱时不考虑：重复、红球排序的问题

package com.itheima.demo04Test;

import java.util.Random;

/*
    综合案例2-双色球开奖核心算法
    需求:
        1、出奖号码由6个红球 + 1蓝球组成
        2、每个红球是1—33之间的一个数字
        3、蓝球是1—16之间的一个数字
        4、本题目咱时不考虑：重复、红球排序的问题
   分析:
        1.定义一个长度为6的int类型的数组
        2.创建Random对象,为Random变量赋值
        3.遍历数组,获取每一个元素
        4.随机产生一个1-33之间的数字,给数组中的元素赋值
        5.随机产生一个1-16之间的数字,赋值给一个变量,作为蓝色球
        6.输出最终产生的双色球(遍历数组获取红球+篮球)
 */
public class Demo02Test {
    public static void main(String[] args) {
        //1.定义一个长度为6的int类型的数组
        int[] arr = new int[6];
        //2.创建Random对象,为Random变量赋值
        Random r = new Random();
        //3.遍历数组,获取每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.随机产生一个1-33之间的数字,给数组中的元素赋值
            arr[i] = r.nextInt(33)+1;
        }
        //5.随机产生一个1-16之间的数字,赋值给一个变量,作为蓝色球
        int blue = r.nextInt(16)+1;
        //6.输出最终产生的双色球(遍历数组获取红球+蓝球)
        System.out.print("红球:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println("蓝球:"+blue);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e9oE8Wg5-1619531404880)(img/1617699441025.png)]

综合案例3-盗墓解密程序

有一个古老的国王墓地，谁能找到解密程序就将能打开墓室大门；两个小偷在找到墓地后于是就开始研究规则
规则为：一串数字无论正着读还是反着读都是一样的。如：1234321 是有效的；345643 是无效的。

请你编程实现该程序的判断。

分析:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B51S72bY-1619531404881)(img/1617700193461.png)]

1、定义一个数组，用于保存输入的数字
2、使用循环判断数组中的第一个数，是否和最后一个相同，依此类推
3、若都相同，则为有效的数字
4、最后输出是否解密成功

package com.itheima.demo04Test;

/*
    综合案例3-盗墓解密程序
        有一个古老的国王墓地，谁能找到解密程序就将能打开墓室大门；两个小偷在找到墓地后于是就开始研究规则
        规则为：一串数字无论正着读还是反着读都是一样的。如：1234321 是有效的；345643  是无效的。
        请你编程实现该程序的判断。
    分析:
        1.定义一个数组,进行静态初始化赋值(赋值小偷的输入的密码)
        2.定义一个布尔类型标记变量,值为true
        3.遍历数组,获取数组的每一个元素
        4.依次比较数组的首尾元素是否相等
        5.首尾元素不同,把标记的值修改为false
        6.结束循环
        7.对标记进行判断
            true:解密成功
            false:解密失败
 */
public class Demo03Test {
    public static void main(String[] args) {
        //1.定义一个数组,进行静态初始化赋值(赋值小偷的输入的密码)
        int[] arr = {5,4,3,2,1,2,2,4,5};
        //2.定义一个布尔类型标记变量,值为true
        boolean flag = true;
        //3.遍历数组,获取数组的每一个元素
        for (int i = 0; i < arr.length/2; i++) {
            //4.依次比较数组的首尾元素是否相等
            if(arr[i]!=arr[arr.length-1-i]){
                //5.首尾元素不同,把标记的值修改为false
                flag =false;
                //6.结束循环
                break;
            }
        }
        //7.对标记进行判断
        if(flag){
            //true:解密成功
            System.out.println("恭喜您小偷同志,解密成功,可以盗墓了!");
        }else{
            //false:解密失败
            System.out.println("恭喜您小偷同志,解密失败,你可以挂了!");
        }
    }
}