java基础-数组

java基础-数组

---

数组的定义

• 数组是相同数据类型的有序集合
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们，下标从0开始。
  表达式：

int [] arr=new int [10]//这里面可以存放10个int类型的数字
//赋值，没赋值时默认值是0
arr[0]=1;
arr[1]=2;

获取数组长度

//变量名.length就可以获取数组的长度了
int [] arr= new int[10];
   	System.out.println(arr.length);

内存分析

如图：
我们声明了一个整数类型的数组array,它的长度是10
栈里面放的是引用对象的变量(array)，因为长度是10.所以堆里面就开辟了一块空间，空间里再开辟10个小空间，来存储数组的值

数组初始化

实体类也可以成为一个数组

//Man 是一个实体类
Man [] mans={new Man(), new Man()};|

基本特点

• 其长度是确定的。数组一旦被创建，它的大小是不可以改变的。
• 其元素是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本数据类型和String类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组边界

下标的合法区间：[0,length-1]，如果超过就会报错；

int [] arr=new int[2];
System.out.println(arr[2]);

ArrayIndexOutOfBoundsException :数组下标越界异常!

数组的使用

基本用法：

增强for循环：

/*输出与普通for循环没有区别，只不过没有下标，
没办法具体操作数组里的值*/
int [] arr= {1,2,3,4,5,6};
for(int arrs : arr){
	System.out.println(arrs);
}

小练习：
将数组中的值反转过来

多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
• 二维数组：

//可以看成一个两行五列的数组
int [][] a= new int[2][5];
/*int[2]可以看成在堆中创建了两个空间
int[5]看成堆中的两个空间都有五个小空间*/
int [][] b={{1,2,3,4,5},{1,2,3,4,5}};
//与上面的二维数组a是一样的

循环遍历二维数组：

Arrays类

• 数组的工具类java.util.Arrays
• 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）

功能

• 给数组赋值：通过fill方法
  注：
  Arrays.fill（ a9, value ）;
  a9是一个数组变量，value是一个a9中元素数据类型的值，作用：填充a1数组中的每个元素都是value
  Arrays.fill(a9, 3, 5,“World”);
  第一个参数指操作的数组，第二个和第三个指在该数组的某个区域插入第四个参数，第二个参数指起始元素下标（包含该下标），第三个参数指结束下标（不包含该下标），注意：java的数组下标从0开始

• 对数组排序：通过sort方法，按升序
  

• 比较数组：通过equals方法比较数组中的元素值是否相等
  关于==与equals的区别：
  详情参考大佬博客

• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找发操作
  

不用循环打印数组

一维数组:

int [] a ={1,2,3};
System.out.println(Arrays.toString(a));

二维数组：
[[I@15db9742, [I@6d06d69c] 这种输出结果是因为：
因为arrs是一个二维数组。相当于一个长度为2的数组，但是这个数组的元素是数组。
当执行Arrays.toString的时候相当于遍历数组，并且输出数组的元素，但是这个数组的元素是数组，所以这里输出的是数组元素的地址。

稀疏数组

• 它也是一种数据结构，也叫压缩算法
• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

处理方式：

• 记录数组一共有几行几列，有多少个不同值
• 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
  如下图：左边是原始数组，右边是稀疏数组
  话不多说，上代码！
  第一步：我们先定义一个左边的一样的数组：
  第二步：查看原数组的有效值的总数，定义一个稀疏数组，并设计头部
  第三步：遍历原数组 将原数组的 非零的值 存放到稀疏数组中
  第四步：稀疏数组已经完成，打印输出看看
  完整代码：

	// 我们先定义一个左边的图的数组，6行7列
		int[][] arr = new int[6][7];
		// 让数组的值跟左图一样
		arr[0][3] = 22;
		arr[0][6] = 15;
		arr[1][1] = 11;
		arr[1][5] = 17;
		arr[2][3] = -6;
		arr[3][5] = 39;
		arr[4][0] = 91;
		arr[5][2] = 28;
		// 遍历数组
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j <= arr.length; j++) {
				System.out.print(arr[i][j] + "\t");
			}
			System.out.println();
		}
		// 查看有效值
		int sum = 0;// 有效值的个数
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j <= arr.length; j++) {
				if (arr[i][j] != 0) {
					sum++;
				}
			}
		}
		System.out.println(sum);
		// 定义一个稀疏数组,如右图，我们可以看出它的列是固定的，行是有效值总数+1，因为第一行是原数组的行列加值的总数
		int[][] arrs = new int[sum + 1][3];
		// 设计头部
		arrs[0][0] = arr.length;// 第一行第二列为：原数组的行
		arrs[0][1] = arr[0].length;// 第一行第二列为：原数组的列
		arrs[0][2] = sum;// 第一行第三列为：原数组的有效值的总数
		// 打印稀疏数组看看头部
		System.out.println("================================");
		for (int i = 0; i < arrs.length; i++) {
			for (int j = 0; j < arrs[0].length; j++) {
				System.out.print(arrs[i][j] + "\t");
			}
			System.out.println();
		}
		// 将原数组的 非零的值 存放到稀疏数组中
		int count = 0;// 定义有效值为0
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[0].length; j++) {
				if (arr[i][j] != 0) {
					count++;// 只要有非0零值就加1
					// arrs[count]:将非零记录为稀疏数组的行
					arrs[count][0] = i;// 每一行的第一列为i:即原数组的行
					arrs[count][1] = j;// 每一行的第二列为j:即原数组的列
					arrs[count][2] = arr[i][j];// 每一行的第三列为值:即原数组的非零值
				}
			}
		}
		System.out.println("================================");
		// 遍历输出稀疏数组
		for (int i = 0; i < arrs.length; i++) {
			for (int j = 0; j < arrs[0].length; j++) {
				System.out.print(arrs[i][j] + "\t");
			}
			System.out.println();
		}

还原稀疏数组

代码：

	/*还原稀疏数组,定义个新数组
		稀疏数组arrs的第一行：  6	 7	8
		arrs[0][0]为6,即原数组arr的行数
		arrs[0][1]为7,即原数组arr的列数*/
		int [][] NewArr = new int [arrs[0][0]][arrs[0][1]];
		//循环遍历稀疏数组arrs将值给还原数组NewArr
		for(int i=1;i<arrs.length;i++){//i=1:第一行为原数组arr的行，列，值，不需要遍历
			
			/*原数组arr的   非零值  在稀疏数组arrs的部分排序：
			6	7	8	
			0	3	22	
			0	6	15	
			当i等于1时：arrs[i][0]=0,
					[arrs[i][1]=7;
					arrs[i][2]=22;
			所以NewArr[arrs[i][0]][arrs[i][1]]=arrs[i][2]=NewArr[0][3]=22;
			就还原了稀疏数组
			*/
			NewArr[arrs[i][0]][arrs[i][1]]=arrs[i][2];
		}
		//打印还原数组NewArr
		System.out.println("打印还原数组NewArr:");
		for (int i = 0; i < NewArr.length; i++) {
			for (int j = 0; j < NewArr[0].length; j++) {
					System.out.print(NewArr[i][j]+"\t");
				}
			System.out.println();
			}