JavaSE（四）数组

最新推荐文章于 2024-10-01 18:51:18 发布

菜得無限大

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量36

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/caiya1/article/details/133200537

版权

JavaSE 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

Java数组

数组其实是个大容器里面放很多数据
数组其实也是一种数据类型；数组是一种引用类型
数组内部的数据也称之为数组元素
数组中数组元素类型必须一致，和声明的类型保持一致；中括号前面是什么类型数组元素就是什么类型；
特点：数组是定长的，长度一旦确定（是在初始化的时候被确定的）不可更改；

数组的使用

1，数组的声明

  /**
     * 数组的声明 中括号可放前也可放后
     */
    private static void method1() {
        //数组的声明 任意类型[] 变量名;
        int arr1[];//等价于 int[] arr1;
        String[] arr2;
        double[] arr3;
        char[] arr4;
    }

2，数组的初始化

 /**
     * 数组的3种初始化方式
     */
    private static void method2() {
        //arr1变量名，数组名
        //1  第1种初始化（赋值）；指定数组的长度（容量大小）
        int[] arr1 = new int[5];
        //2 第2种初始化  直接指定每个数组元素的值
        int[] arr2 = {12, 56, 89, 99};
        //3 第3种初始化
        int[] arr3 = new int[]{12, 55, 77, 88};
    }

注意

使用new关键字初始化 JVM给每个数组元素赋零值

 /**
     * 使用new关键字初始化 JVM给每个数组元素赋零值
     */
    private static void method4() {
        //当使用第一种初始化方式赋值 JVM会给数组元素赋初始默认值；其数据类型的零值 int 0 double 0.0 boolean false char ''
        //引用类型的零值都是 null
        int[] arr1 = new int[5];
        // Arrays.toString方法功能是 把数组内部的数组元素拼接为一个字符串返回
        System.out.println(Arrays.toString(arr1));
        double[] arr2 = new double[3];
        System.out.println(Arrays.toString(arr2));
        boolean[] arr3 = new boolean[4];
        System.out.println(Arrays.toString(arr3));
        String[] arr4 = new String[5];
        System.out.println(Arrays.toString(arr4));
    }

    private static void method3() {
        double[] arr1 = new double[2];
        double[] arr2 = {3.5, 6.7, 12};
        double[] arr3 = new double[]{1.2, 3.3};
        String[] arr4 = new String[7];
        String[] arr5 = {"java", "python", "12"};
        String[] arr6 = new String[]{"java", "python", "12"};
    }

3，数组元素的取值和赋值

/**
     * 数组元素的取值和赋值
     */
    public static void method5() {
        int[] arr1 = new int[5];
        //1, arr1.length获取数组的长度（大小）
        int length = arr1.length;
        System.out.println("length: " + length);
        // 2,获取某个数组元素的值  数组名[索引值]   索引的有效取值范围 [0,length-1]
        //凡是写索引的地方 只要索引值超出有效取值范围 都报异常 ArrayIndexOutOfBoundsException: 数组索引越界
        int num = arr1[0];
        System.out.println(num);
        //3,给数组元素设值（赋值）
        arr1[0] = 99;
        arr1[1] = 79;
        arr1[4] = 69;
        System.out.println(Arrays.toString(arr1));
    }

4，回顾

注意问题：对于第二种初始化方式不能先声明再赋值的

/**
     * 回顾
     */
    private static void method6() {
        //arr数组名 变量名
        int[] arr; //(常见)
        int arr2[];
        //使用new初始化 数组元素有初始值 JVM给其数据类型的零值 引用类型的零值null
        arr = new int[6];
        System.out.println(Arrays.toString(arr));
        //数组长度可以为0
        arr2 = new int[]{12, 11};
        System.out.println(Arrays.toString(arr2));
        // 第二种的初始化方式
        int[] arr4 = {12, 33, 66};
        //注意问题： 对于第二种初始化方式 不能先声明再赋值的
        /*int[] arr5;
        arr5 = {12, 11};*/

        String[] arr3 = new String[3];
        System.out.println(Arrays.toString(arr3));
    }

5，练习

/**
     * 练习
     */
    private static void method8() {
        //班级动态录入 每个学生的成绩存储到数组中 求平均值
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入班级人数 ");
        int stuNum = sc.nextInt();
        double sum = 0;
        int[] scoreArr = new int[stuNum];
        //数组的初始化
        for (int i = 0; i < stuNum; i++) {
            System.out.println("请录入" + (i + 1) + "个学生的成绩");
            int score = sc.nextInt();
            //给数组元素赋值
            scoreArr[i] = score;
            sum = sum + score;// sum += score;
        }
        System.out.println(Arrays.toString(scoreArr));
        System.out.println("sum: " + sum);
        System.out.println("avg: " + (sum / stuNum));
    }

6，注意问题：数组是定长的

 /**
     * 注意点：数组是定长的 长度一旦确定不可更改
     */
    public static void method9() {
        int[] arr = new int[3];
        arr[6] = 10;
        /*//
        System.out.println(arr.length);
        arr[0] = 100;
        arr[1] = 90;*/
    }

7，数组的遍历

/**
     * 数组的遍历
     */
    public static void method10() {
        int[] arr = {12, 55, 77, 100, 120};
        //1 普通for循环遍历  i取值: [0,length-1] index
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("===============");
        //2, 增强for循环遍历 a：依次接收每一个数组元素
        for (int a : arr) {
            System.out.println(a);
        }
        String[] arr2 = {"java1", "java2", "java3"};
        for (String str : arr2) {
            System.out.println(str);
        }
    }

8，数组元素的复制

   /**
     * 数组元素的复制
     */
    public static void method11() {
        int[] arr1 = {12, 55, 77, 100, 120};
        // 数组元素的复制
        int[] arr2 = new int[arr1.length];
        //
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        System.out.println(Arrays.toString(arr2));
    }

9，求最值

/**
     * 1，求最值 :最大值 最小值
     * 2，求最值所在的索引值：
     */
    public static void method12() {
        int[] arr1 = {12, 55, 77, 100, 120, 1, 130, 111, 222, 10, 2, 3};
        //1 假设第一个数组元素就是最值
        int max = arr1[0];
        int min = arr1[0];
        for (int i = 1; i < arr1.length; i++) {
            max = max > arr1[i] ? max : arr1[i];
            min = min < arr1[i] ? min : arr1[i];
        }
        System.out.println("max: " + max);
        System.out.println("min: " + min);
    }

 /**
     * * 2，求最值所在的索引值：
     */
    public static void method13() {
        int[] arr1 = {12, 55, 77, 100, 120, 1, 130, 111, 222, 10, 2, 3};
        // 假设第一个数组元素的索引值 就是最值所在的索引值
        int maxIndex = 0;
        int minIndex = 0;
        for (int i = 1; i < arr1.length; i++) {
            maxIndex = arr1[maxIndex] > arr1[i] ? maxIndex : i;
            minIndex = arr1[minIndex] < arr1[i] ? minIndex : i;
        }
        System.out.println("maxIndex: " + maxIndex);
        System.out.println("max: " + arr1[maxIndex]);
        System.out.println("minIndex: " + minIndex);
        System.out.println("min: " + arr1[minIndex]);
    }

10，练习

/**
     * 有一个数列：8，4，2，1，23，344，12
     *  1）循环输出数列的值
     *  2）求数列中所有数值的和
     *  3）猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数
     */
    private static void method14() {
        int[] arr = {8, 4, 2, 1, 23, 344, 12};
        Scanner sc = new Scanner(System.in);
        String str;
        do {
            System.out.println("请输入");
            int num = sc.nextInt();
            //标志位
            boolean flag = false;
            for (int i = 0; i < arr.length; i++) {
                if (num == arr[i]) {
                    flag = true;
                    break;
                }
            }
            if (flag) {
                System.out.println("此数存在与数列中 " + num);
            } else {
                System.out.println("此数不存在与数列中 " + num);
            }
            System.out.println("是否继续 Y/N");
            str = sc.next();
        } while ("y".equals(str));
        System.out.println("游戏结束");

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

工具类

/**
     * Arrays工具类提供的方法
     */
    private static void method1() {
        int[] arr = {12, 55, 77, 100, 120, 1, 130, 111, 222, 10, 2, 3};
        int[] arr4 = {12, 55, 77, 100, 120, 1, 130, 111, 222, 10};
        int num = 10;
        //Arrays 工具类 给数组提供工具方法的一个类
        //1, Arrays.toString 方法的功能就是把数组内部的数组元素拼接为一个字符串  "[2899, 2950, 2850, 3100]"
        String str = Arrays.toString(arr);
        System.out.println(str);
        System.out.println(Arrays.toString(arr));
        double[] arr2 = {2.5, 1.6, 18};
        // a->97 j: J:
        String[] arr3 = {"java1", "Java2", "w", "a", "e"};
        System.out.println(Arrays.toString(arr2));
        //2, Arrays.sort 对数组元素进行排序
       /* Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(arr[0]);*/
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
        //3,  Arrays.equals 方法的功能用于比较两个数组的数组元素是否一一相等
        boolean b = Arrays.equals(arr, arr4);
        System.out.println(b);
        // 4,Arrays.copyOf(源头数组,新数组的长度) 数组的拷贝；
        int[] arr5 = Arrays.copyOf(arr, 16);
        System.out.println(Arrays.toString(arr5));
    }

二维数组

1，二维数组的声明

 /**
     * 二维数组的声明
     */
    private static void method3() {
        int[] arr1;
        //二维数组的数组元素 是一维数组；二维数组也是引用类型
        int[][] arr2;
        int arr3[][];
    }

    private static void method2() {
        //一维数组
        int[] arr;
        //二维数组
        int[][] arr2;
        //三维数组
        int[][][] arr3;
    }

2，二维数组的初始化

/**
     * 二维数组的初始化
     */
    private static void method4() {
        // 这个二维数组的长度是3；  JVM给数组元素 零值null
        //1，初始化方式 指定了数组的长度； JVM给数组元素 零值null
        int[][] arr1 = new int[3][];
        System.out.println(Arrays.toString(arr1));
        //2，初始化方式；  3:表示这个二维数组长度为3  2：表示每一个数组元素（每一个一维数组的长度都是2，每个一维数组都是JVM初始化的）
        int[][] arr2 = new int[3][2];
        System.out.println(Arrays.toString(arr2));
        // 3, 初始化方式
        int[][] arr3 = {{12, 55, 77}, {12, 11}, {1, 2, 3, 4}};
    }

3，使用

 /**
     * 数组元素的取值和赋值
     */
    private static void method6() {
        //每个一维数组都是JVM初始化的，  new int[2];
        int[][] arr1 = new int[3][2];
        //给二维数组中的一维数组的数组元素赋值
        arr1[0][0] = 12;
        //取值
        int num = arr1[0][0];
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr1[0]));
        System.out.println(Arrays.toString(arr1[1]));
        System.out.println(Arrays.toString(arr1[2]));
    }

    /**
     * 数组元素的取值和赋值
     */
    private static void method5() {
        int[][] arr1 = new int[3][];
        //arr1.length 得到数组的长度
        System.out.println(arr1.length);
        // 给二维数组的数组元素赋值，数组元素都是一维数组类型的
        arr1[0] = new int[5];
        arr1[1] = new int[]{12, 33, 55, 77};
        arr1[2] = new int[3];
        //给二维数组中的一维数组的数组元素赋值
        arr1[0][1] = 90;
        arr1[2][0] = 70;
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr1[0]));
        System.out.println(Arrays.toString(arr1[1]));
        System.out.println(Arrays.toString(arr1[2]));
    }

4，练习

/**
     * 动态录入班级数，以及每个班级学生的人数，以及每个学生的成绩
     * 遍历输出每个班级每个学生的成绩
     */
    private static void method7() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入班级个数：");
        int classNum = sc.nextInt();
        //给二维数组初始化
        int[][] scoreArr = new int[classNum][];
        for (int i = 0; i < classNum; i++) {
            System.out.println("请录入第" + (i + 1) + "个班的学生人数：");
            int stuNum = sc.nextInt();
            //给一维数组初始化
            scoreArr[i] = new int[stuNum];
            // 给每个学生赋成绩值
            for (int j = 0; j < stuNum; j++) {
                System.out.println("请录入第" + (i + 1) + "个班级 第" + (j + 1) + "个学生的成绩");
                int score = sc.nextInt();
                //给一维数组的数组元素赋值
                scoreArr[i][j] = score;
            }
        }
        //每个班每个学生成绩
        for (int i = 0; i < scoreArr.length; i++) {
            System.out.println(Arrays.toString(scoreArr[i]));
        }
    }

方法

方法：其实就是一段代码片段，为了完成某个功能的代码片段而已
定义一个方法就是定义好一个功能
方法是为了减少代码重复冗余，目的：代码的重复使用

1，方法的定义

  /**
     * 为了完成某个功能的代码片段
     * 求数组的最大值
     * <p>
     * public 权限修饰符的位置 4个权限修饰符
     * static：修饰符号不是必须的；只是因为要在main中调用这个方法所以才加static
     * 返回值位置：反馈
     * ***void:此方法执行完毕后 没有返回值;
     * ***任意数据类型：此方法执行完毕后会返回一个对应类型的值给调用者；方法体内部必须出现   return 值;
     * ****一旦执行了return 表示方法执行完毕；return后面不能有代码
     * maxArr：方法名 标识符 方法命名和变量一样 首字母小写
     * (int[] arr)：形参（形式参数）列表,个数可以是0或多个
     * *****(形参类型 形参名,形参类型 形参名,形参类型 形参名... )
     * {方法体}
     *
     * @param arr
     */
    public static int maxArr(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            max = max > arr[i] ? max : arr[i];
        }
        return max;
    }

   public static int sum(int a, int b) {
        int sum = a + b;
        return sum;
    }

2，方法的调用

/**
     * 方法的调用
     */
    private static void method3() {
        int[] arr1 = {12, 55, 77, 100, 120, 1, 130, 111, 222, 10, 2, 3};
        //调用方法 语法：方法名(实参); 接收返回值； 传递是 实参
        int max = maxArr(arr1);
        System.out.println("max： " + max);
        int[] arr2 = {12, 55, 88, 100, 120, 10, 2, 3};
        int max2 = maxArr(arr2);
    }