Java学习笔记（九）--数组及Arrays类

数组

数组是最为常见的一种数据结构，是相同类型的、用一个标识符封装到一起的基本类型数据序列或对象序列。

数组是具有相同数据类型的一组数据的集合。就是说数组中的每个元素具有相同的数据类型。在Java中将数组看作一个对象。

一、一维数组

1.1 创建一维数组

数组作为对象允许使用 new 关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。一维数组的创建有两种形式。

1、先声明，在用 new 运算符进行内存分配

声明以为数组有下列两种方式：

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

数组元素类型决定了数组的数据类型。它可以是Java中任意的数据类型，包括简单类型和组合类型。数组名是一个合法的标识符，符号 " [] " 指明该变量是一个数组类型变量。单个 “ [ ] ” 表示要创建的数组是一个一维数组。

声明数组后，还不能立即访问它的任何元素，因为声明数组只给出了数组名和元素的数据类型，使用数组还要为它分配内存空间。在为数组分配内存空间时必须指明数组的长度。为数组分配内存空间的语法格式如下：

数组名 = new 数组元素的类型[数组元素的个数];

数组名，即被连接到数组变量的名字。数组元素的个数，即指定数组中变量的个数，也就是数组的长度。

数组通过下标来区分数组中不同的元素。数组的下标是从0开始的。使用 new 关键字为数组分配内存时，整形数组中各个元素的初始值都为0。

2、声明数组的同时为数组分配内存

这种方法是将数组的声明和内存分配合在一起执行：

数组元素的类型[] 数组名字 = new 数组元素的类型[数组元素的个数];
数组元素的类型 数组名字[] = new 数组元素的类型[数组元素的个数];

例：以上面几种方式声明两个个长度为5的整型数组，并打印其初始值。

//先声明后分配内存
int[] array1,array2;	//同时声明两个数组
//相当于 int array1[],array2[];
array1 = new int[5];	//分配内存空间

/*声明数组的同时为数组分配内存
int[] array1 = new int[5];
int array2[] = new int[5];
*/
//for循环语句打印数组元素
for(int i = 0; i < 5; i++)
	System.out.println(array1[i]);
	
//使用for each 循环语句打印元素
for(int x : array2)
	System.out.println(x);

1.2 初始化一维数组

数组的初始化可分别初始化数组中的每个元素。创建并初始化数组有以下两种形式：

//一种初始化方式
int[] arr; //声明
int arr = new int[]{1,2,3,4,5};//初始化

//第二种初始化方式
int arr1[] = {1,2,3,4};//创建并初始化
//int[] arr1 = {1,2,3,4}

数组的初始化就是包括在大括号之内用逗号分开的表达式列表。用逗号分隔数组中的各元素，系统会自动为数组分配一定的空间。数组的大小就是初始值的个数。

数组初始化不能定义数组的长度，否则编译器会报错。

第一种方式可以在不创建新变量的情况下重新初始化一个数组。

int arr[];
int arr = new int[]{1,2,3,4,5};//初始化
int arr = new int[]{6,7,8,9,10};//重新初始化
/*相当于以下语句的简写
int arr[];
int arr = new int[]{1,2,3,4,5}; //初始化
int arr1[] = {6,7,8,9,10};//创建并初始化数组arr1
arr = arr1;
*/

在Java中允许数组的长度为0.在编写一个结果为数组的方法时，如果结果为空，则这种语法就显得非常有用。此时可以创建一个长度为0的数组：new 元素类型[0]。注意，数组长度为0与null不同。

1.3 使用一维数组

数组元素的访问可以通过下标访问。其范围从0~(数组长度-1)。

数组名[下标表达式];

下标表达式可以是一个整型常量，也可以是值为整型常量的表达式。

处理数组元素时，经常会用到for循环。Java中简便的for循环（foreach循环），可以不使用下标变量就可以顺序的遍历整个数组。

int[] arr = new int[]{1,2,3,4,5};//创建并初始化
arr[0] = 10;//访问arr数组的第一个元素并新赋值为10
//for循环语句打印数组元素
for(int i = 0; i < 5; i++)
	System.out.println(arr[i]);
	
//使用for each 循环语句打印元素
for(int x : arr)
	System.out.println(x);

1.4 数组拷贝

在Java中，允许将一个数组变量拷贝给另一个数组变量，这是两个变量将引用同一个数组：

int arr[];
int arr1[] = {6,7,8,9,10};//创建并初始化数组arr1
arr = arr1;
arr[4] = 12; //此时arr1[4]也变成了12
arr1[1] = 20;//此时arr[1]也变成了20

此方法不能将arr1引用的数组内容复制给arr，而是将arr1的引用值复制给了arr。它俩都指向同一个数组。

将一个数组的所有值拷贝到一个新数组中去，就要使用 Array 类的 copyOf() 方法：

int[] arr2 = Arrays.copyOf(arr1, arr1.length);

第一个参数是要拷贝的数组名；第二个参数是新素组的长度，常用来改变数组的大小。

如果数组元素是数值型，那么多余的元素将被赋值为0；如果数组元素是布尔型，则将赋值为false。相反，新数组的长度小于原始数组的长度，则只拷贝最前面的数据元素。

二、二维数组

如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。

2.1 二维数组的创建

下面是声明二维数组的语法：

数据类型[][] 数组名;
或者
数据类型 数组名[][];

对于高维数组，有两种为数组分配内存的方式。

(1)、直接为每一维分配内存空间

int[][] arr;
arr = new int[3][3];

(2)、分别为每一维分配内存

int[][] arr;
arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[3];
arr[2] = new int[3];

2.2 二维数组初始化

数据类型 数组名[][] = {value1,value2,...,valuen};

int[][] array = {{0,1},{9,2}}

2.3 使用二维数组

多维数组的引用方式为：

arrayName[index1][index2];

二维数组中使用两个下标，一个表示行，另一个表示列。

例：在项目中创建类Matrix，在主方法中实现输出一个3行3列且所有元素为0的矩阵。

public class Matrix {
	public static void main(String[] args) {
		int[][] arr;
		arr = new int[3][3];

		for(int i = 0; i < arr.length; i++)
		{
			for(int j = 0; j < arr[i].length; j++)
			{
				System.out.printf("%d ",arr[i][j]);
			}
			System.out.printf("\n");
		}
	}

}
/*输出结果为
0 0 0
0 0 0
0 0 0
*/

多维数组的创建方法与二维数组相似。

三、数组的基本操作

3.1 遍历数组

遍历数组就是获取数组中的每个元素。遍历数组一般使用for循环来实现。遍历一维数组很简单，遍历二维数组需要使用双层for循环，通过数组的length属性可以获得数组的长度。

例：在项目中创建类Matrix，在主方法中实现遍历输出一个3行3列且所有元素为0的矩阵。

第一种方式如上，现在我们使用for each循环语句遍历二维数组。

public class Matrix {
	public static void main(String[] args) {
		int[][] arr;
		arr = new int[3][3];

		for(int x[] : arr)
		{
			for(int y : x)
			{
				System.out.printf("%d ",y);
			}
			System.out.printf("\n");
		}
	}

}
/*输出结果为
0 0 0
0 0 0
0 0 0
*/

3.2填充替换数组元素

数组中的元素定义完成后，可以通过Arrays类的静态方法fill()来对数组中的元素进行替换。下面以int型数组为例：

1、fill(int[] a, int value)

该方法可以将指定的int值分配给int型数组的每个元素。

Arrays.fill(int[] a, int value);

• a：要进行元素替换的数组。
• value：要存储数组中所有元素的值。

import java.util.Arrays;
public class First {
	public static void main(String[] args) {
		int[] arr;
		arr = new int[4];
		Arrays.fill(arr, 2);
			for(int i = 0; i < arr.length; i++)
			{
				System.out.printf("%d ",arr[i]);
			}
	}

}
/*输出结果
2 2 2 2
*/

2、fill(int [] a, int fromIndex, int toIndex, int value)

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充范围从索引 fromIndex（包含）一直到索引 toIndex（不包含）。如果 fromIndex == toIndex，则填充范围为空。

Arrays.fill(int [] a, int fromIndex, int toIndex, int value)

• a：要进行填充的数组；
• fromIndex：要使用指定值填充的第一个元素索引（包括）；
• toIndex：要使用指定值填充的最后一个元素的索引（不包括）；
• value：要存储在数组所有元素中的值。

import java.util.Arrays;
public class First {
	public static void main(String[] args) {
		int[] arr;
		arr = new int[4];
		Arrays.fill(arr, 1,4，5);
			for(int i = 0; i < arr.length; i++)
			{
				System.out.printf("%d ",arr[i]);
			}
	}

}
/*输出结果
0 5 5 5
*/

3.3 对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort() 方法提供了多种重载方式，可对任意类型的数组进行升序排序。

Arrays.sort(object);

object是指进行排序的数组名称。

import java.util.Arrays;
public class First {
	public static void main(String[] args) {
		int[] arr;
		arr = new int[]{23,42,12,8,20};
		Arrays.sort(arr);
			for(int i = 0; i < arr.length; i++)
			{
				System.out.printf("%d ",arr[i]);
			}

	}

}
/*运行结果
8 12 20 23 42 
*/

Java中String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

3.4 复制数组

Arrays 类的 copyOf() 方法和 copyOfRange() 方法可以实现对数组的复制。

1、copyOf() 方法

copyOf() 方法是复制一个数组至指定长度的数组。

数据类型 数组名[] = Arrays.copyOf(arr, newlength);

• arr：要复制的数组；
• newlength：int型常量，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，则根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充；如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。

import java.util.Arrays;
public class First {
	public static void main(String[] args) {
		int[] arr;
		arr = new int[]{23,42,12,8,20};
		int[] newarr = Arrays.copyOf(arr, 7);
		
			for(int i = 0; i < newarr.length; i++)
			{
				System.out.printf("%d ",newarr[i]);
			}
	}

}
/*运行结果
23 42 12 8 20 0 0 
*/

2、copyOfRange() 方法

copyOfRange() 方法将指定数组的指定长度复制到一个新数组中。

copyOfRange(arr, int fromIndex, int toIndex)

• arr：要进行复制的数组对象；
• fromIndex：指定开始复制数组的索引位置。fromIndex 必须在0至整个数组长度之间。新数组包括索引是 fromIndex 的元素。
• toIndex：要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toIndex的元素。

import java.util.Arrays;
public class First {
	public static void main(String[] args) {
		int[] arr;
		arr = new int[]{23,42,12,8,20};
		int[] newarr = Arrays.copyOfRange(arr, 3,7);
		
			for(int i = 0; i < newarr.length; i++)
			{
				System.out.printf("%d ",newarr[i]);
			}
	}

}
/*运行结果
8 20 0 0 
*/

toIndex大于数组arr的长度，根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充；

新数组的长度等于toIndex 减去 fromIndex的值。

3.5 数组查询

Arrays 类的 binarySearch()方法，可使用二分法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。数组在调用此方法前必须排序好的。

1、binarySearch(Object[] a, Object key)

binarySearch(Object[] a, Object key)

• a：要搜索的数组；
• key：要搜索的值。
• 如果key包含在数组中，则返回搜索值的索引；否则返回“-x”。x是第一个大于key的元素索引值。如果key大于数组中的所有元素，x为a.length+1。

import java.util.Arrays;
public class First {
	public static void main(String[] args) {
		int[] arr;
		arr = new int[]{23,42,12,8,20};
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr, 13);
			for(int i = 0; i < arr.length; i++)
			{
				System.out.printf("%d ",arr[i]);
			}
			System.out.println(); //换行
			System.out.println(index);
	}

}
/*输出结果
8 12 20 23 42 
-3
*/

2、binarySearch(Object[] a, int fromIndex， int toIndex， Object key)

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

• a：要搜索的数组；
• fromIndex：指定范围的开始处索引（包含）；
• toIndex：指定范围的结束处索引（不包含）；
• key：要搜索的值。
• 如果key包含在数组中，则返回搜索值的索引；否则返回“-x”。x是第一个大于key的元素索引值。如果key大于数组中的所有元素，x为toIndex+1。

import java.util.Arrays;
public class First {
	public static void main(String[] args) {
		int[] arr;
		arr = new int[]{23,42,12,8,20};
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr, 1, 3, 50);
			for(int i = 0; i < arr.length; i++)
			{
				System.out.printf("%d ",arr[i]);
			}
			System.out.println(); //换行
			System.out.println(index);
	}

}
/*输出结果
8 12 20 23 42 
-4
*/