Day04_数组

Day04_数组

数组就是用来存储 一批同类型数据的内存区域。

如果不使用数组：

• 如果同一类型数据的数据过多，就需要大量变量的定义
• 业务功能实现麻烦
• 注意：在java中只有同一类型数据才能存于一个数组中。

今天的任务：

• 如何定义数组存储数据
  • 定义数组的格式
• 如何操作中数组元素
  • 如何获取与修改数组数据
• 怎么解决实际问题
  • 如何完成一些业务功能
• 数组内存原理
  • 数组如何在内存中工作
• 数组使用的注意点
  • 避免入坑，同时可以在出现问题后立即排查问题所在

1、数组的定义

1.1、静态初始化数组

​ 在定义数组的过程中直接给数组赋值。

//完整格式 
//数据类型[] 数组名= new 数据类型[]{元素1，元素2......};
double[] scores = new double[]{1,2,3,4,5};
int[] ages = new int[]{3,4,5,6};
//简化格式
//数据类型[] 数组名 = {元素1，元素2.....};
String[] names = {"name1","name2"};
System.out.println(ages);

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

基本原理

//数组的访问方法
//数组名称[索引]

数组的注意事项

• 数据类型[] 数组名 也可以写成数组类型 数组名[]int ages2[] = {3,4,5,6};
• 什么类型的数组存放什么类型的数据，否则会报错
• 数组一旦定义，程序执行中长度类型就固定了

1.2、动态初始化数组

​ 定义数组的时候 只确定数组的长度，二部存入具体数值

int []array = new int[3];
System.out.println(array[0]);  //输出结果为0
array[0] = 10;
System.out.println(array[0]); //输出结果为10

元素默认规则

• 基本类型：
  • byte、short、char、int、long:0
  • float、double:0.0
  • boolean:false
• 引用类型：
  • 接口、类、数组、String：null

2、数组的遍历

​ 所谓的数组遍历就是要不重复不遗漏的将数组内的内容进行访问。

int ages[] = {1,2,5,3,2};
        for (int i = 0; i < ages.length; i++) {
            System.out.println(ages[i]);
        }

3、数组的案例

 //遍历求和，：某部门5名员工的销售额分别是：16、26、36、6、100，请计算出他们部门的总销售额
        int[] sell = {16,26,36,6,100};
        int sum = 0;
        for (int i = 0; i < sell.length; i++) {
            sum+=sell[i];
        }
        System.out.println(sum);

        //数组最大值求和
        int []faceScores = {15, 9000, 10000, 20000, 9500, -5};
        int max = faceScores[0];
        for (int i = 0; i < faceScores.length; i++) {
            if (max < faceScores[i]){
                max = faceScores[i];
            }
        }
        System.out.println(max);

        //猜数字游戏
        /*
        游戏后台随机生成1-20之间的5个数（无所谓是否重复），然后让大家来猜数字：
                未猜中提示：“未命中”，并继续猜测
                猜中提示：“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据， 最 终结束本游戏
         */
        Random random = new Random();
        int []number = new int [5];
        Scanner sc = new Scanner(System.in);
        int scan;
        boolean flag = false;

        //随机值的赋值
        System.out.print("随机数为：");
        for (int i = 0; i < number.length; i++) {
            number[i] = random.nextInt(20)+1;
            System.out.print(number[i]+" ");
        }
        System.out.println();

        //循环判断是否猜中
        while (true){
            scan = sc.nextInt();
            for (int i = 0; i < number.length; i++) {
                //判断是否猜中
                if (scan == number[i]){
                    System.out.println("地址为"+i);
                    flag = true;
//                    循环输出结果
                    System.out.print("随机数值为:");
                    for (int j = 0; j < number.length; j++) {
                        System.out.print(number[j]+" ");
                    }
                    System.out.println();
                    break;
                }
            }
//            判断是否已经猜中
            if(flag){
                break;
            }else{
                System.out.println("没有猜对哦！！！");
            }
        }

        //随机排名
        /*实现步骤
        * 定义一个动态数组
        * 遍历数组中每个元素，每次随机一个索引值，让当前元素与索引位置处的元素进行交换
        * 遍历输出结果
        * */
        int []employee = {22,35,33,13,88};
        Random rm = new Random();
        int temp,rmIndex;
        for (int i = 0; i < employee.length; i++) {
            rmIndex = rm.nextInt(5);
            temp = employee[rmIndex];
            employee[rmIndex] = employee[i];
            employee[i] = temp;
        }
        for (int i = 0; i < employee.length; i++) {
            System.out.print(employee[i]+" ");
        }
        System.out.println();

        //冒泡排序
        int []employee_sort = {22,35,33,13,88};
        int temp1;
        for (int i = 0; i < employee_sort.length ; i++) {
            for (int j = 0; j < employee_sort.length-i-1; j++) {
                if (employee_sort[j] > employee_sort[j+1]){
                    temp1 = employee_sort[j];
                    employee_sort[j] = employee_sort[j+1];;
                    employee_sort[j+1] = temp1;
                }
            }
        }

        for (int i = 0; i < employee_sort.length; i++) {
            System.out.print(employee_sort[i] +" ");
        }

4、数组的内存图

4.1、Java内存分配、数组内存图

• 堆：new出来的东西会在这块内存中开辟空间并产生地址
• 栈：方法运行时所进入的内存，变量也是在这里
• 方法区：字节码文件加载时进入的内存

代码流程讲解

当两个数组变量指向同一个数组对象时

数组指向的为一个对象地址，并不指向具体的数值，当两个数组指向同一个对象时，其中一个改变数组内容，另一个的内容也会发生改变。

• 这就是数组赋值中的浅复制，如果想要改变其特性就要在复制过程中进行深复制（创建一个新的数组对象并复制）
• eg array2 = array1.clone()

 int[] array1 = {1,2,3,4};
        System.out.print("array1内容:");
        for (int i = 0; i < array1.length; i++) {
            System.out.printf(array1[i]+" ");
        }
        System.out.println();
        int[] array2 = array1;
		// int[] array2 = array1.clone();
        array2[1] = 22;

        System.out.print("array1内容:");
        for (int i = 0; i < array1.length; i++) {
            System.out.printf(array1[i]+" ");
        }
        System.out.println();

        System.out.print("array2内容:");
        for (int i = 0; i < array2.length; i++) {
            System.out.printf(array2[i]+" ");
        }
        System.out.println();

		//浅复制输出的结果为
//array1内容:1 2 3 4 
//array1内容:1 22 3 4 
//array2内容:1 22 3 4 

		//深复制的结果
//array1内容:1 2 3 4 
//array1内容:1 2 3 4 
//array2内容:1 22 3 4 

浅复制原理

5、数组使用的常见问题

• 问题1：方位元素位置超过最大索引 ，报错为：ArrayIndexOutOfBoundsException(数组索引越界异常)
  :1 22 3 4
  //array2内容:1 22 3 4

    //深复制的结果
  

//array1内容:1 2 3 4
//array1内容:1 2 3 4
//array2内容:1 22 3 4

**浅复制原理**

[外链图片转存中...(img-664svFhY-1645156575393)]

## 5、数组使用的常见问题

- 问题1：方位元素位置超过最大索引 ，报错为：ArrayIndexOutOfBoundsException(数组索引越界异常) 
- 问题2 ：数组变量中未存储数组地址，为null，访问数组内容，报错为NullPointerException(空指针异常)