Array1

Demo1

数组：是一块连续固定大小的内存空间，有着索引的概念

定义数组的语句格式：
        数据类型[] 数组名;【推荐】
        数据类型 数组名[];

如果只是定义一个数组的话，没有给初始化值，相当于一个变量没有值，是不能够直接使用的
    如何对一个数组进行初始化？
        1、动态初始化：我们自己给定数组的大小，数组中的默认值由JVM来赋值
        2、静态初始化：我们自己给元素值，由JVM根据我们给的值数量来设置数组的大小

动态初始化语句定义格式：
        数据类型[] 数组名 = new 数据类型[元素的个数];

public class ArrayDemo1 {
    public static void main(String[] args) {
        //定义一个存储int类型元素的数组
        //数据类型 变量名 = 初始化值;
        int[] arr = new int[3];
        /*
            左边：
                int: 表示该数组中元素的数据类型，需要一致
                []: 表示一个一维数组
                arr:是数组名，符合标识符变量的命名规则
            右边：
                new:将来看到new，表示在堆内存中开辟一个空间
                int: 表示该数组中元素的数据类型，需要一致
                []: 表示一个一维数组
                3: 表示该数组最大只能存储3个int类型的元素
         */

        System.out.println(arr); // [I@4554617c 地址值【16进制】
        //数组有索引的概念，从左向右，索引下标从0开始编号，我们可以通过这个索引下标来定位到具体位置的元素
        //语法格式：数组名[索引]
        //获取数组中的第一个元素
        int i = arr[0];
        System.out.println(i);
        //获取数组中的第二，三个元素
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //我们以后使用数组的时候，肯定是希望将我们自己元素值放在数组中
        //将数组第一个元素值进行修改
        arr[0] = 100;
        System.out.println(arr[0]);

    }
}

Demo2

/*
    定义两个数组，先定义一个数组，赋值，输出。
    然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
    然后给第二个数组赋值，再次输出两个数组的名及元素。

 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        arr1[0] = 11;
        arr1[1] = 22;
        arr1[2] = 33;
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println("-----------------------------");
        int[] arr2 = arr1;
        arr2[1] = 100;
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

Demo3

/*
    我们上一个案例中，学习了数组的定义以及数组的动态初始化
    但是，有一个地方不太方便，如果我们想要赋值自己的元素在数组中的话，动态初始化需要我们先将数组创建出来
    然后再一个一个赋值，其实挺麻烦的。能不能直接在初始化的时候，将元素赋值进去？

    数组的静态初始化：
        数据类型[] 数组名 = new 数据类型[]{元素1,...};
        举例：int[] arr1 = new int[]{11,22,33,44,55};
        简化写法：
            数据类型[] 数组名 = {元素1,...};

 */
public class ArrayDemo3 {
    public static void main(String[] args) {
//        int[] arr1 = new int[]{11,22,33,44,55};
//        System.out.println(arr1);
//        System.out.println(arr1[3]);

//        int[] arr1;
//        arr1 = new int[]{11,22,33,44,55};
//        System.out.println(arr1);

        int[] arr1 = {11,22,33,44,55};
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr1[3]);
        System.out.println(arr1[4]);
//        System.out.println(arr1[5]); // ArrayIndexOutOfBoundsException 数组越界异常

        arr1 = null;
//        System.out.println(arr1[0]); // NullPointerException
    }
}

Demo4

/*
    1、当基本数据类型当作参数传递的时候，传递的是具体的数值，不会对原本的变量值进行修改影响
    2、当引用数据类型当作参数传递的时候，传递的是地址值，方法内部可能会对地址值对应的堆内存空间中的数值进行修改。
 */
public class ArrayDemo4 {
    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        System.out.println("a:" + a + ",b:" + b); // a:10,b:20
//        change(a, b);
//        System.out.println("a:" + a + ",b:" + b); // a:10,b:20

        int[] arr = {1, 2, 3, 4, 5};
        change(arr);
        System.out.println(arr[1]);
    }

    public static void change(int[] arr) {
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] % 2 == 0) {
                arr[x] *= 2;
            }
        }
    }
    public static void change(int a, int b) {
        System.out.println("a:" + a + ",b:" + b); // a:10,b:20
        a = b;
        b = a + b;
        System.out.println("a:" + a + ",b:" + b); // a:20,b:40
    }
}

Test1

/*
    数组遍历
 */
public class ArrayTest1 {
    public static void main(String[] args) {
        //定义一个数组并初始化
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6};

//        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]);
//        System.out.println(arr[5]);
//        System.out.println(arr[6]);
//        System.out.println(arr[7]);
        //使用for循环改进
//        for(int i=0;i<8;i++){
//            System.out.println(arr[i]);
//        }
        //我们虽然使用了for循环改进遍历，但是，我们的范围是自己数出来的，当元素多的时候，很难数对
        //java中的数组都有一个属性，length属性，我们可以直接获取数组的该属性得到数组的长度【元素的个数】
        //语句格式：数组名.length
//        System.out.println("数组的长度为："+arr.length);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

Test2

/*
    数组获取最值

    分析：
        1、创建一个数组，赋值
        2、默认第一个元素是最大值或最小值
        3、从第二个元素开始循环，依次比较出较大的值和较小的值

 */
public class ArrayTest2 {
    public static void main(String[] args) {
        int[] arr = {34, 12, 72, 13, 76, 32, 12, 46, 2, 89};

        int maxNumber = arr[0];
        int minNumber = arr[0];

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxNumber) {
                maxNumber = arr[i];
            } else {
                minNumber = arr[i];
            }
        }

        System.out.println("最大值为：" + maxNumber);
        System.out.println("最小值为：" + minNumber);
    }
}

Test3

/*
    数组元素逆序
    分析：
        1、交换的次数是长度/2的整除
        2、交换的时候，需要使用到一个临时变量
 */
public class ArrayTest3 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        System.out.println("逆序前：");
        printIntArray(arr);
        System.out.println("-------------------------------");
//        //第一次交换，将第1个元素与最后一个元素交换
//        int tmp1 = arr[arr.length-0-1];
//        arr[arr.length-0-1] = arr[0];
//        arr[0] = tmp1;
//        //第二次交换，将第2个元素与倒数第2个元素交换
//        int tmp2 = arr[arr.length-1-1];
//        arr[arr.length-1-1] = arr[1];
//        arr[1] = tmp2;
//        //第三次交换，将第3个元素与倒数第3个元素交换
//        int tmp3 = arr[arr.length-2-1];
//        arr[arr.length-2-1] = arr[2];
//        arr[2] = tmp3;
//        System.out.println("逆序后：");
//        printIntArray(arr);

        //使用for循环解决
//        for (int i = 0; i < arr.length/2; i++) {
//            int tmp = arr[arr.length - i - 1];
//            arr[arr.length - i - 1] = arr[i];
//            arr[i] = tmp;
//        }

//        int[] resArr = niXu1(arr);
//        System.out.println("逆序后：");
//        printIntArray(resArr);

        int[] resArr = niXu2(arr);
        System.out.println("逆序后：");
        printIntArray(resArr);

    }

    public static int[] niXu2(int[] arr) {
        for (int front = 0, end = arr.length - 1; front < end; front++, end--) {
            int tmp = arr[end];
            arr[end] = arr[front];
            arr[front] = tmp;
        }
        return arr;
    }


    public static int[] niXu1(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int tmp = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = arr[i];
            arr[i] = tmp;
        }
        return arr;
    }

    public static void printIntArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (i == 0) {
                System.out.print("[" + arr[i] + ",");
            } else if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
    }
}