数组的基本操作
数组的基本操作
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开始计数，得“ - 插入点索引值”；
- 该搜索键在范围内，且是数组元素，由0开始计数，得搜索值的索引值；
- 该搜索键不在范围内，且小于范围（数组）内元素，返回–(fromIndex + 1)；
- 该搜索键不在范围内，且大于范围（数组）内元素，返回 –(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
