数组、数组的静态初始化、数组的遍历、数据的动态初始化、静态初始化和动态初始化的使用场景、索引越界异常、 数组的最值、交换数据、打乱数组

数组

概念：

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

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

数组格式一：

​ 数据类型 [] 数组名

比如：int [] array

数组格式二：

​ 数据类型 数组名 []

比如： int array []

数组的静态初始化

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4…};

比如：

​ int[] arr = new int[]{11,22,33};

​ double[] arr = new double[]{1.1,1.2,1.3};

简写

int[] arr = {11,22,33};

​ double[] arr = {1.1,1.2,1.3};

地址值

int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736

以[I@6d03e736为例：

[ ：表示现在打印的是一个数组。

I：表示现在打印的数组是int类型的。

@：仅仅是一个间隔符号而已。

6d03e736：就是数组在内存中真正的地址值。（十六进制的）

但是，我们习惯性会把[I@6d03e736这个整体称之为数组的地址值。

数组元素访问

通过索引

数组名[索引];

   public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        //需求1：获取arr数组中，3索引上的值
        int number = arr[3];
        System.out.println(number);
        System.out.println(arr[3]);

        //需求2：将arr数组中，3索引上的值修改为10
        arr[3] = 10;
        System.out.println("修改之后为:" + arr[3]);

    }
}

数组的遍历

数组的长度：数组名.length;

最大索引：数组长度-1

快捷键：arr.fori

for(int i = 0; i < arr.length; i++){
    //在循环的过程中，i依次表示数组中的每一个索引
    //arr[i]表示数组里面的每一个元素
    sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}

数据的动态初始化

添加的数据一开始不知道

格式：

​ 数据类型[] 数组名 = new 数据类型[数组的长度];

//1.定义一个数组，存3个人的年龄，年龄未知
int[] agesArr = new int[3];
agesArr[0]=13;
agesArr[1]=14;
agesArr[2]=15;

//2.定义一个数组，存班级10名学生的考试成绩，考试成绩暂时未知，考完才知道。
int[] scoresArr = new int[10];

静态初始化和动态初始化的使用场景

只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。

已经明确了要操作的所有数据，推荐使用静态初始化。

常见问题：索引越界异常ArrayIndexOutOfBoundsException

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,5,5,5,5};
    //用索引来访问数组中的元素
    System.out.println(arr[1]);
    System.out.println(arr[10]);//ArrayIndexOutOfBoundsException

}

数组的最值

//定义数组求最大值：33,5,22,44,55
       //1.定义数组用来存储5个值
        int[] arr = {33,5,22,44,55};
        //2.定义一个变量max用来存储最大值，数组里面的值
        //临时认为0索引的数据是最大的
        int max = arr[0];
        //3.循环获取数组中的每一个元素
        //拿着每一个元素跟max进行比较
       for (int i = 1; i < arr.length; i++) {
            //i 索引  arr[i] 元素
            if(arr[i] > max){
                max = arr[i];
            }
        }
    //4.当循环结束之后，max记录的就是数组中的最大值
    System.out.println(max);//55

    //分析：
    //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;
        //把生成的随机数添加的数组当中
        //数组名[索引] = 数据;
        arr[i] = number;
    }
    // 1）求出所有数据的和
    //定义求和变量
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        //循环得到每一个元素
        //并把元素累加到sum当中
        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] + " ");
    }

交换数据

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

打乱数组

    //1.定义数组存储1~5
    int[] arr = {1, 2, 3, 4, 5};
    //2.循环遍历数组，从0索引开始打乱数据的顺序
    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] + " ");
    }