数组的基本操作

数组的基本操作

---

1.数组的创建

1.一维数组的创建

声明：

int arr[];      //方式一
int[] arr2;    //方式二

分配内存：

arr = new int[5];   //创建有5个元素的整型数组，下标为0~4

也可在声明数组的同时为数组分配内存：

int arr[] = new int[5]

数组的初始化：

int arr[] = new int[]{1,2,3,4,5};   //方式一
int arr2[] = {6,7,8,9}      //方式二

2.二维数组的创建

声明：

int arr[][];      //方式一
int[][] arr2;    //方式二

分配内存：

//方式一：直接为每一维分配内存空间
a = new int[2][4];  
//方式二：分别为每一维分配内存
a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];

也可在声明数组的同时为数组分配内存：

int arr[][] = new int[5][2]

数组的初始化：

int arr[][] = {{1,2,3},{4,5,6}};      //方式二

2.遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现，但使用foreach语句可能会更简单，以下以遍历二维数组来举例。
例：

public class Trap {	//创建类

	public static void main(String[] args) {	//主方法
		int arr[][] = {{1,2},{3,4}};		//定义二维数组
		System.out.print("使用 for循环遍历数组：");	//提示信息
		for(int i=0;i<arr.length;i++){		//循环遍历二维数组中的每一个元素
			for(int j=0;j<arr[i].length;j++){
				System.out.print(arr[i][j]+" ");	//将数组中的元素输出
			}
		}
		System.out.println();		//换行
		System.out.print("使用 foreach语句遍历数组：");	//提示信息
		for(int x[]:arr){		//将外层循环变量变为一维数组
			for(int e:x){		//循环遍历每一个数组元素
				System.out.print(e+" ");		//将数组中的元素输出
			}
		}

	}

}

运行结果：
使用 for循环遍历数组：1 2 3 4
使用 foreach语句遍历数组：1 2 3 4

3.填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类型的数组元素的替换。

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

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

import java.util.*;

public class Swap { // 创建类
	public static void main(String[] args) { // 主方法
		int arr[] = new int[5]; // 创建int型数组
		Arrays.fill(arr, 8); // 使用同一个值对数组进行填充
		for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
			// 将数组中的元素依次输出
			System.out.println("第" + (i+1) + "个元素是：" + arr[i]);
		}
	}
}

运行结果：
第1个元素是：8
第2个元素是：8
第3个元素是：8
第4个元素是：8
第5个元素是：8

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

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

若指定的索引位置大于或等于要进行填充的数组长度则会报出异常

例：

import java.util.*;

public class Displace { // 创建类
	public static void main(String[] args) { // 主方法
		int arr[] = new int[] { 45, 12, 2, 10 }; // 定义并初始化int型数组arr
		Arrays.fill(arr, 1, 2, 8); // 使用fill方法对数组进行初始化
		for (int i = 0; i < arr.length; i++) { // 循环遍历数组中元素
			// 将数组中的每个元素输出
			System.out.println("第" + (i+1) + "个元素是：" + arr[i]);
		}
	}
}

运行结果：
第1个元素是：45
第2个元素是：8
第3个元素是：2
第4个元素是：10

4.对数组进行排序

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

语法：

Arrays.sort(object)     //object为进行排序的数组名称

例：

import java.util.Arrays;    //导入java.util.Arrays类

public class Taxis { // 创建类
	public static void main(String[] args) { // 主方法
		int arr[] = new int[] { 23, 42, 12, 8 }; // 声明数组
		Arrays.sort(arr); // 将数组进行排序
		for (int i = 0; i < arr.length; i++) { // 循环遍历排序后的数组
			System.out.println(arr[i]); // 将排序后数组中的各个元素输出
		}
	}
}

运行结果：
8
12
23
42

上述实例是对整型数组进行排序。Java中String类型数组的排序算法是根据字典编排顺序进项排序，因此数字排在字母前面，大写字母排在小写字母前面。

5.复制数组

Arraya类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

1.copyOf()方法

该方法提供了多种重载方法，用于满足不同类型数组的复制。

语法：

copyOf(arr,int newlength)

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

例：

import java.util.Arrays;    //导入java.util.Arrays类

public class Cope { // 创建类
	public static void main(String[] args) { // 主方法
		int arr[] = new int[] { 23, 42, 12, }; // 定义数组
		int newarr[] = Arrays.copyOf(arr, 5); // 复制数组arr
		for (int i = 0; i < newarr.length; i++) { // 循环变量复制后的新数组
			System.out.println(newarr[i]); // 将新数组输出
		}
	}
}

运行结果：
23
42
12
0
0

2.copyOfRange()方法

该方法同样提供了多种重载形式

语法：

copyOfRange(arr,int formIndex,int toIndex)

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

例：

import java.util.Arrays;    //导入java.util.Arrays类

public class Repeat { // 创建类
	public static void main(String[] args) { // 主方法
		int arr[] = new int[] { 23, 42, 12, 84, 10 }; // 定义数组
		int newarr[] = Arrays.copyOfRange(arr, 0, 3); // 复制数组
		for (int i = 0; i < newarr.length; i++) { // 循环遍历复制后的新数组
			System.out.println(newarr[i]); // 将新数组中的每个元素输出
		}
	}
}

运行结果：
23
42
12

6.数组查询

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。

1.binarySearch(Object[], Object key)

语法：

binarySearch(Object[] a, Object key)

a: 要搜索的数组
key：要搜索的值
如果key在数组中，则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是索引键将要插入数组的那一点，即第一个大于该键的元素的索引。
在使用该方法前要对数组进行排序。

例：

import java.util.Arrays;    //导入java.util.Arrays类

public class Example { // 创建类
	public static void main(String[] args) { // 主方法
		int ia[] = new int[] { 1, 8, 9, 4, 5 }; // 定义int型数组ia
		Arrays.sort(ia); // 将数组进行排序
		int index = Arrays.binarySearch(ia, 4); // 查找数组ia中元素4的索引位置
		System.out.println("4的索引位置是：" + index); // 将索引输出
	}
}

运行结果：
4的索引位置是：1

2. binarySearch(Object[], int fromIndex, int toIndex, Object key)

a：要搜索的数组
fromIndex：指定范围的开始处索引（包含）
toIndex：指定范围的结束处索引（不包含）
key：要搜索的值
在使用该方法前同样要对数组进行排序，来获得准确的索引值。如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或“-”（插入点）。如果范围中的所有元素都小于指定的键，则为toIndex
技巧：

1. 该搜索键在范围内，但不是数组元素，由1开始计数，得“ - 插入点索引值”；
2. 该搜索键在范围内，且是数组元素，由0开始计数，得搜索值的索引值；
3. 该搜索键不在范围内，且小于范围（数组）内元素，返回–(fromIndex + 1)；
4. 该搜索键不在范围内，且大于范围（数组）内元素，返回 –(toIndex + 1)。

例：

import java.util.Arrays;    //导入java.util.Arrays类

public class Rakel { // 创建类
	public static void main(String[] args) { // 主方法
		// 定义String型数组str
		String str[] = new String[] { "ab", "cd", "ef", "yz" };
		Arrays.sort(str); // 将数组进行排序
		// 在指定的范围内搜索元素"cd"的索引位置
		int index = Arrays.binarySearch(str, 0, 2, "cd");
		System.out.println("cd的索引位置是：" + index); // 将索引输出
	}
}

运行结果：
cd的索引位置是：1