数组

创建一维数组

（1）先声明，再用new运算符进行内存分配

声明一维数组有两种方式：数组元素类型 数组名字[]; 数组元素类型[] 数组名字;
例如：int arr[]; String str[];
为数组分配内存空间时必须指明数组的长度，为数组分配内存空间的语法格式：
数组名字 = new 数组元素的类型[数组元素的个数];
例如：arr = new int[5];

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

数组元素类型 数组名字 = new 数组元素的类型[数组元素的个数];
例如：int month[] = new int [12];

初始化一维数组

主要有两种形式：
int arr[] = new int[]{1,2,3,4,5,25};
int arr2[] = {32,43,12,1};

使用一维数组

public class GetDay { // 创建类
	public static void main(String[] args) { // 主方法
		// 创建并初始化一维数组
		int day[]=new int[]{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
		for (int i = 0; i < 12; i++) { // 利用循环将信息输出
			System.out.println((i + 1) + "月有" + day[i] + "天"); // 输出的信息
		}
	}
}

创建二维数组

数组元素类型 数组名字[][];
数组元素类型[][] 数组名字;
例如：int myarr[][];

为数组分配内存：

（1）直接为每一维分配内存空间
a = new int[2][4];
（2）分别为每一维分配内存
a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];

二维数组初始化

type arrayname[][] = {value1,value2,…valuen};
例如：int myarr[][] = {{12,0},{45,3}};
可以直接给某个元素赋值：a[1][1] = 20;

使用二维数组

public class Matrix { // 创建类
	public static void main(String[] args) { // 主方法
		int a[][] = new int[3][4]; // 定义二维数组
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) { // 循环遍历数组中的每个元素
				System.out.print(a[i][j]); // 将数组中的元素输出
			}
			System.out.println(); // 输出空格
		}
	}
}

遍历数组

通常遍历数组使用for循环，通过数组的length属性可以获得数组的长度。
实例中实现了将二维数组中的元素呈梯形输出。

public class Trap { // 创建类
	public static void main(String[] args) { // 主方法
		int b[][] = new int[][]{{ 1 },{ 2, 3},{ 4, 5, 6 } };// 定义二维数组
		for (int k = 0; k < b.length; k++) {
			for (int c=0;c<b[k].length; c++){// 循环遍历二维数组中的每个元素
				System.out.print(b[k][c]); // 将数组中的元素输出
			}
			System.out.println(); // 输出空格
		}
	}
}

运行结果如图所示

遍历数组时，使用foreach语句可能会更简单。

public class Tautog { // 创建类
	public static void main(String[] args) { // 主方法
		int arr2[][] = { { 4, 3 }, { 1, 2 } }; // 定义二维数组
		System.out.println("数组中的元素是："); // 提示信息
		int i = 0;// 外层循环计数器变量
		for (int x[] : arr2) { // 外层循环变量为一维数组
			i++;// 外层计数器递增
			int j = 0;// 内层循环计数器
			for (int e : x) { // 循环遍历每一个数组元素
				j++;// 内层计数器递增
				if (i == arr2.length && j == x.length) { // 判断变量是二维数组中的最后一个元素
					System.out.print(e); // 输出二维数组的最后一个元素
				} else
					// 如果不是二维数组中的最后一个元素
					System.out.print(e + "、"); // 输出信息
			}
		}
	}
}

运行结果为：
数组中的元素是：
4、3、1、2

填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素替换。
（1）fill (int[] a,int value)
该方法可将指定的int值分配给int型数组的每个元素。
a：要进行元素替换的数组
value：要存储数组中所有元素的值
在项目中创建一维数组，并实现通过fill()方法填充数组元素，最后将各个元素输出。

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 + "个元素是：" + arr[i]);
		}
	}
}

运行结果如图

（2）fill (int[] a,int fromIndex,int toIndex,int value)
该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）一直到索引toIndex（不包括）。如果fromIndex=toIndex，则填充范围为空。
在项目中创建一维数组，并实现通过fill()方法填充数组元素，最后将各个元素输出。

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 + "个元素是：" + arr[i]);
		}
	}
}

运行结果如图

对数组进行排序

通过Array类的静态sort()方法可以实现对数组排序
Arrays.sort(object)
object是指进行排序的数组名称

import java.util.*;

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]); // 将排序后数组中的各个元素输出
		}
	}
}

运行结果如图

数字排在字母前面，大写字母排在小写字母前面。

复制数组

（1）copyOf()方法：复制数组至指定长度
copyOf(arr,int newlength)
arr：要进行复制的数组
newlength：int型常量，指复制后的新数组的长度。如果newlength大于数组arr的长度，则用0填充（整型数组用0填充，char型数组用null填充）；如果newlength小于数组arr的长度，则从arr的第一个元素开始截取至满足新数组长度为止。

import java.util.*;

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]); // 将新数组输出
		}
	}
}

运行结果如图

（2）copyOfRange()方法：将指定数组的指定长度复制到一个新数组中
copyOfRange(arr,int fromIndex,int toIndex)

import java.util.*;

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]); // 将新数组中的每个元素输出
		}
	}
}

运行结果如图

数组查询

（1）binarySearch(Object[] a,Object key)
a：要搜索的数组
key：要搜索的值
如果key包含在数组中，则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。

int arr[] = new int[]{4,25,10};             //创建并初始化数组
Arrays.sort(arr);                           //将数组进行排序
int index = Array.binarySearch(arr,0,1,8);

上述代码中变量index的值是元素“8”在数组arr中索引在0~1内的索引位置。由于在指定范围内并不存在“8”，index的值是“-”（插入点）。如果对数组进行排序，元素“8”应该在“25”的前面，因此插入点应是元素“25”的索引值2，所以index的值为-2。
在进行查询之前必须先进行排序（用sort()方法），否则结果是不确定的。
在主方法中创建一维数组ia，实现查找元素4在数组ia中的索引位置。

import java.util.*;

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
注意，索引位置为1是排序后的结果
（2）binarySearch(Object[] a,int fromIndex,int toIndex,Object key)
在主方法中创建String数组，实现查找元素“cd”在指定范围的数组str中的索引位置。

import java.util.*;

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