Day05Java基础-数组和二维数组及其遍历

1.数组介绍和静态初始化

数组: 指的是一种容器, 可以用来存储同种数据类型的多个值.

使用思路: 今后若要操作的多数据,属于同一组数据就可以考虑使用数组容器进行维护.

数组静态初始化

初始化: 就是在内存中, 为数组容器开辟空间, 并将数组存入容器中的过程

数组定义格式

package itheima.array;

public class ArrayDemo1 {
    public static void main(String[] args) {
        arrayTest2();
    }

    /*
        数组介绍 : 一种容器, 可以存储同种数据类型的多个值

        数组的使用场景 : 发现手里的数据有多个, 并且中这多个数据还属于同一组数据, 就可以考虑使用数组容器进行维护.

        初始化 : 在内存中, 为数组容器开辟空间, 并将数据存入容器的过程.

        数组的定义格式:

                1. 数据类型[] 数组名;

                2. 数据类型 数组名;

                注意 : 这种定义格式, 定义出来的, 只是数组类型的变量而已, 内存中还没有创建出数组容器
     */
    public static void arrayTest1() {
        int[] array;

        int array2[];

//        System.out.println(array);
//        System.out.println(array2);

        int a;
//        System.out.println(a);
    }

    /*
        数组的静态初始化格式:

                1. 完整格式 :
                                数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...}

                2. 简化格式 :
                                数据类型[] 数组名 = {元素1, 元素2, 元素3...}
            打印数组名 :

                    [I@776ec8df
                    [D@4eec7777
            解析:
                @ : 分隔符
                [ : 当前空间, 是数组类型的
                I : 当前数组类型, 是int类型
                776ec8df : 数组的十六进制内存地址
        */
    public static void arrayTest2() {
        int[] arr1 = {11, 22, 33};
        double[] arr2 = {11.1, 22.2, 33.3};

        System.out.println(arr1);
        System.out.println(arr2);
    }
}

2.数组元素访问

package itheima.array;

public class ArrayDemo2 {
    public static void main(String[] args) {
        arrayTest();
    }

    /*
        数组元素访问格式:

                数组名[索引];

                索引: 数组容器中空间所对应的编号, 编号从0开始, 逐个+1增长
     */
    public static void arrayTest() {
        int[] arr = {11, 22, 33, 44, 55};

        // 取出数组中 22 元素, 打印在控制台
        System.out.println(arr[1]);

        // 判断数组中第一个元素, 是奇数还是偶数
        if (arr[0] % 2 == 0) {
            System.out.println(arr[0] + "是一个偶数");
        } else {
            System.out.println(arr[0] + "是一个奇数");
        }

        // 修改数组中第三个元素, 为66
        arr[2] = 66;
        System.out.println(arr[2]);

        // g根据数组中的第四个元素, 决定在控制台打印多少次HelloWorld
        for (int i = 1; i <= arr[3]; i++) {
            System.out.println("HelloWorld");
        }
    }
}

3.数组的遍历操作

package itheima.test;

public class ArrayTest1 {
    public static void main(String[] args) {
        printArray();
    }

    /*
        数组遍历 : 将数中的每一个(所有)的内容, 取出来进行操作

        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++) {
            // i = 0 1 2 3 4
            System.out.println(arr[i]);
        }

        弊端: 循环次数写死了
        改进: 使用数组名.length

                数组名.leng : 动态获取到数组的长度 (元素的个数)

        -------------------------------------------------

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

     */
    public static void printArray() {
        int[] arr = {11, 22, 33, 44, 55};
        
        // 数组遍历快捷键 : 数组名.fori

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

package itheima.test;

public class ArrayTest1 {
    public static void main(String[] args) {

        printArray();

        System.out.println("---------------------");

        getSum();
    }

    /*
        数组遍历 : 将数中的每一个(所有)的内容, 取出来进行操作

        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++) {
            // i = 0 1 2 3 4
            System.out.println(arr[i]);
        }

        弊端: 循环次数写死了
        改进: 使用数组名.length

                数组名.leng : 动态获取到数组的长度 (元素的个数)

        -------------------------------------------------

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

     */
    public static void printArray() {
        int[] arr = {11, 22, 33, 44, 55};

        // 数组遍历快捷键 : 数组名.fori

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

    }

    /*
        需求: 对数组中的偶数元素求和操作

        数组遍历的场景 : 如果要完成的需求, 是需要操作到数组中的 [每一个] 元素, 就需要对数组进行遍历操作
     */
    public static void getSum() {

        int[] arr = {11, 22, 33, 44, 55};

        // 1. 定义求和变量, 准备进行累加操作
        int sum = 0;
        // 2. 遍历数组, 获取到每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 3. 判断当前元素是否是偶数
            // i: 索引
            // arr[i] : 元素
            if (arr[i] % 2 == 0) {
                // 4. 是的话.进行累加求和
                sum += arr[i];
            }
        }
        // 5. 遍历结束后,将求和结果打印
        System.out.println("偶数和为:" + sum);
    }
}

package itheima.test;

public class ArrayTest2 {
    public static void main(String[] args) {
        int[] arr1 = {33, 55, 11, 22, 44};
        int[] arr2 = {100, 50, 20, 90, 90};
        int max = getMax(arr2);
        System.out.println("最高分为:" + max);
        int min = getMin(arr2);
        System.out.println("最低分为:" + min);
        System.out.println("班级总成绩为:" + getSum(arr2));
        System.out.println("班级平均分为:" + getAvg(arr2));
        System.out.println("低于平均分人数为:" + getCount(arr2));
    }

    /*
        需求: 已知数组元素为 {5,44,33,55,22} 请找出数组中最大值并打印在控制台

        分析:
                1. 第一名选手上台 (假设第一个元素就是最大值)
                2. 遍历数组, 获取到每一个元素
                3. 逐个比较
                4. 记录更大的元素
     */
    public static int getMax(int[] arr) {

        // 1. 第一名选手上台 (假设第一个元素就是最大值)
        int max = arr[0];
        // 2. 遍历数组, 获取到每一个元素
        for (int i = 1; i < arr.length; i++) {
            // 3. 逐个比较
            if (arr[i] > max) {
                // 4. 记录更大的元素
                max = arr[i];
            }
        }

        return max;
    }

    /*
        需求:
            已知班级学成成绩为
            int[] arr = {100, 50, 20, 90, 90}
            1. 找出数组最大值, 并打印在控制台
            2. 找出数组最小值, 并打印在控制台
            3. 求总成绩, 并打印在控制台
            4. 计算出平均值, 并打印在控制台
            5. 统计出低于平均值元素的个数
     */

    /*从数组中找最小值*/
    public static int getMin(int[] arr) {

        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    /*求总成绩*/
    public static int getSum(int[] arr) {

        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    /*求平均值*/
    public static double getAvg(int[] arr){

        int sum = getSum(arr);
        double avg = (sum * 1.0)/ arr.length;
        return avg;
    }

    /*统计出低于平均值元素的个数*/
    public static int getCount(int[] arr){

        int count = 0;
        double avg = getAvg(arr);
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < avg){
                count++;
            }
        }
        return count;
    }
}

4.动态初始化

初始化时只指定数组长度, 由系统为数组分配初始值

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

• 范例:  int[ ]  arr  =  new  int[3] ;

package itheima.array;

public class ArrayDemo3 {
    public static void main(String[] args) {
        arrayTest();
    }

    /*
        数组的动态初始化 :

            在初始化的时候, 只需要指定数组的长度, 系统就会分配默认值(初始值)

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

            默认值的分类 :

                    整数 : 0
                    小数 : 0.0
                    布尔 : false
                    ----------------------------------
                    字符 : '\u0000'   ---> Unicode字符  --->常见的体现是空白字符
                    引用数据类型 : null

                    引用数据类型 : 数组, 类, 接口

                    String : 类
     */
    public static void arrayTest(){

        String[] arr = new String[3];

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

两种初始化的区别

动态初始化:  手动指定数组长度, 由系统给出默认初始化值.

静态初始化:  手动指定数组元素, 系统会根据元素个数, 计算出数组的长度.

package itheima.test;

import java.util.Random;
import java.util.Scanner;

public class ArrayTest3 {
    /*
        数组两种初始化的区别 :

            动态初始化: 手动指定数组长度, 由系统给出默认初始化值.
            静态初始化: 手动指定数组元素, 系统会根据元素个数, 计算出数组的长度.

        两种初始化的使用选择 :

            1. 静态初始化: 如果要操作的数据, 需求中已经明确给出了, 直接静态初始化
                            需求: 已知班级学生成绩为 100 100 90 20 100, 找出最高分
                            int[] arr = {100,100,90,100};

            2. 动态初始化: 只明确元素个数, 不明确具体数值
                            需求1: 键盘录入5个学生成绩, 找出最高分
                            需求2: 产生10个1~100之间的随机数, 找出最小值
     */
    public static void main(String[] args) {

        /*int[] arr = initArrayFromScanner();

        int max = getMax(arr);
        System.out.println("最大值为:" + max);*/

        int[] randomNums = initArrayFromRandom();

        int min = getMin(randomNums);
        System.out.println("最小值为:" + min);
    }

    private static int[] initArrayFromRandom() {
        Random r = new Random();
        int[] randomNums = new int[10];

        for (int i = 0; i < randomNums.length; i++) {
            randomNums[i] = r.nextInt(100) + 1;
            System.out.println(randomNums[i]);
        }
        return randomNums;
    }

    private static int[] initArrayFromScanner() {
        // Ctrl + alt + M : 抽取方法的快捷键
        Scanner sc = new Scanner(System.in);
        System.out.println("键盘录入班级成绩, 请输入班级人数:");
        int count = sc.nextInt();
        int[] arr = new int[count];

        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个");
            arr[i] = sc.nextInt();
        }
        return arr;
    }

    /*从数组中找最大值*/
    public static int getMax(int[] arr) {

        // 1. 第一名选手上台 (假设第一个元素就是最大值)
        int max = arr[0];
        // 2. 遍历数组, 获取到每一个元素
        for (int i = 1; i < arr.length; i++) {
            // 3. 逐个比较
            if (arr[i] > max) {
                // 4. 记录更大的元素
                max = arr[i];
            }
        }

        return max;
    }

    /*从数组中找最小值*/
    public static int getMin(int[] arr) {

        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }
}

Java 内存分配介绍

• 栈

• 堆

• 方法区

• 本地方法栈 (辅助本地虚拟机干活, 暂时先不管)

• 寄存器 (由cpu调用, 先不管)

package itheima.args;

public class ArgsTest1 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前:" + number);
        change(number);
        System.out.println("调用change方法后:" + number);
    }

    public static void change(int number){
        number = 200;
    }
}

package itheima.args;

public class ArgsTest2 {

    /*
        方法参数传递问题:

            1. 基本数据类型: 传递的是数据值
            2. 引用数据类型: 传递的是地址值

            问题: Java到底是值传递, 还是址传递?
            回答: 值传递, 地址值也是值
     */
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55};
        System.out.println("调用change方法之前:" + arr[0]);
        change(arr);
        System.out.println("调用change方法之后:" + arr[0]);
    }

    public static void change(int[] arr) {
        arr[0] = 66;
    }
}

索引越界异常

ArrayIndexOutOfBoundsException :  当访问了数组中不存在的索引,就会引发索引越界异常.

package itheima.exception;

public class ArrayIndexOutOfBoundsExceptionDemo {
    /*
        数组索引越界异常 : ArrayIndexOutOfBoundsException

        原因: 访问了不存在的索引
     */
    public static void main(String[] args) {
        int[] arr = {11, 22, 33};

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

空指针异常

package itheima.exception;

public class NullPointerExceptionDemo {
    /*
        空指针异常 : NullPointerException

        原因: 当引用数据类型的变量, 被赋值为null之后, 就代表跟堆内存的连接被切断了
                这时候还想去访问堆内存的数据, 就会出现空指针异常
     */
    public static void main(String[] args) {

        int[] arr = {11, 22, 33};

        arr = null;

        System.out.println(arr[0]);

    }
}

5.二维数组

二维数组是一种容器,  该容器用于存储一维数组.

二维数组静态初始化格式

package itheima.array2;

public class ArrayDemo1 {
    /*
        细节: 二维数组在存储一维数组的时候, 具体存储的是一维数组的地址值

        二维数组的元素访问格式 :

                数组名[m索引][n索引] :

                m索引 : 指定访问哪一个一维数组
                n索引 : 访问一位数组中的哪一个元素
     */
    public static void main(String[] args) {
        int[][] arr = {
                {11,22,33},
                {44,55,66}
        };

        System.out.println(arr);        // [[I@776ec8df

        System.out.println(arr[0]);     // [I@4eec7777
        System.out.println(arr[1]);     // [I@3b07d329

        System.out.println(arr[1][1]);
        System.out.println(arr[0][2]);
    }
}

二维数组动态初始化格式

package itheima.test;

public class ArrayTest4 {
    /*
        二维数组的遍历操作

                1. 遍历二维数组, 获取到每一个一维数组
                2. 继续遍历一维数组, 获取到具体的元素
     */
    public static void main(String[] args) {
        int[][] arr = {
                {11,22,33},
                {44,55,66}
        };

        printArray(arr);

        int sum = getSum(arr);
        System.out.println("求和结果为:" + sum);
    }

    /*
    * 遍历并打印二维数组中元素
    * 已知一个二维数组 arr = { {11, 22, 33}, {44, 55, 66} }
    * 遍历该数组, 取出所有元素并打印
    * */
    public static void printArray(int[][] arr){

        // 遍历二维数组, 获取到每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            // arr[i] : 每一个一维数组
            // 2. 继续遍历一维数组, 获取具体的元素
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }


    }

    /*
    * 遍历二维数组并求和
    * 已知一个二维数组 arr = { {11, 22, 33}, {44, 55, 66} }
    * 对内部存储的元素累加求和, 并将结果输出在控制台
    * */
    public static int getSum(int[][] arr){
        int sum = 0;

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                sum += arr[i][j];
            }
        }
        return sum;
    }
}

package itheima.array2;

public class ArrayDemo2 {
    /*
        二维数组动态初始化 :

            格式: 数据类型[][] 数组名 = mew = 数据类型[m][n];

            m : 这个二维数组中, 可以存放多少个一维数组
            n : 每一个一维数组中, 可以存放多少个元素
     */
    public static void main(String[] args) {

        // 问题: 能不能将提前创建好的一维数组, 直接存入二维数组中?
        int[] arr1 = {11, 22, 33};
        int[] arr2 = {44, 55, 66};

        int[][] arr = new int[2][3];

        arr[0] = arr1;
        arr[1] = arr2;

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

        
    }

    private static void arrayTest1() {
        // 这个二维数组中可以存储2个一维数组, 每一个一维数组中可以存放3个元素
        int[][] arr = new int[2][3];

        arr[0][0] = 11;
        arr[0][2] = 33;

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