Java编程基础——数组和二维数组

Java编程基础——数组和二维数组

摘要：本文主要对数组和二维数组进行简要介绍。

数组

定义

数组可以理解成保存一组数的容器，而变量可以理解为保存一个数的容器。

数组是一种引用类型，用于保存一组相同类型的数据。

数组定义的类型可以为任意类型，意思是我们可以定义int类型的数组，也可以定义String类型的数组，或其他任何类型的数组。

数组实际在内存的存储和基本类型不同，实际上是在堆中申请空间保存一组数，栈中只是有一个地址的引用。

声明数组

语法：

类型[] 数组名;
类型 数组名[];

举例：

int[] sum;
int color[];

说明：

此时只是声明了一个数组变量，并没有在内存中开辟空间。

开辟空间

语法：

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

举例：

sum = new int[5];

说明：

数组开辟空间时，必须要设置开辟的空间长度。

这时会根据类型对数组里的数据设置默认值。

数组赋值

语法：

数组名[下标] = 值;

举例：

sum[0] = 10;

说明：

在对数组进行赋值时，注意下标不要超过数组的长度范围，否则会产生错误。

使用数组

语法：

数组名[下标]

举例：

System.out.println(sum[0]);

说明：

同样需要注意下标不要超过数组的长度范围。

其他赋值方式

除了上面通过下标赋值，还可以在声明时开辟空间并赋值，或者在开辟空间时赋值。

语法：

数组名 = new 类型[]{值, 值};
类型[] 数组名 = {值, 值};

举例：

int[] sum = {1, 2};
sum = new int[]{1, 2, 3};

说明：

这两种方式都需要在确定数组大小和值的内容的时候使用。

在开辟空间时赋值，不需要在中括号里面填写数组长度。

注意

数组不赋值也有默认值。

数组中每个元素的赋值和访问都是通过“数组名[下标]”实现的，不能直接使用数组名。

“数组名.length”代表的是数组的长度，经常用在循环中，提高代码的维护性。

数组的下标从 0  ~  数组名.length - 1 ，如果不是这个范围，会导致一个数组下标越界的异常：ArrayIndexOutOfBoundsException。

数组没有开辟空间，直接使用，会导致一个空指针异常：NullPointerException。

进阶使用

数组的复制

◆　引用类型的赋值：复制的是一个地址号，二者共同引用一个地址，其中一个对数组做了更改，都会影响另一个。

◆　基本类型的赋值：复制的是数值内容，实际上是一个备份，其中一个对它更改，不会影响另一个。

复制引用地址：

复制的是一个地址号，二者共同引用一个地址，其中一个对数组做了更改，都会影响另一个。

int[] a1 = {1, 2, 3};
int[] a2;
a2 = a1;
System.out.println(a2[0]);
a1[0] = 100;
System.out.println(a2[0]);

结果：

1
100

复制数组数据：

int[] a1={1, 7, 8};
int[] a2 = new int[a1.length];
for (int i = 0; i < a1.length; i++) {
    a2[i] = a1[i];
}
System.out.println(a2[0]);
a2[1]=100;
System.out.println(a2[0]);

结果：

1
1

数组的排序

int[] nums = {1, 9, 3, 5, 2, 8, 4};
for(int i = 0; i < nums.length - 1; i++) {// 控制轮数
    for(int j = 0; j < nums.length - 1 - i; j++) {
        if (nums[j] < nums[j + 1]) {// 交换
            int temp = nums[j];
            nums[j] = nums[j + 1];
            nums[j + 1] = temp;
        }
    }
}

数组的倒置

int[] nums = {1, 9, 3, 5, 2, 8, 4};
for(int i = 0; i < nums.length / 2; i++) {
    int temp = nums[i];
    nums[i] = nums[nums.length - 1 - i];
    nums[nums.length - 1 - i] = temp;
}

工具类

排序： Arrays.sort(nums); 

填充： Arrays.fill(nums, 1); 

转成字符串以便打印： Arrays.toString(nums); 

比较： Arrays.equals(a1, a2); 

二维数组

定义

二维数组可以看做是一个数组，里面存放的元素是一维数组。

声明数组

int[][] nums;
int nums[][];
int[] nums[];

开辟空间

nums = new int[3][];// 行固定，列不固定。
nums = new int[3][2];// 行固定，列固定。

数组赋值

动态初始化，使用时赋值，需要指明行和列：

nums[0][1] = 1;

静态初始化，声明时赋值，不必也不能指明行和列，否则会提示错误：

int[][] nums = new int[][]{{1}, {9, 3, 5, 2}, {7, 6}};
int[][] nums = {{1}, {9, 3, 5, 2}, {7, 6}};

注意

如果在动态初始化时明确了二维数组的行数和列数，那么一维数组的长度就是固定的列数。

如果在动态初始化时仅仅明确了行数，或者通过静态初始化赋值，那么一维数组可以有不同的长度。

数组排序

冒泡排序

思路

属于交换排序。

从第一个元素开始，比较两个相邻的元素，如果两个元素位置不正确，则进行交换，否则继续比较下面相邻的两个元素。

代码

public void test() {
    int[] arr = new int[]{1, 7, 3, 8, 5};
    int len = arr.length;
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

快速排序

思路

属于交换排序。

任取序列的某个元素作为界点，将序列分为两个子序列，左子序列的元素小于界点，右子序列的元素大于界点，然后递归每个子序列，直到每个子序列只有一个元素。

代码

public void test() {
    int[] arr = new int[]{8, 3, 11, 4, 9, 5, 1};
    sort(0, arr.length - 1, arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
public void sort(int left, int right, int[] arr){
    int l = left;
    int r = right;
    int pivot = arr[(left + right)/2];//找中间值
    int temp = 0;
    while(l < r){
        while(arr[l] < pivot) l++;
        while(arr[r] > pivot) r--;
        if(l >= r) break;
        temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;
        if(arr[l] == pivot) --r;
        if(arr[r] == pivot) ++l;
    }
    if(l == r){
        l++;
        r--;
    }
    if(left < r) sort(left, r, arr);
    if(right > l) sort(l, right, arr);
}

直接选择排序

思路

属于选择排序。

每次都选取最小值放在起始位上，一共通过n-1次。

代码

public void test() {
    int[] arr = new int[]{3, 2, 6, 10, 1, 9, 8};
    for (int i = 0; i < arr.length - 1; i++) {
        int index = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[index] > arr[j]) {
                index = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[index];
        arr[index] = temp;
    }
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}