java入门基础教程：2023.3.2第四天，java的数组对象使用

前言

记录时间：2023.3.2

已坚持的第四天

java从入门到精通

学习java时间历程记录打卡

早上6：00到 12：00

下午1：00到6：00

java数组总结

完成代码练习

1.数组的定义

1.用静态初始化的的方式定义数组

package cn.vqqc.create;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //学会使用静态初始化的的方式定义数组
        //数据类型[] 数组名称 = new 数据类型[]{元素1，元素2}
       // double[] scores =  new double[]{99.1, 51, 68.54};
        //简化数组
        double[] score = {99.1, 51, 68.54};

       // int[] ages = new int[]{15, 16, 17, 18};
        //简化数组
        int[] age = {15, 16, 17, 18};

       // String[] names = new String[]{"小明", "小张", "小王"};
        //简化数组
        String[] name = {"小明", "小张", "小王"};

        System.out.println(score);
    }
}

2.访问数组的元素

package cn.vqqc.create;

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);
    }
}

3.理解数组的注意事项

package cn.vqqc.create;

public class ArrayAttentionDemo3 {
    public static void main(String[] args) {
        //理解数组的注意事项
        //.1.数据类型[] 数组名称  也可以写成 数组类型 数组名称[]
        int[] ages = {11, 23, 45};
        //int ages1[] = {11, 23, 45};

        //2.什么类型的数组只能存放什么类型的元素
        //String[] names = {"小明", "小红", 23}; // 错误的

        //3.数组一旦定义出来之后，类型和长度固定了
        int[] ages2 = {11, 23, 45};
        //System.out.println(ages2[3]); //错误 长度固定值是3 不能访问第四个元素
    }
}

4.动态初始化数组的定义和使用

package cn.vqqc.create;

public class ArrayDemo4 {
    public static void main(String[] args) {
        //学会动态初始化数组的定义和使用
        double[] scores = new double[3]; // [0.0, 0.0, 0.0]
        //                                     0    1   2
        //赋值
        scores[0] = 99.5;
        System.out.println(scores[0]);

        System.out.println(scores[2]);
        String[] names = new String[90];
        names[0] = "小明";
        names[1] = "小红";
        System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);


    }
}

5.掌握动态初始化元素默认值的规则

package cn.vqqc.create;

public class ArrayDemo5 {
    public static void main(String[] args) {
        //掌握动态初始化元素默认值的规则
        //1.整型数组的元素默认值都是0
        int[] arr = new int[10];
        System.out.println(arr[0]);
        System.out.println(arr[9]);

        //2.字符数组的元素默认值是多少呢？ 0
        char[] chars = new char[100];
        System.out.println((int) chars[0]);
        System.out.println((int) chars[99]);

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

        //4.布尔型数组元素默认值是false
        boolean[] booleans = new boolean[100];
        System.out.println(booleans[0]);
        System.out.println(booleans[99]);

        //5.引用型数组元素默认值是null
        String[] names = new String[90];
        System.out.println(names[0]);
        System.out.println(names[89]);

        //int[] arr = new int[3]{1, 2, 3};
    }
}

2.数组的遍历

1.数组元素的遍历

package cn.vqqc.traverse;

public class ArrayDemo {
    public static void main(String[] args) {
        //学会进行数组元素的遍历
        int[] arr = {12, 24, 12, 48, 98};
        //          0   1   2   3   4

        //原始的遍历方式
//        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]);

//        for (int i = 0; i < 5; i++) {
//            System.out.println(arr[i]);
//        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

3.案例练习

1.数组元素求和案例

package cn.vqqc.demo;

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

        //3.定义一个求和的变量
        int sum = 0;
        //2.遍历数组中的每个元素
        for (int i = 0; i < money.length; i++) {
            //拿到元素值累加
            sum += money[i];
        }

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

2.数组元素求最值的案例

package cn.vqqc.demo;

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);
    }
}

3.随机数让用户去猜的案例

package cn.vqqc.demo;

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++) {
            //i = 0 1 2 3 4
            data[i] = r.nextInt(1,20);
        }

        //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("恭喜你猜中了！您猜中的数据索引是：" + i);
                    break OUT; //结束了整个死循环，代表游戏结束了！
                }
            }
            System.out.println("当前猜测的数据在数组中不存在，请重新猜测！");
        }

        //5.输出数组的全部元素，让用户看到自己确实是猜中了某个数据
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }

    }
}

4.录入工号随机排名的案例

package cn.vqqc.demo;

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次，依次录入一个工号存入对应的位置
        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 , 20 , 45 ,99]
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值：codes[i]
            //随机一个索引位置出来:codes[index]
            int index = r.nextInt(codes.length);
            if(index == i) {
                //定义一个临时变量存储index的位置处的值
                int temp = codes[index];
                codes[index] = codes[i];
                codes[i] = temp;
            }
        }

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

5.冒泡排序的算法

package cn.vqqc.demo;

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

        //2.定义一个一个循环控制比较的轮数
        for (int i = 1; i <= arr.length - 1; i++) {
            //i == 1 比较次数3  j = 0 1 2
            //i == 2 比较次数2  j = 0 1
            //i == 3 比较次数1  j = 0
            //3.定义控制一个循环每轮的比较次数，占位
            for (int j = 0; j < arr.length - i ; j++) {
                //判断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");
        }
    }
}

4.数组使用的常见问题

package cn.vqqc.attention;

public class Text {
    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.length);

        System.out.println("程序结束");
    }
}

5.数组的内存使用

1.内存分配

package cn.vqqc.memory;

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]);
    }
}

2.理解两个2数组变量指向同一个数组对象

package cn.vqqc.memory;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //理解两个2数组变量指向同一个数组对象
        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(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
    }
}