Java数组//2020.6.13

知识点来源：bilibili狂神说

数组

---

一、数组的定义

• 数组是相同类型数据的有序集合.
• 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
• 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

四个基本特点：

1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2. 其元素必须是相同类型,不允许出现混合类型。

3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

---

二、数组的声明和创建

1.声明数组

在栈中操作

必须声明数组变量，才能在程序中使用数组。

dataType[ ] arrayRefVar ;首选
或
dataType arrayRefVar[ ]；效果相同但不常使用

2.创建数组

在堆中操作

arrayRefVar = new dataType[arraySize[ ];

精简语句：

dataType[  ]  arrayRefVar = new dataType[arraySize[ ];//同时完成了声明和创建两个操作

3.三种数组初始化方式

（1）静态初始化

例：

int[ ] nums = {1,2,3};

(2)动态初始化

例：

int[  ] nums = new int[5];

nums[0] = 1;

nums[1] = 2;

nums[2] = 3;

(3)默认初始化

例：

int[  ] nums = new int[3];//此时nums数组里均为默认值：0   不同类型的数组默认值不同

4.数组下标越界

数组下标从零开始，到数组长度-1结束。 数组长度可用 array.length获取。

若数组下标越界会出现该提示：ArrayIndexOutOfBoundsException 数组下标越界异常！

5.知识点

数组是相同数据类型(数据类型可以为任意类型)的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度的确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds

---

三、数组的使用

1.for-each 循环

public static void main(String[] args) {
	double[] myList = {1.9, 2.9, 3.4, 3.5};
		// 打印所有数组元素
	for (double element: myList) {
		System.out.println(element);
	}
}

2.数组作返回值

public static int[] nums(int[] nums){
    int[] a = new int[list.length];
    ……
    return a;//返回的a是一个数组
}

---

四、多维数组

相当于套娃（禁止套娃，滑稽）

比如二维数组就相当于一个特殊的一维数组，这个特殊的一维数组的数组元素都是由新的一维数组构成的

多维数组的定义：

int[][][] nums = new int[x][y][z];//三维数组的定义

多维数组的引用：

如nums[0][1]

获取数组长度:

array.length是获取二维数组的第一维的数组长度     array[0].length是获取第二维的数组长度

---

五、Arrays类

1、打印数组

public static void main(String[] args) {
	int[] a = {1,2};
	System.out.println(a); //[I@1b6d3586
	System.out.println(Arrays.toString(a)); //[1, 2]
}

2、数组排序

public static void main(String[] args) {
	int[] a = {1,2,323,23,543,12,59};
	System.out.println(Arrays.toString(a));//排序前
	Arrays.sort(a);//排序
	System.out.println(Arrays.toString(a));//排序后
}

3、二分法查找

public static void main(String[] args) {
	int[] a = {1,2,323,23,543,12,59};
	Arrays.sort(a); //使用二分法查找，必须先对数组进行排序
	System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));
}

如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

4、元素填充

public static void main(String[] args) {
	int[] a = {1,2,323,23,543,12,59};
	Arrays.sort(a); //使用二分法查找，必须先对数组进行排序
	Arrays.fill(a, 2, 4, 100); //将2到4索引的元素替换为100   [2,4)为左闭右开区间
	System.out.println(Arrays.toString(a));
}

---

六、常见排序算法

1、冒泡排序

public static int[] sort(int[] a1){
        int temp = 0;
        for (int i = 0; i < a1.length-1; i++) {
            int flag = 0;
            for (int j = 0; j < a1.length-i-1; j++) {
                if(a1[j+1]<a1[j]){
                    temp = a1[j];
                    a1[j] = a1[j+1];
                    a1[j+1] = temp;
                    flag = 1;
                }
            }
            if (flag == 0){
                break;
            }
        }
        return a1;
    }

​

2、选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到排序序列的末尾。

选择排序是不稳定的排序方法。

public int[] sort(int arr[]) {
	int temp = 0;
	for (int i = 0; i < arr.length - 1; i++) {// 认为目前的数就是最小的, 记录最小数的下标
		int minIndex = i;
		for (int j = i + 1; j < arr.length; j++) {
			if (arr[minIndex] > arr[j]) {// 修改最小值的下标
				minIndex = j;
			}
	}// 当退出for就找到这次的最小值,就需要交换位置了
	if (i != minIndex) {//交换当前值和找到的最小值的位置
		temp = arr[i];
		arr[i] = arr[minIndex];
		arr[minIndex] = temp;
	}
}
return arr;
}	

---

七、稀疏数组

理解例子即可

https://blog.csdn.net/baolingye/article/details/99943083