JavaSE从入门到放弃.数组

数组

数组就是一个容器，用来存一批同种类型的数据的。

比如：想要存储 20,10,80,60,90 这些数据。 我们可以把代码写成这样

int[]array={20,10,80,60,90};

数组的定义和访问

数组有两种初始化的方式，一种是静态初始化、一种是动态初始化。

数组的静态初始化

所谓静态初始化指的是：在定义数组时直接给数组中的数据赋值。

数据类型[]变量名=new 数据类型[]{元素1,元素2,元素3};

按照格式定义int类型、double类型数组

public class Demo {
    public static void main(String[] args) {
        int[] ages = new int[]{12, 24, 36}
        double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
    }
}

静态初始化简化格式

Java语言的设计者为了简化定义数组的写法，还为静态初始化提供了一种简化写法

数据类型[]变量名={元素1,元素2,元素3};

定义数组时， 数据类型[] 数组名 也可写成 数据类型 数组名[]

使用简化格式定义int类型、double类型数组

public class Demo {
    public static void main(String[] args) {
        int[] ages = {12, 24, 36}
        double[] scores = {89.9, 99.5, 59.5, 88.0};
    }
}

数组在计算机中的基本原理

以int[] ages = {12,24,36};这句话为例，看一下这句话到底在计算机中做了那些事情。

• 首先，左边int[] ages 表示定义了一个数组类型的变量，变量名叫ages
• 其次，右边{12,24,36}
  表示创建一个数组对象，你完全可以把它理解成一个能装数据的东西。这个对象在内存中会有一个地址值[I@4c873330
  ，每次创建一个数组对象都会有不用的地址值。
• 然后，把右边的地址值[I@4c873330赋值给左边的ages变量
• 所以，ages变量就可以通过地址值，找到数组这个东西。

数组的元素访问

数组中存储的数据我们叫做元素；而且数组中的每一个元素都有一个编号与之对应，我们把这个编号叫做索引，这个索引是从0依次递增的整数。
数组名可以找到数组对象的地址，再通过索引就可以定位到具体的元素了
要想访问数组中的元素，格式如下

数组名[索引]

public class Demo {
    public static void main(String[] args) {
        int[] arr = {12, 24, 36};

        // 访问
        System.out.println(arr[0]); //12
        System.out.println(arr[1]); //24
        System.out.println(arr[2]); //36
        //下面代码没有3索引，会出现ArrayIndexOutOfBoundsException 索引越界异常
        //System.out.println(arr[3]); 

        // 修改数组中的数据
        arr[0] = 66;
        arr[2] = 100;
        System.out.println(arr[0]); //66
        System.out.println(arr[1]);
        0
        System.out.println(arr[2]); //100
    }
}

除了访问数组中的元素，我们可以获取数组中元素的个数，后面我们统称为数组的长度。

数组的遍历

public class Demo {
    public static void main(String[] args) {
        int[] ages = {12, 24, 36};
        for (int i = 0; i < ages.length; i++) {
            System.out.println(ages[i]);
        }
    }
}

数组的动态初始化

动态初始化不需要我们写出具体的元素，而是指定元素类型和长度就行。格式如下

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

public class Demo {
    public static void main(String[] args) {
        int[] arr = new int[3];
    }
}

注意： 使用动态初始化定义数组时，根据元素类型不同，默认值也有所不同。

public class Demo {
    public static void main(String[] args) {
        double[] scores = new double[6];

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请您输入第" + (i + 1) + "个数字：");
            double score = sc.nextDouble();
            scores[i] = score;
        }

        // 遍历数组中的每个元素进行求和
        double sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        System.out.println("总数是：" + sum / scores.length);
    }
}

数组在计算机中的执行原理

public class ArrayDemo {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);

        int[] arr = new int[]{11, 22, 33};
        System.out.println(arr);

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

        arr[0] = 44;
        arr[1] = 55;
        arr[2] = 66;

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

Java为了便于虚拟机执行Java程序，将虚拟机的内存划分为 方法区、栈、堆、本地方法栈、寄存器 这5块区域。

• 方法区：字节码文件先加载到这里
• 栈：方法运行时所进入的内存区域，由于变量在方法中，所以变量也在这一块区域中
• 堆：存储new出来的东西，并分配地址。由于数组是new 出来的，所以数组也在这块区域。

多个变量指向同一个数组的问题

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33};
        int[] arr2 = arr1;

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

        arr2[1] = 99;
        System.out.println(arr1[1]);

        arr2 = null;
        System.out.println(arr2);
    }
}

• 两个变量指向同一个数组时，两个变量记录的是同一个地址值。
• 当一个变量修改数组中的元素时，另一个变量去访问数组中的元素，元素已经被修改过了。

案例

需求：定义一个int类型数组，求数组中元素的最大值，并打印最大值

public class Test {
    public static void main(String[] args) {
        int max = faceScores[0];
        int[] faceScores = {15, 9000, 10000, 20000, 9500, -5};

        for (int i = 1; i < faceScores.length; i++) {
            if (faceScores[i] > max) {
                max = faceScores[i];
            }
        }
        System.out.println("最大值是：" + max);
    }
}

需求：数组元素反转

public class Test {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }

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