【Java复习巩固 Day2】数组

数组也是大部分编程语言都支持数据结构，Java也不例外。Java的数组类型是一种引用类型的变量，Java程序通过数组引用变量来操作数组，包括获得数组的长度，访问数组元素的值等。

Java的数组要求所有的数组元素具有相同的数据类型。因此，在一个数组中，数组的元素类型是唯一的，即一个数组只能存储一种数据类型的数据，不能存储多种数据类型的数据

定义数组

type[] arrayName;
type arrayName[];

数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量，这个引用变量还未指向任何有效内存，因此定义数组时不能指定数组的长度
由于定义数组只是定义了一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有对数组进行初始化后才可以使用

数组的初始化

所谓的初始化，就是为数组元素分配内存空间，并为每个数组赋初始值

• 静态初始化：初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组的长度
• 动态初始化：初始化时程序员只指定数组的长度，由系统为数组元素分配初始值

静态初始化

arrayName = new type[] {elem1, elem2, ...}

动态初始化

arrayName = new type[length];

package day2;

public class ArrayTest {
    public static void main(String[] args) {
        int[] arr1;
        int[] arr2;
        // 静态初始化
        arr1 = new int[] {1, 2, 3, 4, 5};
        // 动态初始化
        arr2 = new int[10];
    }
}

在动态初始化中，指定初始值时，系统按照如下规则分配初始值
整数类型为0
浮点类型为0.0
字符类型为’\u0000’
布尔类型为false
引用类型为null

注意：不要同时使用静态初始化和动态初始化，也就是说，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值

数组的使用

package day2;

public class ArrayTest {
    public static void main(String[] args) {
        int[] arr1;
        int[] arr2;
        // 静态初始化
        arr1 = new int[] {1, 2, 3, 4, 5};
        // 动态初始化
        arr2 = new int[10];
        // 修改数组的元素
        arr1[1] = 100;
        arr2[0] = 1024;
        // 访问数组元素
        System.out.println(arr1[1]);
        System.out.println(arr2[2]);
        // 获取数组的长度
        System.out.println(arr2.length);
        // foreach循环
        for (int item : arr1) {
            System.out.println(item);
        }
        for (int item : arr2) {
            System.out.println(item);
        }
    }
}

100
0
10
1
100
3
4
5
1024
0
0
0
0
0
0
0
0
0

Process finished with exit code 0

注意：使用foreach循环迭代数组元素时，并不能改变数组元素的值，因此不要对foreach的循环变量进行赋值

工具类：Arrays

Java提供的Arrays类里包含了一些static修饰的方法可以直接操作数组
Arrays类处于java.util包下，为了在程序中使用Arrays类，必须在程序中导入java.util.Arrays类

package day2;

import java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args) {
        int[] arr = new int[10];
        // 数组填充
        Arrays.fill(arr, 1024);
        Arrays.fill(arr, 1, 5, 2);
        System.out.println(Arrays.toString(arr));
        // 数组复制
        int[] arr1 = Arrays.copyOf(arr, 5);
        int[] arr2 = Arrays.copyOfRange(arr, 1, 6);
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
        // 数组排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        // 二分查找
        int pos;
        System.out.println((pos=Arrays.binarySearch(arr, 1)) < 0 ? "未找到" : pos);
        System.out.println((pos=Arrays.binarySearch(arr, 1, 9, 1024)) < 0 ? "不存在" : pos);
    }
}

[1024, 2, 2, 2, 2, 1024, 1024, 1024, 1024, 1024]
[1024, 2, 2, 2, 2]
[2, 2, 2, 2, 1024]
[2, 2, 2, 2, 1024, 1024, 1024, 1024, 1024, 1024]
未找到
4

Process finished with exit code 0

package day2;

import java.util.Arrays;
import java.util.function.IntBinaryOperator;
import java.util.function.IntUnaryOperator;

public class ArraysTest1 {
    public static void main(String[] args) {
        int[] arr1 = new int[] {3, -4, 25, 16, 30, 18};
        // 对数组进行并发排序
        Arrays.parallelSort(arr1);
        System.out.println(Arrays.toString(arr1));

        int[] arr2 = new int[] {3, -4, 25, 16, 30, 18};
        Arrays.parallelPrefix(arr2, new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                return left * right;
            }
        });
        System.out.println(Arrays.toString(arr2));

        int[] arr3 = new int[10];
        Arrays.parallelSetAll(arr3, new IntUnaryOperator() {
            @Override
            public int applyAsInt(int operand) {
                return operand * 5;
            }
        });
        System.out.println(Arrays.toString(arr3));
    }
}

[-4, 3, 16, 18, 25, 30]
[3, -12, -300, -4800, -144000, -2592000]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]

Process finished with exit code 0