Java基础知识

最新推荐文章于 2022-07-11 11:21:59 发布

三月太阳雨

最新推荐文章于 2022-07-11 11:21:59 发布

阅读量102

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_53051166/article/details/125627194

版权

Java基础知识-数组

java数组概述

数组是什么？

数组就是用来储存一批同种类型数据的内存区域（可以理解成容器）
在这里插入图片描述

数组的定义

静态初始化数组

数组的访问：
在这里插入图片描述

案例

package com.itheima.create;

public class ArrayDemo1 {
    //主方法
    public static void main(String[] args) {
        // 目标：学会使用静态初始化的方式定义数组
        // 数据类型[] 数字名称 = new 数据类型[] {元素1，元素2...}
        double[] scores = new double[]{9935,88.0, 75.5};

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

        String[] names = new String[]{"牛三", "李四"};

        System.out.println(scores);
        System.out.println(ages);
    }
}

package com.itheima.create;

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

        // 取值：数组名称[索引]
        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);

        int[] arr = {};
        
    }
}

数组的几个注意事项：
在这里插入图片描述
案例

package com.itheima.create;

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

        // 2.什么类型的数组只能存放什么类型的元素
        // String[] names = {"西门吹雪"， 11}; //会报错

        // 3.数组一旦定义出来之后，类型和长度就固定了
        int[] ages2 = {54,545,84};
        System.out.println(ages2[6]); // 报错！ 长度固定是3，索引不能超过数组长度
    }
}

动态初始化数组

动态初始化数组的元素默认值：
在这里插入图片描述
案例：

package com.itheima.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[98];
        names[0] = "迪丽热巴";
        names[3] = "杰克船长";
        names[2] = "杰克船长";

        System.out.println(names[1]);
        System.out.println(names[2]);

    }
}

在这里插入图片描述
案例：

package com.itheima.create;

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

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

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

        // 4.布尔值数组
        boolean[] booleans = new boolean[10];
        System.out.println(booleans[0]);

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


    }
}

数组的遍历

数组的遍历介绍

遍历：就是一个一个数据的访问
为什么要遍历？搜索，数据统计等等都需要用到遍历
如何遍历数组？

案例

package com.itheima.traverse;

public class ArrayDemo1 {
    //主方法
    public static void main(String[] args) {
        // 目标：学会进行数组元素的遍历
        int[] arr = {12, 24, 34, 55, 1};
        //原始遍历方式
//        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]);
        }
        
    }
}

在这里插入图片描述

package com.itheima.demo;

public class Test1 {
    //主方法
    public static void main(String[] args) {
        // 需求：数组元素求和
        // 1. 把这些数据拿到程序的数组中
        int[] money = {16, 32, 54, 84, 55};

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

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

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

在这里插入图片描述

package com.itheima.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);

    }
}

在这里插入图片描述

package com.itheima.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++) {
            //
            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("您已经猜中了该数据，运气不错，您猜中的数据索引是：" + i);
                    break OUT; // 结束了整个死循环，代表游戏结束了
                }
            }
            System.out.println("当前猜测的数据真数组中不存在，请重新猜测！");
        }
        // 5. 输出数组的全部元素，让用户看到字节确定是猜中了某个数据
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
    }
}

在这里插入图片描述

package com.itheima.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, 28, 45, 99}
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
             // 当前遍历的元素值：codes[i]
            // 随机一个索引位置出来：
            int index = r.nextInt(codes.length);

            // 定义一个临时变量储存index位置的值
            int teep = codes[index];
            codes[index] = codes[i];
            codes[i] = teep;
        }

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

在这里插入图片描述

package com.itheima.demo;

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

        // 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++) {
                // 判断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内存分配，数组内存图

在这里插入图片描述

在这里插入图片描述

案例

package com.itheima.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]);

    }
}

两个变量指向同一个数组

在这里插入图片描述
案例

package com.itheima.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(arr2[0]);

        
    }
}

数组使用的常见问题

在这里插入图片描述
案例

package com.itheima.attention;

public class Test {
    //主方法
    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]);  // 出现异常

        arr = null;
        System.out.println(arr);
        System.out.println(arr.length); // 出现异常


    }
}

Debug工具的使用

在这里插入图片描述

三月太阳雨

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识

数组就是用来储存一批同种类型数据的内存区域（可以理解成容器）数组的访问：案例数组的几个注意事项：案例动态初始化数组动态初始化数组的元素默认值：案例：案例：数组的遍历数组的遍历介绍遍历：就是一个一个数据的访问为什么要遍历？搜索，数据统计等等都需要用到遍历如何遍历数组？案例数组的内存图Java内存分配，数组内存图案例两个变量指向同一个数组案例数组使用的常见问题案例Debug工具的使用...
复制链接

扫一扫