数组（Array）：是多个相同类型的数据按一定顺序排列的集合。
特点：（1）数组是有序排列的；（2）数组属于引用数据类型的变量。数组中的元素可以是基本数据类型，也可以是引用数据类型；（3）数组对象在内存中占一整块连续的空间；（4）数组的长度一旦确定就不能修改。
一. 一维数组
public class Test{
public static void main(String[] args) {
//1. 数组的初始化
//生成一个int型的数组
int[] age = new int[]{18,19,20,21,22}; //静态初始化：数组的初始化和数组元素的赋值同时进行
//生成一个String型的数组
String[] name = new String[5]; //动态初始化：数组的初始化和数组元素的赋值分开进行
//2. 调用数组指定位置的元素(数组的索引是从0开始)
name[0] = "王";
name[1] = "杨";
name[2] = "刘";
name[3] = "张";
name[4] = "赵";
System.out.println(age[0]); //18
System.out.println(name[1]); //杨
//3. 获取数组的长度
System.out.println(name.length); //5
System.out.println(age.length); //5
//4. 遍历数组元素
for(int i = 0; i < name.length; i++){
System.out.println(name[i]);
}
//5. 数组元素的默认初始化值
int[] array1 = new int[4];
System.out.println(array1); //结果是指向数组array1的地址
System.out.println(array1[0]); //数组是整型：0
double[] array2 = new double[4];
System.out.println(array2); //结果是指向数组array2的地址
System.out.println(array2[0]); //数组是浮点型：0.0
boolean[] array3 = new boolean[4];
System.out.println(array3[0]); //数组是布尔型：false
String[] array4 = new String[4];
System.out.println(array4[0]); //数组是字符串类型：null
}
}
二. 二维数组
public class Test{
public static void main(String[] args) {
//1. 二维数组的初始化
//生成一个int型的数组
int[][] age = new int[][]{{5,6,7,8},{18,19,20},{40,41}}; //静态初始化：数组的初始化和数组元素的赋值同时进行
//生成一个String型的数组
String[][] name1 = new String[3][2]; //动态初始化1：内层元素的个数固定为2，name1 = [[2个元素],[2个元素],[2个元素]]
String[][] name2 = new String[3][]; //动态初始化2：内层元素的数量不固定
//2. 调用数组指定位置的元素(数组的索引是从0开始)
System.out.println(age[1][2]); //20
name1[0][0] = "王";
name1[0][1] = "杨";
name1[1][0] = "刘";
name1[1][1] = "张";
name1[2][0] = "金";
name1[2][1] = "朱";
System.out.println(name1[1][0]); //刘
name2[0] = new String[3];
name2[1] = new String[4];
name2[2] = new String[2];
//以上的形式相当于name2 = [[3个元素],[4个元素],[2个元素]]
name2[1][1] = "杨";
System.out.println(name2[1][1]); //杨
//3. 获取数组的长度
System.out.println(age.length); //3
System.out.println(age[0].length); //4
System.out.println(age[2].length); //2
//4. 遍历数组元素
for(int i = 0; i < age.length; i++){
for(int j = 0; j < age[i].length; j++){
System.out.print(age[i][j] + " ");
}
System.out.println();
}
//5. 数组元素的默认初始化值：(1)动态初始化1：外层元素为地址，内层元素与一维数组相同；(2)动态初始化2：外层元素为null，内层元素会报错
int[][] array1 = new int[4][3];
System.out.println(array1); //结果是指向二维数组array1的地址
System.out.println(array1[0]); //结果是指向一维数组array1[0]的地址
System.out.println(array1[0][0]); //数组是整型：0
double[][] array2 = new double[4][3];
System.out.println(array2); //结果是指向二维数组array2的地址
System.out.println(array2[0]); //结果是指向一维数组array2[0]的地址
System.out.println(array2[0][0]); //数组是浮点型：0.0
boolean[][] array3 = new boolean[4][3];
System.out.println(array3[0][0]); //数组是布尔型：false
String[][] array4 = new String[4][3];
System.out.println(array4[0][0]); //数组是字符串类型：null
double[][] array5 = new double[4][];
System.out.println(array5[0]); //null，不管声明为什么类型的数组，都为null
//System.out.println(array5[0][0]); //报错
}
}
三. 数组复制
public class Test{
public static void main(String[] args) {
int[] array1 = new int[]{5,6,7,8};
int[] array2;
array2 = array1; //不能实现数组的复制
array2[0] = 13;
System.out.println(array1[0]); // array1[0] = 13，堆中只有一个数组，array2 = array1是将array1的地址赋值给array2
//数组的复制
int[] array3 = new int[]{5,6,7,8};
int[] array4 = new int[array3.length];
for(int i = 0; i < array3.length; i++){
array4[i] = array3[i];
}
}
}
四. 查找
1. 线性查找
public class Test{
public static void main(String[] args) {
String[] array = new String[]{"A","B","C","D","E","F"};
String index = "B";
for(int i = 0; i < array.length; i++){
if(index.equals(array[i])){
System.out.println(i);
break;
}
}
}
}
2. 二分法查找
public class Test{
public static void main(String[] args) {
int[] array = new int[]{5,12,13,18,22,24,28,32};
int index = 22;
int head = 0;
int end = array.length;
while(head <= end){
int middle = (head + end)/2;
if(array[middle] == index){
System.out.println(middle);
break;
}else if(array[middle] > index){
end = middle - 1;
}else if(array[middle] < index){
head = middle + 1;
}
}
}
}
五. 排序
冒泡排序
public class Test{
public static void main(String[] args) {
int[] array = new int[]{97,15,85,64,22,53,46,25,18,32};
for(int i = 0; i < array.length - 1; i++){
for(int j = 0; j < array.length - 1 - i; j++){
if(array[j] > array[j + 1]){
int temp = array[j+1];
array[j+1] = array[j];
array[j] = temp;
}
}
}
for(int i = 0; i < array.length; i++){
System.out.print(array[i] + " ");
}
}
}
六. Arrays类
举例：以下的数据类型可以是任意的
1. 判断两个数组是否相等：Arrays.equals(int[] a, int[] b)
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] array1 = new int[]{18,19,20,21,22};
int[] array2 = new int[]{18,19,20,21,22};
int[] array3 = new int[]{19,18,20,21,22};
System.out.println(Arrays.equals(array1,array2)); //true
System.out.println(Arrays.equals(array1,array3)); //false
}
}
2. 输出数组信息：Arrays.toString(int[] a)
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] array = new int[]{18,19,20,21,22};
System.out.println(Arrays.toString(array)); //[18, 19, 20, 21, 22]
}
}
3. 对数组进行排序：Arrays.sort(int[] a)
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] array = new int[]{97,15,85,64,22,53,46,25,18,32};
Arrays.sort(array);
System.out.println(Arrays.toString(array)); //[15, 18, 22, 25, 32, 46, 53, 64, 85, 97]
}
}
4. 二分查找：Arrays.binarySearch(int[] a, int key)
import java.util.Arrays;
public class Test{
public static void main(String[] args) {
int[] array = new int[]{15, 18, 22, 25, 32, 46, 53, 64, 85, 97};
int index = Arrays.binarySearch(array, 22);
System.out.println(index); //2
}
}
