JavaSE--数组

1.数组的概念

在Java中，数组是一种用来存储相同类型数据的容器。它是一个固定长度的数据结构，可以在内存中连续存储多个元素。

数组有以下特点：

• 数组中的元素可以是任何类型：基本数据类型（例如int、char、boolean等）或引用类型（例如对象、字符串等）。
• 数组的长度是固定的，一旦创建后，不能改变大小。
• 数组中的元素通过索引访问，索引从0开始，依次递增。可以使用方括号（[]）来访问数组的元素。
• 数组是对象，可以通过new关键字来创建数组对象。
• 数组可以一维或多维。一维数组是一个线性结构，而多维数组则是多个一维数组的组合。

2.数组的创建及初始化

// 声明和创建一个一维数组
type[] arrayName = new type[length];

// 声明和创建一个多维数组
type[][] arrayName = new type[rows][columns];
 

数组的初始化主要分为 动态初始化以及静态初始化 。

        1. 动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array = new int[10];//默认10个元素均为0

         2. 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"}

【注意事项】

• 静态初始化可以简写，省去后面的new T[]。

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"};

• 数组也可以按照如下C语言个数创建，不推荐

/*
该种定义方式不太友好，容易造成数组的类型就是int的误解
[]如果在类型之后，就表示数组类型，因此int[]结合在一块写意思更清晰
*/
int arr[] = {1, 2, 3};

• 静态和动态初始化也可以分为两步，但是省略格式不可以。

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3};

• 静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
• 静态初始化时, {}中数据类型必须与[]前数据类型一致。
• 如果没有对数组进行初始化，数组中元素有其默认值。
• 如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，比如：

       

3.遍历数组

• 方法一：使用for-each遍历

int[] array = {1, 2, 3};
for (int x : array) {
    System.out.println(x);
}

• 方法二：使用数组.length(）

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
    System.out.println(array[i]);
}

• 方法三：转化为字符串

int[] array = {1,2,3,4,5,6};
System.out.println(Arrays.toString(array));

 4.数组拷贝

import java.util.Arrays;
public static void func(){
    // newArr和arr引用的是同一个数组
    // 因此newArr修改空间中内容之后，arr也可以看到修改的结果
    int[] arr = {1,2,3,4,5,6};
    int[] newArr = arr;
    newArr[0] = 10;
    System.out.println("newArr: " + Arrays.toString(arr));
    // 使用Arrays中copyOf方法完成数组的拷贝：
    // copyOf方法在进行数组拷贝时，创建了一个新的数组
    // arr和newArr引用的不是同一个数组
    arr[0] = 1;
    newArr = Arrays.copyOf(arr, arr.length);
    System.out.println("newArr: " + Arrays.toString(newArr));
    // 因为arr修改其引用数组中内容时，对newArr没有任何影响
    arr[0] = 10;
    System.out.println("arr: " + Arrays.toString(arr));
    System.out.println("newArr: " + Arrays.toString(newArr));
    // 拷贝某个范围.
    int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
    System.out.println("newArr2: " + Arrays.toString(newArr2));
}

5.不规则二维数组

6.数组应用

6.1二分查找

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};
    System.out.println(binarySearch(arr, 6));
}
public static int binarySearch(int[] arr, int toFind) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (toFind < arr[mid]) {
            // 去左侧区间找
            right = mid - 1;
        } else if (toFind > arr[mid]) {
            // 去右侧区间找
            left = mid + 1;
        } else {
            // 相等, 说明找到了
            return mid;
        }
    }
    // 循环结束, 说明没找到
    return -1;
}
// 执行结果
//5

6.2冒泡排序

public static void main(String[] args) {
    int[] arr = {9, 5, 2, 7};
    bubbleSort(arr);
    System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 1; j < arr.length-i; j++) {
            if (arr[j-1] > arr[j]) {
                int tmp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = tmp;
            }
        }
    } // end for
} // end bubbleSort
// 执行结果
//[2, 5, 7, 9]

数组排序还可以用sort排序：

int[] arr = {9, 5, 2, 7};
Arrays.sort(arr);

制作不易，麻烦给个三连支持一下吧！！！