Java数组相关

1、数组

1.1、定义

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。 即：数(数据)组(一组)就是一组数据

public static void main(String[] args) {
    // 定义一个double类型的数组
    // 1. double[] 表示是double类型的数组, 数组名arrList
    // 2. {1.1, 2.2, 3.3, 4.4} 表示数组的值/元素,依次表示数组的第几个元素
    double[] arrList = {1.1, 2.2, 3.3, 4.4};

    // 遍历得到数组的和
    // 1. 我们可以通过arrList[下标]来访问数组的元素
    //    下标是从0开始编号的比如第一个元素就是arrList[0], 第2个元素就是arrList[1], 依次类推
    // 2. 通过for就可以循环的访问 数组的元素/值
    // 3. 使用一个变量sum将各个元素累积
    double sum = 0;
    for (int i = 0; i < arrList.length; i++) {
        sum += arrList[i];
    }
    System.out.println("sum=" + sum);
}

1.2、数组的使用

1.2.1、方式一 (动态分配方式)

public static void main(String[] args) {
    // 创建一个int数组, 大小 5
    int[] arrList1 = new int[5];

    // 循环输入
    Scanner scanner = new Scanner(System.in);
    for (int i = 0; i < arrList1.length; i++) {
        arrList1[i] = scanner.nextInt();
    }

    // 循环遍历
    for (int i = 0; i < arrList1.length; i++) {
        System.out.println("第" + (i + 1) + "个元素的值=" + arrList1[i]);
    }
}

1.2.2、方式二 (动态初始化)

// 先声明数组 语法:数据类型 数组名[]; 也可以 数据类型[] 数组名; int a[]; 或者 int[] a; 
// 创建数组 语法: 数组名=new 数据类型[大小]; a=new int[10];

// 先声明数组, 再new分配空间
public static void main(String[] args) {
    int[] arrList2;  // 声明数组, 这时arrList2是null
    arrList2 = new int[5];  // 分配内存空间, 可以存放数据
	
	// 循环输入
    Scanner scanner = new Scanner(System.in);
    for (int i = 0; i < arrList2.length; i++) {
        arrList2[i] = scanner.nextInt();
    }

    // 循环遍历
    for (int i = 0; i < arrList2.length; i++) {
        System.out.println("第" + (i + 1) + "个元素的值=" + arrList2[i]);
    }
}

1.2.3、方式三 (静态初始化)

public static void main(String[] args) {
    int[] arrList3 = {1, 2, 3, 4, 5};
    for (int i = 0; i < arrList3.length; i++) {
        System.out.println(arrList3[i]);
    }
}

1.3、注意事项和细节

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用 (同一个数组中必须是同一种类型)
3. 数组创建后，如果没有赋值，有默认值 int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
4. 使用数组的步骤 （1）声明数组并开辟空间 （2）给数组各个元素赋值 （3）使用数组
5. 数组的下标是从 0 开始的
6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如 int [] arr=new int[5]; 则有效下标为 0-4
7. 数组属引用类型，数组型数据是对象(object)

public static void main(String[] args) {
    // 创建一个 char 类型的 26 个元素的数组，
    // 分别 放置'A'-'Z'。使用 for 循环访问所有元素并打印出来。
    // 提示：char 类型 数据运算 'A'+2 -> 'C'
    char[] arrList = new char[26];
    for (int i = 0; i < arrList.length; i++) {
        arrList[i] = (char) ('A' + i);
    }

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

public static void main(String[] args) {
    // 请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标。
    int[] arrList = {4, -1, 9, 99, 102, 10, 23};
    int maxIndex = 0;
    int maxValue = arrList[maxIndex];
    for (int i = 0; i < arrList.length; i++) {
        if (arrList[i] > maxValue) {
            maxValue = arrList[i];
            maxIndex = i;
        }
    }
    System.out.println("最大值是" + maxValue + ", 下标是" + maxIndex);
}

1.4、数组赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。 int n1 = 2; int n2 = n1;
2. 数组在默认情况下是引用传递，赋的值是地址。

int[] arr1 = {1,2,3}; 
int[] arr2 = arr1;

对应的内存图：

1.5、数组拷贝

将 int[] arr1 = {10,20,30}; 拷贝到arr2数组, 要求数据空间是独立的

public static void main(String[] args) {

    // 将 int[] arr1 = {10,20,30}; 拷贝到arr2数组, 要求数据空间是独立的
    int[] arr1 = {10, 20, 30};
    int[] arr2 = new int[arr1.length];
    for (int i = 0; i < arr1.length; i++) {
        arr2[i] = arr1[i];
    }
    // 修改arr1， 不会对arr2有影响.
    arr1[0] = 100;  // 将arr1的第一个元素值改成100

    for (int i = 0; i < arr1.length; i++) {
        System.out.print(arr1[i] + " ");  // 100 20 30
    }

    for (int i = 0; i < arr2.length; i++) {
        System.out.print(arr2[i] + " ");  // 10 20 30
    }
}

1.6、数组反转

方式一 (使用逆序赋值方式)

public static void main(String[] args) {

    // 数组反转 {11,22,33,44,55,66} -> {66, 55,44,33,22,11}
    int[] arrReverse1 = {11, 22, 33, 44, 55, 66};
    int[] arrReverse2 = new int[arrReverse1.length];
    for (int i = 0, j = arrReverse1.length - 1; i < arrReverse1.length; i++, j--) {
        arrReverse2[i] = arrReverse1[j];
    }
    for (int i = 0; i < arrReverse2.length; i++) {
        System.out.print(arrReverse2[i] + " ");
    }
}

方式二 (通过找规律反转)

public static void main(String[] args) {

    // 数组反转 {11,22,33,44,55,66} -> {66, 55,44,33,22,11}
    int[] arrReverse = {11, 22, 33, 44, 55, 66};
    int temp = 0;
    int len = arrReverse.length;
    for (int i = 0; i < len / 2; i++) {
        temp = arrReverse[len - 1 - i];
        arrReverse[len - 1 - i] = arrReverse[i];
        arrReverse[i] = temp;
    }

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

1.7、数组添加/扩容

实现动态的给数组添加元素效果，实现对数组扩容。

1. 原始数组使用静态分配 int[] arr = {1,2,3}
2. 增加的元素 4，直接放在数组的最后 arr = {1,2,3,4}
3. 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

public static void main(String[] args) {
    // 数组动态扩容
    int[] arrList = {10, 20, 30};
    do {
        Scanner scanner = new Scanner(System.in);
        int[] arrNewList = new int[arrList.length + 1];
        for (int i = 0; i < arrList.length; i++) {
            arrNewList[i] = arrList[i];
        }
        System.out.print("请输入要添加的数值: ");
        int addNum = scanner.nextInt();
        arrNewList[arrNewList.length - 1] = addNum;
        arrList = arrNewList;
        System.out.println("====arrList扩容后元素情况====");
        // 查看扩容后的效果
        for (int i = 0; i < arrList.length; i++) {
            System.out.print(arrList[i] + "\t");
        }
        System.out.println("是否继续添加【y/n】");
        char key = scanner.next().charAt(0);
        if (key == 'n') break;
    } while (true);
}

1.8、数组减少/缩容

public static void main(String[] args) {
    // 有一个数组 {1， 2， 3， 4， 5}，
    // 可以将该数组进行缩减，提示用户是否继续缩减，每次缩减最后那个元素。当只剩 下最后一个元素，提示，不能再缩减
    int[] arrList = {1, 2, 3, 4, 5};
    do {
        Scanner scanner = new Scanner(System.in);
        int len = arrList.length;
        int[] arrNewList = new int[len - 1];
        for (int i = 0; i < len - 1; i++) {
            arrNewList[i] = arrList[i];
        }
        System.out.println("是否要继续缩容? 【y/n】");
        char key = scanner.next().charAt(0);
        if (key != 'y') break;
        arrList = arrNewList;
        System.out.println("=====动态缩容后的数组=====");
        for (int i = 0; i < arrNewList.length; i++) {
            System.out.print(arrNewList[i] + "\t");
        }
    } while (arrList.length > 0);
    System.out.println("程序结束...");
}

1.9、数组排序

排序是将多个数据，依指定的顺序进行排列的过程。

1.9.1、数组排序的分类

1.9.1.1、内部排序

指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择 式排序法和插入式排序法)。

1.9.1.2、外部排序

数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。

1.9.2、冒泡排序法

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素 的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

public static void main(String[] args) {
    // 冒泡排序
    int[] arrList = {24, 69, 80, 57, 13};
    int temp = 0;
    for (int i = 0; i < arrList.length - 1; i++) {
        for (int j = 0; j < arrList.length - 1 - i; j++) {
            if (arrList[j] > arrList[j + 1]) {
                temp = arrList[j];
                arrList[j] = arrList[j + 1];
                arrList[j + 1] = temp;
            }
        }
    }

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

1.10、查找

1.10.1、查找分类

1. 顺序查找
2. 二分查找

1.10.2、查找案例

public static void main(String[] args) {
    // 有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王
    // 猜数游戏：从键盘中任意输入一个名称，判断数列中是否 包含此名称【顺序查找】 要求: 如果找到了，就提示找到，并给出下标值
    String[] arrList = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
    int index = -1;
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入要查找的值: ");
    String findValue = scanner.next();
    for (int i = 0; i < arrList.length; i++) {
        if (findValue.equals(arrList[i])) {
            index = i;
            break;
        }
    }
    if (index == -1) {
        System.out.println("没有找到" + findValue);
        return;
    }
    System.out.println("找到了, 值是" + findValue + ", 下标是" + index);
}

1.11、多维数组

多维数组以二维数组为例。 二维数组的应用场景 比如我们开发一个五子棋游戏，棋盘就是需要二维数组来表示。如图：

1.11.1、二维数组的使用

public static void main(String[] args) {
    // 请用二维数组输出如下图形
    // 0 0 0 0 0 0
    // 0 0 1 0 0 0
    // 0 2 0 3 0 0
    // 0 0 0 0 0 0
    int[][] arrList = {{0, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 2, 0, 3, 0, 0}, {0, 0, 0, 0, 0, 0}};
    for (int i = 0; i < arrList.length; i++) {
        for (int j = 0; j < arrList[i].length; j++) {
            System.out.print(arrList[i][j] + "\t");
        }
        System.out.println();
    }
}

1.11.1.1、使用方式一 (动态初始化)

1. 语法: 类型[][] 数组名=new 类型[大小][大小]
2. 比如: int a[][]=new int[2][3]

public static void main(String[] args) {
    int arr[][] = new int[2][3];
    
    arr[1][1] = 8;
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println();
    }
}

1.11.1.2、使用方式二 (动态初始化)

先声明：类型 数组名[][];
再定义(开辟空间) 数组名 = new 类型[大小][大小]
赋值(有默认值，比如 int 类型的就是 0)

public static void main(String[] args) {
    int arr[][];  // 声明二维数组
    arr = new int[2][3];  // 再开空间

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

1.11.1.3、使用方式三 (动态初始化-列数不确定)

public static void main(String[] args) {
    //创建二维数组，每个是有3个一维数组，但是每个一维数组还没有开数据空间
    int[][] arrList = new int[3][];
    for (int i = 0; i < arrList.length; i++) {
        // 给每个一维数组开空间 new
        // 如果没有给一维数组new ,那么 arr[i]就是 null
        arrList[i] = new int[i + 1];
        //遍历一维数组，并给一维数组的每个元素赋值
        for (int j = 0; j < arrList[i].length; j++) {
            arrList[i][j] = i + 1;
        }
    }
    //遍历 arrList 输出
    for (int i = 0; i < arrList.length; i++) {
        for (int j = 0; j < arrList[i].length; j++) {
            System.out.print(arrList[i][j] + "\t");
        }
        System.out.println();
    }
}

1.11.1.4、使用方式四 (静态初始化)

定义 类型 数组名[][] = {{值 1,值 2…},{值 1,值 2…},{值 1,值 2…}}
使用即可 [ 固定方式访问 ]
比如:
int[][] arr = {{1,1,1}, {8,8,9}, {100}};

1. 定义了一个二维数组 arr
2. arr 有三个元素(每个元素都是一维数组)
3. 第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组有 1 个元素

public static void main(String[] args) {
    // 遍历该二维数组，并得到和
    int arr[][] = {{4, 6}, {1, 4, 5, 7}, {-2}};
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            sum += arr[i][j];
        }
    }
    System.out.println("二维数组的和是" + sum);
}

1.11.2、使用细节和注意事项

1. 一维数组的声明方式有:
   int[] x 或者 int x[]
2. 二维数组的声明方式有:
   int[][] y 或者 int[] y[] 或者 int y[][]
3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如： map[][] 是 一个二维数组
   int map [][] = {{1,2},{3,4,5}}
   由 map[0] 是一个含有两个元素的一维数组，map[1] 是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组