一、前言

数组数什么？

数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）。

场景：

关于数组需要学会什么？

二、数组的定义

静态初始化数组

定义

定义数组的时候直接给数组赋值.

静态初始化数组的格式：

举例：

public class ArrrayDemo1 {
    public static void main(String[] args) {
        //学会使用静态初始化的方式定义数组
        //数据类型[] 数组名称 =new 数据类型[] {元素1，元素2，元素3.....};

        //double[] scores=new double[]{99.5,88.0,75.5};
        double[] scores={99.5,88.0,75.5};

        //int[] ages=new int[]{12,24,36};
        int[] ages={12,24,36};

        //String[] names=new String[]{"牛二","全蛋儿","老王"};
        String[] names={"牛二","全蛋儿","老王"};
    }
}

数组的基本原理：

注意：
数组变量名称中存储的是数组在内存中的地址，数组是引用类型。

 //double[] scores=new double[]{99.5,88.0,75.5};
        double[] scores={99.5,88.0,75.5};
        System.out.println(scores);

小结：

数组的访问

==格式：

举例：

public class ArrayDemo2 {
    public static void main(String[] args) {
        //目标：学会访问数组的元素
        int[] ages={12,24,36};

        //取值：数组名称[索引]
        System.out.println(ages[0]);
        System.out.println(ages[1]);
        System.out.println(ages[2]);

        //赋值：数组名称[索引]=数据
        ages[2]=100;
        System.out.println(ages[2]);

        //访问数组长度：
        System.out.println(ages.length);
    }
}

运行结果：

问题： 数组的最大索引可以怎么表示？

数组名.length-1 //前提：元素个数大于0

小结：

数组的几个注意事项

//目标：理解数组的注意事项
        //1.数据类型[] 数组名称，也可以写成  数据类型 数组名称[]
        int[] ages={11,12,13};
        int ages2[]={11,12,13};

        //2.什么类型的数组只能存放什么类型的元素
        //String[] names={"西门吹雪","东方不败",23};//报错

        //3.数组一旦定义出来之后，类型和长度就固定了
        int[] ages3={11,23,45};
        //System.out.println(ages3[3]);//报错
    }

动态初始化数组

定义

举例：

public class ArrayDemo4 {
    public static void main(String[] args) {
        //目标：学会动态初始化数组的定义
        double[] scores=new double[3];//[0.0,0.0,0.0]

        scores[0]=99.5;
        System.out.println(scores[0]);

        System.out.println(scores[2]);


        String[] names=new String[90];
        names[0]="迪丽热巴";
        names[2]="马尔扎哈";
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
    }
}

运行结果：

小结：

动态初始化数组的元素默认值

元素默认值规则：

两种初始化的使用场景总结、注意事项：

代码：

 //目标：掌握动态初始化元素默认值的规则
        //1.整形数组的元素默认值都是0
        int[] arr=new int[10];
        System.out.println(arr[0]);
        System.out.println(arr[9]);

        //2.字符数组的元素默认值：0
        System.out.println();
        char[] chars=new char[100];
        System.out.println((int)chars[0]);
        System.out.println((int)chars[9]);

        //3.浮点型数组的元素默认值是0.0
        System.out.println();
        double[] scores=new double[90];
        System.out.println(scores[0]);
        System.out.println(scores[89]);

        //4.布尔型的数组
        System.out.println();
        boolean[] booleans=new boolean[100];
        System.out.println(booleans[0]);
        System.out.println(booleans[99]);

        //5.引用类型数组
        System.out.println();
        String[] names=new String[90];
        System.out.println(names[0]);
        System.out.println(names[89]);


    }

运行结果：

小结：

三、数组的遍历

数组遍历的介绍：

小结：

四、数组的案例

数组的元素求和

代码：

public class Test1 {
    public static void main(String[] args) {
        //数组元素求和
        //1.把这些数据拿到程序中使用数组记住
        int[] money={16,32,8,100,78};

        //3.定义一个求和变量累加数组的元素值
        int sum=0;

        //2.遍历数组的每个元素
        for (int i = 0; i < money.length; i++) {
            sum+=money[i];
        }

        //4.输出求和变量
        System.out.println("数组的元素和是：" + sum);
    }
}

运行结果：

小结：

数组求最值

代码：

public class Test2 {
    public static void main(String[] args) {
        //数组元素求最值
        //1.定义一个静态初始化数组，存储一批颜值
        int[] faceScore={15,9000,10000,20000,9500,-5};
        
        //2.定义一个变量用于存储最大值元素，建议使用第一个元素作为参照
        int max=faceScore[0];
        
        //3.遍历数组的每个元素，依次与最大值进行比较，若较大，则替换
        for (int i = 1; i < faceScore.length; i++) {
            if(faceScore[i]>max){
                max=faceScore[i];
            }
        }

        //4.输出最大值变量存储的数据即可
        System.out.println("数组的最大值是：" + max);
    }
}

运行结果：

小结：

猜数字游戏

代码：

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

public class Test3 {
    public static void main(String[] args) {
        //需求：5个1-20之间的随机数，让用户猜测
        //1.定义一个动态初始化数组存储5个1-20之间的数据
        int[] data=new int[5];

        //2.动态的生成5个1-20之间的随机数并存入到数组中去
        Random r=new Random();
        for (int i = 0; i < data.length; i++) {
            data[i]=r.nextInt(20)+1;
        }

        //3.使用一个死循环让用户进行猜测
        Scanner sc=new Scanner(System.in);
        OUT:
        while(true){
            System.out.println("请您输入一个1-20之间的数组进行猜测：");
            int guessData=sc.nextInt();

            //4.遍历数组中队的每个数据，看是否有数据与猜测的数据相同，相同代表猜中了
            for (int i = 0; i < data.length; i++) {
                if(data[i]==guessData){
                    System.out.println("您猜中了该数据，运气不错！");
                    System.out.println("您猜中的数据索引是：" + i);
                    break OUT;//结束了整个死循环，代表游戏结束了
                }
            }
            System.out.println("当前猜测的数据在数组中不存在，请重新猜测：");
        }
        
        //5.输出数组的全部元素，让用户看到自己确实是猜中了某个数据
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
    }
}

运行结果：

小结：

随机排名

代码：

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

public class Test4 {
    public static void main(String[] args) {
        //随机排名
        //1.动态初始化一个数组，存储5个工号
        int[] codes=new int[5];

        //2.定义一个循环，循环5次，依次录入一个工号存入5个对应的位置
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            //正式录入工号
            System.out.println("请输入第" + (i + 1) + "个员工的工号：");
            int code=sc.nextInt();
            //存入到数组中去
            codes[i]=code;
        }

        //3.遍历数组中的每个元素，然后随机一个索引，让该元素与随机索引位置处的元素值进行交换
        //codes=[12,36,28,45,99]
        Random r=new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值：codes[i]
            //随机一个索引位置出来 codes[index]
            int index=r.nextInt(codes.length);
            //点定义一个临时变量存储index位置处的值
            int temp=codes[index];
            codes[index]=codes[i];
            codes[i]=temp;
        }

        //4.遍历数组元素输出就是随机排名的结果
        System.out.println("随机排名结果是：");
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i] + "\t");
        }
    }
}

运行结果：

随机交换排名的其他使用场景：

小结：

数组排序

什么是数组排序

就是对数组中的元素，进行升序（由小到大）或者降序（由大到小）的操作。

数组排序的技术

冒泡排序
选择排序
快速排序
插入排序
希尔排序算法
……

冒泡排序

冒泡排序的思想：



实现冒泡排序的关键步骤分析：

代码：

public class Test5 {
    public static void main(String[] args) {
        //1.定义一个数组，存储一些数据
        int[] arr={5,2,3,1};
        ///        0 1 2 3

        //2.定义一个循环控制比较的论数
        for (int i = 0; i < arr.length-1; i++) {
            //i=0 比较3次 j=0 1 2
            //i=1 比较2次 j=0 1
            //i=2 比较1次 j=0

            //3.定义一个循环控制每轮比较的次数，占位
            for (int j = 0; j < arr.length-i-1; j++) {
                //判断当前位置的元素值 是否 大于后一个位置 若较大 则交换
                if(arr[j]>arr[j+1]){
                    int temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
                
            }
        }
        
        //遍历数组内容输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

运行结果：

小结：

数字搜索相关的技术

二分搜索
分块查找
哈希表查找
……

五、数组的内存图

java内存分配、数组内存图

java内存分配介绍：

public class ArrayDemo1 {
    public static void main(String[] args) {
        int a=12;
        System.out.println(a);

        int[] arr={11,22,33};
        System.out.println(arr);

        arr[0]=44;
        arr[1]=55;
        arr[2]=66;

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

两个变量指向同一个数组

public class ArrayDemo2 {
    public static void main(String[] args) {
        //理解两个数组变量指向同一个数组对象
        int[] arr1={11,22,33};

        //把数组arr1变量赋值给int类型的数组变量arr2
        int[] arr2=arr1;

        System.out.println(arr1);
        System.out.println(arr2);

        arr2[1]=99;
        System.out.println(arr1[1]);

        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

六、数组使用的常见问题

问题1：

public class Test1 {
    public static void main(String[] args) {
        int[] arr={11,22,33};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //System.out.println(arr[3]);//出现异常
    }
}

问题2：

 arr=null;
        System.out.println(arr);
        //System.out.println(arr[0]);//报错

七、Debug工具的使用

八、阶段总结：数组