数组的相关概念

一、数组概述和静态初始化

数组：作用类似于变量，可以存储同种数据类型的多个值。


初始化:就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
数组的初始化有两种方式：静态初始化和动态初始化。

静态初始化：

二、数组的地址值和元素访问

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

数组元素的访问：
格式： 数组名[索引]

另外：可以使用具体的数据存储到数组中，但这样做，以前的数据就会被覆盖。

三、数组的遍历

数组遍历:将数组中所有的内容取出来取出来之后可以(打印，求和，判断…）

.length方法

调用方式：数组名.length
可用for循环进行遍历，循环停止条件为：i < 数组名.length
扩展：
IDEA中可用数组名.fori快速生成遍历数组元素的for循环。

3.1 数组遍历的练习

Test1:

public class ArrayDemo1 {
    public static void main(String[] args) {
        // 定义一个数组，存储1-5，遍历每个元素并求和
        int[] array1  = {1,2,3,4,5};
        int sum = 0;

        for (int i = 0; i < array1.length; i++) {
            sum += array1[i];  
            //i表示数组的索引；array1[i]则表示每个元素
        }
        System.out.println(sum);
    }
}

Test2:

public class ArrayTest1 {
    /*
    定义一个数组，存储1,2,3,4,5,6,7,8,9,10
    遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
     */
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
        int count = 0;

        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] % 3 == 0){
                count++;
            }
        }
        System.out.println("数组arr1中能被3整除的数共有" + count + "个");
    }
}

Test3:

public class ArrayTest2 {
    /*
    定义一个数组，存储1,2,3,4,5,6,7,8,9,10遍历数组得到每一个元素。要求:
    如果是奇数，则将当前数字扩大两倍
    如果是偶数，则将当前数字变成二分之一
     */
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5,6,7,8,9,10};

        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] % 2 ==1){
                arr2[i] *= 2;
            }else if (arr2[i] % 2 ==0){
                arr2[i] /=2;
            }
            System.out.println(arr2[i]); 
            //不推荐这样写，打印可以另写一个循环，一个循环做一件事就好
        }
    }
}

四、数组的动态初始化和常见问题

4.1 数组的动态初始化

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

格式：
数据类型[] 数组名= new 数据类型[数组长度];

public class ArrayDemo2 {
    /*
    定义一个数组，用来存班级中50个学生的姓名
    姓名未知，等学生报道之后，再进行添加。
     */
    public static void main(String[] args) {
        String [] name = new String[50];

        //添加
        name[0] = "zhangsan";
        name[1] = "lisi";

        System.out.println(name[0]);
        System.out.println(name[1]);
        System.out.println(name[2]);//尚未添加，打印结果是初始化的值
    }
}

扩展：

数组默认的初始化规律：

• 整数类型:默认初始化值0
• 小数类型:默认初始化值0.0
• 字符类型:默认初始化值 /u0000，打印出来是空格
• 布尔类型:默认初始化值 false
• 引用数据类型:默认初始化值 null（引用数据类型：除了四类八种以外的所有）

4.2 静态初始化和动态初始化的区别

4.3 常见问题——索引越界

出现原因：访问了不存在的索引；
避免方式：知道数组索引范围，即，从0开始，到数组长度-1结束。

4.4 对数组的常见操作

1.求最值

public class Test3 {
    /*
    已知数组元素为{33,5,22,44,55}
    请找出数组中最大值并打印在控制台
     */
    public static void main(String[] args) {
        int [] arr= {33,5,22,44,55};
        int max = arr[0];

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println(max);
    }
}

2.求和并统计个数

public class Test4 {
    /*
    生成10个1~100之间的随机数存入数组
    1)求出所有数据的和
    2)所有数据的平均数
    3)统计有多少个数据比平均值小
     */
    public static void main(String[] args) {
        int [] num = new int[10];
        int sum = 0;

        // 生成10个随机数存入数组
        for (int i = 0; i < 10; i++) {
            Random r = new Random();
            int number = r.nextInt(100)+1;
            num[i] = number;
        }
        // 求和
        for (int i = 0; i < 10; i++) {
            sum += num[i];
        }

        int average = sum / 10;
        int count = 0;

        //求几个小于平均
        for (int i = 0; i < 10; i++) {
            if (num[i] < average){
                count++;
            }
        }

        System.out.println("总和为：" + sum);
        System.out.println("平均为：" + average);
        System.out.println("小于平均数的共有：" + count + "个");
    }
}

3.交换数据*

public class Test5 {
    /*需求:定义一个数组，存入1,2,3,4,5.按照要求交换索引对应的元素
    交换前:1,2,3,4,5    交换后:5,2,3,4,1*/
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};

        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] =temp;
        }
    }
}

4.打乱数据

import java.util.Random;

public class Test6 {
    //需求:定义一个数组，存入1~5。要求打乱数组中所有数据的顺序
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        for (int i = 0; i < arr.length; i++) {
            Random r = new Random();
            int num = r.nextInt(5);

            int temp = arr[i];
            arr[i] = arr[num];
            arr[num] = temp;
        }
    }
}

五、数组的内存图

当定义一个数组时：

总结：

• 只要是new出来的一定是在堆里面开辟了一个小空间
• 如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据

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

总结：
当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。