java语言之数组

一、数组的概述

1.数组的理解

数组是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.数组相关的概念

• 数组名
• 元素
• 角标、下标、索引
• 数组的长度：元素的个数

3.数组的特点

(1）数组是有序排列的
(2）数组属于引用数据类型。数组的元素，既可以是基本数据类型，也可以是引用数据类型
(3）创建数组对象会在内存中开辟一整块连续的空间
(4）数组的长度一旦确定，就不能修改。

4.数组的分类

(1)按照维数：一维数组、二维数组、
(2)按照数组元素的类型：基本数组类型元素的数组、引用数组类型元素的数组

二、一维数组的使用

1.一维数组的声明和初始化

		int[] ids;   //声明
		//1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};
		//1.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];
		//也是正确的写法：
		int[] arr4 = {1,2,3,4,5};   //类型推断

总结：数组一旦初始化完成，其长度就确定了。

2.如何调用数组的指定位置的元素

		//2.如何调用数组的指定位置的元素:通过角标的方式调用
		//数组的角标(或索引)从0开始的，到数组的长度 - 1结束。
		names[0] = "王铭";
		names[1] = "王和";
		names[2] = "张学良";
		names[3] = "孙居龙";
		names[4] = "王宏";

3.如何获取数组的长度

使用数组名.length获取数组的长度

		//3.如何获取数组的长度
		//属性：length
		System.out.println(names.length);  //5
		System.out.println(ids.length);  //4

4.如何遍历数组

	for(int i = 0; i < nums.length;i++){
		System.out.println(nums[i]);
	}

5.数组元素的默认初始化值

•  数组元素是整型：0
  

•  数组元素是浮点型：0.0
  

•  数组元素是char型:底层ASCII码值为0对应的字符或/u0000,而非'0'
  

•  数组元素是boolean型：false(因为底层false是用0装的)
  

•  数组元素是引用数据类型(类、接口、数组)：null
  

6.数组的内存解析

一维数组的内存解析

三、二维数组的使用

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

1.二维数组的声明和初始化

	//静态初始化
	int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
	//动态初始化1
	String[][] arr2 = new String[3][2];
	//动态初始化2
	String[][] arr3 = new String[3][];

2.如何调用数组的指定位置的元素

	System.out.println(arr1[0][1]); //2
	System.out.println(arr2[1][1]);  //null,String是引用数据类型，默认值为null
	
	arr3[1] = new String[4];
	System.out.println(arr3[1][0]);  //null

3.如何获取数组的长度

	System.out.println(arr4.length);  //3
	System.out.println(arr4[0].length);  //3
	System.out.println(arr4[1].length); //4

4.如何遍历数组

	for(int i = 0; i < arr4.length; i++){
		for(int j = 0; j < arr4[i].length; j++){
			System.out.print(arr4[i][j] + " ");
		}
		System.out.println();
	}

5.数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0],arr[1][2]等

只针对动态初始化来说，因为静态初始化无意义，已经给数组指定元素赋过值了

• 针对于初始化方式一：比如：int[][] arr = new int[4][2];
  外层元素的初始化值为：地址值
  内层元素的初始化值为：与一维数组初始化情况相同

• 针对于初始化方式二：比如：int[][] arr = new int[4][];
  外层元素的初始化值为：null
  内层元素的初始化值为：不能调用，否则报错

6.数组的内存解析

二维数组的内存解析

三、操作数组的工具类：java.util.Arrays

	//1. boolean equals(int[] a,int[] b) 判断两个数组是否相等。
	int[] arr1 = new int[]{1,2,3,4};
	int[] arr2 = new int[]{1,3,2,4};
	boolean isEquals = Arrays.equals(arr1, arr2);
	System.out.println(isEquals);  
	
	//2. String toString(int[] a) 输出数组信息。
	System.out.println(Arrays.toString(arr1));
	
	//3. void fill(int[] a,int val) 将指定值填充到数组之中。
	Arrays.fill(arr1,10);
	System.out.println(Arrays.toString(arr1));
	
	//4. void sort(int[] a) 对数组进行排序。
	Arrays.sort(arr2);
	System.out.println(Arrays.toString(arr2));
	
	//5. int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。
	int[] arr = new int[]{-98,-34,2,34,54,66,79,105,210,333};
	int index = Arrays.binarySearch(arr, 73);
	if(index >= 0) {
		System.out.println(index);
	}
	else{
		System.out.println("未找到");
	}

四、数组的复制、反转、查找(线性查找、二分法查找)

String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
		
	//数组的复制(区别于数组变量的赋值：arr1 = arr)
	String[] arr1 = new String[arr.length];
	for(int i = 0; i < arr1.length; i++){
		arr1[i] = arr[i];
	}
	
	//数组的反转
	//方式1：
	for(int i = 0; i < arr.length / 2; i++){
			String temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
	}
	//方式2：
	for(int i = 0, j = arr.length - 1; i < j; i++,j--){
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
	}
	//遍历
	for(int i = 0; i < arr.length; i++){
		System.out.print(arr[i] + "\t");
	}
	System.out.println();
	
	//查找(或搜索)
	//线性查找
	String dest = "BB";
	dest = "CC";
	boolean isFlag = true;
	for(int i = 0; i < arr.length; i++){
		if(dest.equals(arr[i])){
			System.out.println("找到了指定的元素，位置为：" + i);
			isFlag = false;
			break;
		}
	}
	if(isFlag){
		System.out.println("很遗憾没有找到");
	}
	
	//二分法查找
	//前提：所要查找的数组必须有序
	int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
	
	int dest1 = -34;
	dest1 = 34;
	boolean isFlag1 = true;
	int head = 0;  //初始的首索引
	int end = arr2.length - 1;  //初始的末索引
	
	while(head <= end){
		int middle = (head + end) /2;
		if(dest1 == arr2[middle]){
			isFlag1 = false;
			System.out.println("找到了指定的元素，位置为：" + middle);
			break;
		}
		else if(dest1 > arr2[middle]){
			head  = middle + 1;
		}
		else{
			end = middle - 1;
		}
	}
	if(isFlag1){
		System.out.println("很遗憾，没有找到指定的元素！");
	}

五、数组的冒泡排序

	int[] arr = new int[]{42,32,76,-98,0,64,33,-21,32,99};
		
	//冒泡排序
	for(int i = 0; i < arr.length - 1; i++){  //控制跑多少趟
		for(int j = 0; j < arr.length - 1 - i; j++){  //冒泡排序的核心
			if(arr[j] > arr[j+1]){
				int temp = arr[j+1];
				arr[j+1] = arr[j];
				arr[j] = temp;
			}
		}
	}
	
	for(int i = 0; i < arr.length; i++){
		System.out.print(arr[i] + " ");
	}

六、数组中的常见异常

1.数组角标越界的异常

	//1.数组角标越界的异常：ArrayIndexOutOfBoundExcetion
	int[] arr = new int[]{1,2,3,4,5};
	
	for(int i = 0; i <= arr.length; i++){
		System.out.print(arr[i]);
	}
	System.out.print(arr[-2]);
	System.out.print("hello");

2.空指针异常

	//2.空指针异常：NullPointerException
	//情况一：
	int[] arr1 = new int[]{1,2,3};
	arr1 = null;
	System.out.print(arr1[0]);
	
	//情况二：
	int[][] arr2 = new int[4][];
	System.out.print(arr2[0][0]);
	
	//情况三：
	String[] arr3 = new String[]{"AA","BB","CC"};
	arr3[0] = null;
	System.out.print(arr3[0].toString());