java入门 -- 数组

1 数组

1.1 什么是数组

▪ 数组（Array）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 这些有序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。
-----来自百度百科

1.2 数组的分类

▪ 一维数组
▪ 二维数组(矩阵)
▪ 多维数组

1.3 数组的注意点

▪ 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
▪ 数组中的所有元素都具有相同类。数组中的元素存储在一个连续性的内存块中，并通过索引来访问。索引从0开始
▪ 数组的长度一旦确定，就不能修改。

2 一维数组

2.1 一维数组的声名

▪ type var[] 或 type[] var；

例如 ：

int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组

注意数组声名时不能指定他的长度

2.2 一维数组的初始化

//方法一
int[] arr = new int [10];
> ▪ 初始化了一个长度为10的int型数组；
//方法二
int [] arr1=new int[] {10,5,8,9};
> ▪ 初始化了一个长度为4的，地址从0-1分别为10，5，8，9 的数组。
//方法三
double price [] = {5.2,5,7,9};
> ▪ []的位置改变不影响数组的初始化。

2.3 一维数组的引用

数组元素的引用方式：数组名[数组元素下标]
例如：arr1 [4]
每个数组都有一个属性length指明它的长度，例如：arr1.length 指明数组arr1的长度(元素个数).
数组一旦确定，其长度也就确定，要想改变其长度必须进行扩充。

2.4 一维数组的遍历

注意数组的显示只能通过遍历，不能通过System.out.println(arr1);==
注意
System.out.println(arr1)
System.out.println(arr1[3])

int [] arr1=new int[] {10,5,8,9};
		for(int i=0;i<arr1.length;i++) {
			System.out.print(arr1[i]+",");
		}	
		System.out.println();
		System.out.print(arr1[3]);

结果：

3 二维数组

3.1 二维数组的声名及初始化

▪ 类型说明符 数组名 [常量表达式1][常量表达式2]…；
▪ 其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度。
▪ 格式1： int[][] arr = new int[3][];
▪ 格式2： int[][] arr = new int[3][4];
▪ 格式3： int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
▪ 格式4： int arr[][] ={{3,8},{2,7}};
▪ 二维数组不一定是矩阵形式。
▪ int a[3][4]; 说明了一个三行四列的数组，数组名为a，其下标变量的类型为整型。该数组的下标变量共有3×4个，即：
a[0][0],a[0][1],a[0][2],a[0][3]
a[1][0],a[1][1],a[1][2],a[1][3]
a[2][0],a[2][1],a[2][2],a[2][3]

注意 int[][]arr = new int[][3]; //非法

3.2 二维数组的遍历

二维数组的遍历需要通过双重for循环

int[][] arr = new int[][]{{3,8,2},{2,7,9},{9,0,1}};
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				System.out.print(arr[i][j]);
				
			}
			System.out.println();
		}

用双for循环不能很好的输出非矩阵形式的二维数组

4 三维数组

三维数组，是指维数为三的数组结构。三维数组是最常见的多维数组，由于其可以用来描述三维空间中的位置或状态而被广泛使用。
三维数组就是维度为三的数组，可以认为它表示对该数组存储的内容使用了三个独立参量去描述，但更多的是认为该数组的下标是由三个不同的参量组成的。
数组这一概念主要用在编写程序当中，和数学中的向量、矩阵等概念有一定的差别，主要表现：在数组内的元素可以是任意的相同数据类型，包括向量和矩阵。
对数组的访问一般是通过下标进行的。在三维数组中，数组的下标是由三个数字构成的，通过这三个数字组成的下标对数组的内容进行访问。

int[][][] arr = new int[3][][];
        arr[0] = new int[3][];
         
        arr[0][0] = new int[2];
        arr[0][0][0] = 1111;
        arr[0][0][1] = 1112;
         
        arr[0][1] = new int[2];
        arr[0][1][0] = 1121;
        arr[0][1][1] = 1122;
         
        arr[0][2] = new int[3];
        arr[0][2][0] = 1131;
        arr[0][2][1] = 1132;
        arr[0][2][2] = 1133;
         
        arr[1] = new int[3][];
        arr[1][0] = new int[2];
        arr[1][0][0] = 1211;
        arr[1][0][1] = 1212;
         
        arr[1][1] = new int[2];
        arr[1][1][0] = 1221;
        arr[1][1][1] = 1222;
         
        arr[1][2] = new int[2];
        arr[1][2][0] = 1231;
        arr[1][2][1] = 1232;
         
        arr[2] = new int[3][];
        arr[2][0] = new int[2];
        arr[2][0][0] = 1311;
        arr[2][0][1] = 1312;
         
        arr[2][1] = new int[2];
        arr[2][1][0] = 1321;
        arr[2][1][1] = 1322;
         
        arr[2][2] = new int[2];
        arr[2][2][0] = 1331;
        arr[2][2][1] = 1332;
         
         
        for (int[][] a2 : arr) {
            for (int[] a1 : a2) {
                for (int a: a1) {
                    System.out.print(a + "\t");
                }
                System.out.println();
            }
        }
         
    }

三位数组可以理解为在立方体中添加数字。

5 Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比
如排序和搜索）的各种方法。

项目	Value
boolean equals(int[] a,int[] b)	判断两个数组是否相等。
String toString(int[] a)	输出数组信息。
void fill(int[] a,int val)	将指定值填充到数组之中。
void sort(int[] a)	对数组进行排序。
int binarySearch(int[] a,int key)	对排序后的数组进行二分法检索指定的值。

6 二分查找算法

6.1 基本思想

▪ 1. 如果待查序列为空，那么就返回-1，并退出算法；这表示查找不到目标元素。
▪ 2. 如果待查序列不为空，则将它的中间元素与要查找的目标元素进行匹配，看它们是否相等。
▪ 3. 如果相等，则返回该中间元素的索引，并退出算法；此时就查找成功了。
▪ 4. 如果不相等，就再比较这两个元素的大小。
▪ 5. 如果该中间元素大于目标元素，那么就将当前序列的前半部分作为新的待查序列；这是因为后半部分的所有元素都大于目标元素，它们全都被排除了。
▪ 6. 如果该中间元素小于目标元素，那么就将当前序列的后半部分作为新的待查序列；这是因为前半部分的所有元素都小于目标元素，它们全都被排除了。
▪ 7. 在新的待查序列上重新开始第1步的工作。

6.2 代码表示

//二分法查找：要求此数组必须是有序的。
int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
boolean isFlag = true;
int number = 256;
//int number = 25;
int head = 0;//首索引位置
int end = arr3.length - 1;//尾索引位置
while(head <= end){
int middle = (head + end) / 2;
if(arr3[middle] == number){
System.out.println("找到指定的元素，索引为：" + middle);
isFlag = false;
break; }else if(arr3[middle] > number){
end = middle - 1;
}else{//arr3[middle] < number
head = middle + 1;
} }
if(isFlag){
System.out.println("未找打指定的元素");
}

结果