【Java基础】Java的数组

一、数组的创建和属性

数组是一种有序数据的集合，数组中的每个元素具有相同的数据类型，Java 中有基本数据类型和引用数据类型两种数据类型。数组就是引用数据类型。,可以用一个统一的数组名和不同的下标来唯一确定数组中的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。

1.一维数组的创建：

首先说一下要想创建一个一维数组需要两步：

• 1.声明一个数组
• 2.分配空间

我们先说第一点，声明数组，声明数组有两种格式：

这里我们看一下数据类型+数组名+[],这里面，数据类型可以是:

• 基本数据类型
• 也可以是引用数据类型

然后数组名可以是任意合法的变量名
[],这个标志就是说明它是一个一维数组

大多数Java程序员喜欢用第二种格式，因为它可以把数据类型和变量名字用[]，清晰的分开。

注意点：

• 1.声明数组的时候，不需要规定数组的长度，例如：
  int socre[10],这样写是错误的
• 2.在声明数组的时候，千万不要忘记写[],这个标识。

我们再说第二点分配空间：
声明了数组，只是得到了一个存放数组的变量，并没有为数组元素分配内存空间，是不能够去使用的，因此我们要为数组分配内存空间，这样数组的每一个元素才能够进行存储。

我们来看一下分配内存的格式:

当然啦，我们在工作中，通常声明一个数组，不会分为两步，可以直接一步到位，声明加分配空间，格式是这样的：

一维数组的内存格式：

其实声明和分配空间之后，还有一步初始化数组，这里有三种方式：
注意：第二种方式中，[],里面不能写数值。

获取单个元素

获取单个元素的方法非常简单，指定元素所在数组的下标即可

1.	int[] number={1,2,3,5,8};
2.	System.out.println("获取第一个元素："+number[0]);
3.	System.out.println("获取最后一个元素："+number[number.length-1]);
4.	输出结果为：
5.	获取第一个元素：1
    获取最后一个元素：8
    

获取全部元素

获取全部元素——使用循环语句。
下面利用 for 循环语句遍历 number 数组中的全部元素，并将元素的值输出。代码如下：

1.	int[] number={1,2,3,5,8};
2.	for (int i=0;i<number.length;i++)
3.	{
4.	    System.out.println("第"+(i+1)+"个元素的值是："+number[i]);
5.	}
这里的for循环也可以换成增强for循环输出：
6.	for(int val:number)
7.	{
8.	    System.out.print("元素的值依次是："+val+"\t");
9.	}
int是变量类型，val是变量名字，number是数组名字。	

2.二维数组的创建：

为了方便组织各种信息，计算机常将信息以表的形式进行组织，然后再以行和列的形式呈现出来。
二维数组的结构决定了其能非常方便地表示计算机中的表：

• 第一个下标表示元素所在的行
• 第二个下标表示元素所在的列

下面简单了解一下二维数组，包括数组的声明和初始化。

声明二维数组的语法如下：

这里提供两种初始化的方法：

上述代码创建了一个二行二列的二维数组 temp，并对数组中的元素进行了初始化。图 1 所示为该数组的内存结构。

图1 二维数组内存结构

获取单个元素

获取单个元素的方法非常简单，指定元素所在数组的下标即可

1.	public static void main(String[] args)
2.	{
3.	    double[][] class_score={{10.0,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5}};
4.	    System.out.println("第二行第二列元素的值："+class_score[1][1]);
5.	    System.out.println("第四行第一列元素的值："+class_score[3][0]);
6.	}
执行上述代码，输出结果如下：
第二行第二列元素的值：98.0
第四行第一列元素的值：99.5

获取全部元素

如果要获取二维数组中的全部元素，最简单、最常用的办法就是使用 for 语句。

1.	public static void main(String[] args)
2.	{
3.	    double[][] class_score={{100,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5 }};
4.	    for(int i=0;i<class_score.length;i++)
5.	    {    //遍历行
6.	        for(int j=0;j<class_score[i].length;j++)
7.	        {
8.	            System.out.println("class_score["+i+"]["+j+"]="+class_score[i][j]);
9.	        }
10.  }
11.  }
执行上述代码，输出结果如下所示。
class_score[0][0]=100.0
class_score[0][1]=99.0
class_score[0][2]=99.0
class_score[1][0]=100.0
class_score[1][1]=98.0
class_score[1][2]=97.0
class_score[2][0]=100.0
class_score[2][1]=100.0
class_score[2][2]=99.5
class_score[3][0]=99.5
class_score[3][1]=99.0
class_score[3][2]=98.5

上述代码使用嵌套 for 循环语句输出二维数组。在输出二维数组时，第一个 for 循环语句表示以行进行循环，第二个 for 循环语句表示以列进行循环，这样就实现了获取二维数组中每个元素的值的功能。

3.数组的长度属性：

用数组名.length可以获取数组的长度。

因为数组索引是由0开始的，所以数组最大的索引值为数组名.length-1。

4.比较两个数组是否相等：

数组相等的条件不仅要求数组元素的个数必须相等，而且要求对应位置的元素也相等。Arrays 类提供了 equals() 方法比较整个数组。语法如下：
Arrays.equals(arrayA, arrayB);
举个例子：

5.复制数组的方法：

所谓复制数组，是指将一个数组中的元素在另一个数组中进行复制。
使用 copyOf() 方法和 copyOfRange() 方法
Arrays 类的 copyOf() 方法与 copyOfRange() 方法都可实现对数组的复制。copyOf() 方法是复制数组至指定长度，copyOfRange() 方法则将指定数组的指定长度复制到一个新数组中。

1. 使用 copyOf() 方法对数组进行复制

Arrays 类的 copyOf() 方法的语法格式如下：

Arrays.copyOf(dataType[] srcArray,int length);

其中，(dataType[] srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度。

使用这种方法复制数组时，默认从源数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。如果 length 大于 srcArray.length，则目标数组中采用默认值填充；如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。
举个例子：

在上述代码中，由于源数组 scores 的长度为 5，而要复制的新数组 newScores 的长度为 8，因此在将源数组中的 5 个元素复制完之后，会采用默认值填充剩余 3 个元素的内容。

2.使用 CopyOfRange() 方法对数组进行复制

Arrays 类的 CopyOfRange() 方法是另一种复制数组的方法，其语法形式如下：

Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)

其中，srcArray 表示源数组；startIndex 表示开始复制的起始索引，目标数组中将包含起始索引对应的元素，另外，startIndex 必须在 0 到 srcArray.length 之间；endIndex 表示终止索引，目标数组中将不包含终止索引对应的元素，endIndex 必须大于等于 startIndex，可以大于 srcArray.length，如果大于 srcArray.length，则目标数组中使用默认值填充。

举个例子：

6.数组查找指定元素：

从数组中查询指定位置的元素，或者查询某元素在指定数组中的位置。使用 Arrays 类的 binarySearch() 方法可以实现数组的查找，该方法可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。

有两种方式查找：
第一种形式如下：

binarySearch(Object[] a,Object key);

其中，a 表示要搜索的数组，key 表示要搜索的值。如果 key 包含在数组中，则返回搜索值的索引；否则返回 -1 或“-插入点”。插入点指搜索键将要插入数组的位置，即第一个大于此键的元素索引。

在进行数组查询之前，必须对数组进行排序（可以使用 sort() 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法确认找到的是哪一个。

举个例子：

声明 double 类型的 score 数组，接着调用 Arrays 类的 sort() 方法对 score 数组排序，排序后分别查找数组中值为 100 和 60 的元素，分别将结果保存到 index1 和 index2 变量中，最后输出变量的值。代码如下：

第二种形式如下：

binarySearch(Object[] a,int fromIndex,int toIndex,Object key);

其中，a 表示要进行查找的数组，fromIndex 指定范围的开始处索引（包含开始处），toIndex 指定范围的结束处索引（不包含结束处），key 表示要搜索的元素。

**在使用 binarySearch() 方法的上述重载形式时，也需要对数组进行排序，**以便获取准确的索引值。如果要查找的元素 key 在指定的范围内，则返回搜索键的索引；否则返回 -1 或 “-插入点”。插入点指要将键插入数组的位置，即范围内第一个大于此键的元素索引。
举个例子：

这里的-3，因为60没找到，然后我们从第二个位置开始找的，那就第二个位置为基准0，往前是-1，-2，而60比-1位置上的85.5还小，故，它应该放在-3的位置，所以，这里得到-3

7.数组填充：

Arrays 类提供了一个 fill() 方法，可以在指定位置进行数值填充。fill() 方法虽然可以填充数组，但是它的功能有限制，只能使用同一个数值进行填充。语法如下：

Arrays.fill(array,value);

其中，array 表示数组，value 表示填充的值。

举个例子：

8.数组转为字符串：

Arrays.toString(type[] a)方法：
该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。
例如：

只不过转为的字符串形式，是个数组的模样的形式。

二、数组的排序

1.sort() 方法排序

使用 Armys.sort(数组名) 语法对数组进行排序，排序规则是从小到大，即升序。
举个例子：

2.冒泡排序（Bubble Sort）

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

冒泡排序的算法比较简单，排序的结果稳定，但时间效率不太高。Java 中的冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。
举个例子：

3.快速排序（Quicksort）

快速排序（Quicksort）是对冒泡排序的一种改进。

快速排序的基本思想是：通过一趟排序，将要排序的数据分隔成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。

具体做法是：假设要对某个数组进行排序，首先需要任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它的前面，所有比它大的数都放到它的后面。这个过程称为一趟快速排序；递归调用此过程，即可实现数据的快速排序。

举个例子：

import java.util.Arrays;

public class test2 {
	public static void main(String[] args) {
		int[] arr = new int[] { 5, 2, 6, 8, 7, 9 };
		quickSort(arr, 0, arr.length - 1);
		System.out.println(Arrays.toString(arr));

	}

	public static void quickSort(int arr[], int left, int right) {
		// 递归要求第一步写结束递归的条件
		if (left > right) {
			return;
		}
		// 设置基准值是arr[0]
		int base = arr[left];
		// 保留left和right目的保证下面的递归能正确找到相应位置
		int i = left;
		int j = right;
		// 经行位置移动
		while (i != j) {
			// 从右往左寻找比基准小的值的下标
			while (arr[j] >= base && i < j) {
				j--;
			}
			// 从左往右寻找比基准大的值的下标
			while (arr[i] <= base && i < j) {
				i++;
			}
			if (i < j) {
				// 将找到的比基准数大的数和比基准数小的数交换
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
		// 最后将原来的基准数和当前的i==j索引值进行交换
		arr[left] = arr[i];
		arr[i] = base;
		System.out.println(Arrays.toString(arr));
		// 按照刚刚思想，基数两边继续递归
		quickSort(arr, left, i - 1);
		quickSort(arr, j + 1, right);
	}
}

4.选择排序

选择排序是指每一趟从待排序的数据元素中选出最大（或最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

选择排序原理为：随机确定一个标志位（一般为第一个数字）作为最小数，然后向后遍历，找到比标志位更小的数便与标志位互换位置并更新最小数，实现步骤为：

• 将数组的第一个数字设置为标志位最小数并记录最小数下标。
• 向后遍历，发现更小数后将该数与标志位互换位置并更新最小数与最小数下标。
• 循环完成排序

举个例子：

public static void main(String[] args){
    int int[] arr = new int[]{1,6,8,9,2,3,5,4,7};
    for(int i=0;i<arr.length-1;i++){//每次循环都会找出最小的数
            int minIndex = i;//记录最小数的下标
            int minNum = arr[i];//记录最小数
            for(int j=i+1;j<arr.length;j++){//每次循环都会找出最小的数
                if(arr[j]<minNum){//如果当前数比最小数小，则更新最小数
                    minNum = arr[j];//更新最小数
                    minIndex = j;//更新最小数的下标
                }
            }
            arr[minIndex]=arr[i];//将最小数放到最前面
            arr[i]=minNum;//将标志位放到最小数原来所在的位置
        }
    
    for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
}

5.直接插入排序

直接插入排序的基本思想是：将 n 个有序数存放在数组 a 中，要插入的数为 x，首先确定 x 插在数组中的位置 p，然后将 p 之后的元素都向后移一个位置，空出 a§，将 x 放入 a§，样可实现插入 x 后仍然有序。

举个例子：

int[] arr={3,2,5,1,4};
for (int i=1;i<arr.length ;i++ )
	{
		int index = arr[i];//先把操作数取出来
		int insertNum = i;//假设要插入的位置是当前位置
		for(int j = i-1;j>=0;j--){
				if(arr[j]>index){
				arr[j+1]=arr[j];//后移，给操作数腾位置
				insertNum=j;//记录当前位置
				}
				if(insertNum!=i){
				arr[insertNum]=index;//将操作数插入到排好序的位置
				}
			}
		}
	System.out.println(Arrays.toString(arr));

总结

各位小主，如果感觉有一点点帮助到你的话，麻烦留下赞赞一枚哦~