JavaSE之数组

1.数组的概述

1.1

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

1.2数组的常见概念

1. 数组名
2. 下标
3. 元素
4. 数组的长度

1.3数组的特点

1. 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
2. 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
3. 数组的长度一旦确定，就不能修改。
4. 直接通过下标(或索引)的方式调用指定位置的元素，

1.4数组的分类

1. 按照维度：一维数组、二维数组…
2. 按照数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

2.一维数组

1. 声明：(两种类型)
   int[] num;
   int a1[];
2. 静态初始化：声明和赋值同时进行
   int[] arr1 = new int[]{1,2,3,4,5};
3. 动态初始化：声明和赋值分开进行
   int[] arr2 = new int[5];
   arr2[0] = 1;
   arr2[1] = 2;
   arr2[2] = 3;
   arr2[3] = 4;
   arr2[4] = 5;
4. 引用：通过下标的方式引用。
   数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；
   如int a[]=new int[3]，可引用的数组元素为a[0]、a[1]、a[2]
5. 属性：length
   a.length 指明数组a的长度(元素个数)

int[] arr1 = new int[5];
System.out.print(arr1.length);//5

6. 遍历

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

7. 默认初始化值

数组元素类型	元素默认初始化值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0
boolean	false
引用数据类型	null

8. 内存解析
   

3.二维数组

1. 概述：
   对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。
2. 动态初始化（格式一）
   int[][] arr = new int[3][2];
   定义了名称为arr的二维数组
   二维数组中有3个一维数组
   每一个一维数组中有2个元素
   一维数组的名称分别为arr[0], arr[1], arr[2]
   给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
3. 动态初始化（格式二）
   int[][] arr = new int[3][];
   二维数组中有3个一维数组。
   每个一维数组都是默认初始化值null (注意：区别于格式1）
   可以对这个三个一维数组分别进行初始化
   arr[0] = new int[3];
   arr[1] = new int[1];
   arr[2] = new int[2];
   注：
   int[][]arr = new int[][3]; //非法
4. 静态初始化
   int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
   定义一个名称为arr的二维数组，二维数组中有三个一维数组
   每一个一维数组中具体元素也都已初始化
   第一个一维数组 arr[0] = {3,8,2};
   第二个一维数组 arr[1] = {2,7};
   第三个一维数组 arr[2] = {9,0,1,6};
   第三个一维数组的长度表示方式：arr[2].length;
   注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
5. 二维数组的内存解析
   

练习

public class Test1 {
	public static void main(String[] args) {
		
		int[][] arr = new int[3][];
		arr[0] = new int[]{3,5,8}; //静态初始化
		arr[1] = new int[2];//动态初始化
		arr[1][0] = 12;
		arr[1][1] = 9;
		arr[2] = new int[] {7,0,6,4};//静态初始化
		int sum = 0;
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr[i].length;j++) {
				sum = sum + arr[i][j];
			}
		}
		System.out.print("二维数组的各元素总和为"+ sum);
	}
}

运行结果：54

4.数组的常见算法

1.数组的创建与元素复制：

杨辉三角

public class YangHui {//按步骤一步步写
	public static void main(String[] args) {
		int[][] arr = new int[10][];//第一步，十行的杨辉三角
		for(int i=0;i<arr.length;i++) {
			arr[i] = new int[i+1];//第二步，第一行有一个元素，第n行有n个元素
			for(int j=0;j<arr[i].length;j++) {
				arr[i][j] = 1; arr[i][arr[i].length-1]=1;
				//第三步，每一行的第一个元素和最后一个元素都是1
				if(j != 0 && j !=arr[i].length-1) {
				//第四步，从第三行开始，对于非第一个元素和最后一个元素满足下列条件
					arr[i][j] = arr[i-1][j-1]+arr[i-1][j];
				}
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}		
	}
}

回形数(未写)

6个数，1-30之间随机生成且不重复

public class Practise {
	public static void main(String[] args) {
		int[] arr = new int[6];//动态初始化
		for(int i=0;i<arr.length;i++) {
			int random = (int)(Math.random()*30+1);//随机数的范围是[0,1)
			int count = 0;
			for(int j=0;j<arr.length;j++) {//循环判断是否有相同随机数
				if(arr[j] == random) {
					count++;
				}			
			}
			if(count == 0) {
				arr[i] = random;
			}
			System.out.print(arr[i]+" ");
		}
	}
}

2.针对与数值型的数组：

最大值

int []arr1 = new int[]{1,2,3,4,5}; 
//静态初始化，声名和赋值同时进行
int num=0;
for(int i = 0;i<arr1.length;i++){
	if(num < arr1[i]){
		num = arr1[i];
	}
}
System.out.print("数组arr1的最大值是" + num);

运行结果：5

最小值

int []arr1 = new int[5]; 
//动态初始化,声名和赋值分开进行
arr1[0]= 9;
arr1[1]= 7;
arr1[2]= 3;
arr1[3]= 16;
arr1[4]= 2;
int num=arr[0];
for(int i = 0;i<arr1.length;i++){
	if(num < arr1[i]){
		num = arr1[i];
	}
}
System.out.print("数组arr1的最小值是" + num);

运行结果：2

总和

int []arr1 = new int[]{1,2,3,4,5}; 
		//静态初始化，声名和赋值同时进行
	int sum=0;
	for(int i = 0;i<arr1.length;i++){
		sum = sum + arr1[i];
	}
	System.out.print("数组arr1的总和是" + sum);
}

运行结果：15

平均数

int []arr1 = new int[]{1,2,3,4,5}; 
	//静态初始化，声名和赋值同时进行
int sum=0;
	for(int i = 0;i<arr1.length;i++){
		sum = sum + arr1[i];
	}
System.out.print("数组arr1的平均数是" + sum/arr1.length);
	}

运行结果：3

3.数组的赋值与复制

//复制
int[] arr1,arr2;
arr1 = new int[]{1,2,3};
arr2 = arr1;
//赋值
arr2 = new int[arr1.length]
for(int i=0;i<arr1.length;i++){
	arr2[i]=arr1[i];
}

4.反转

public class FanZhuan {
	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3,4,5,6};
		int temp=0;		
		for(int i=0;i<arr.length/2;i++){
			temp = arr[i];
			arr[i] = arr[arr.length - i-1];
			arr[arr.length - i-1] = temp;			
		}
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+" ");
		}
	}
}

5.线性查找

public class XianXing {
	public static void main(String[] args) {
	String[] arr = new String[]{"das","asdg","xzc","jhh","cc"};
	String dest = "cc";
	boolean isFlag = true;
	for(int i=0;i<arr.length;i++) {
		if(dest.equals(arr[i])){
			System.out.print("成功查找目标，位置为："+i);
			isFlag = false;
			break;
		}
	}
	if(isFlag) {
		System.out.println("并未找到");
	}
	}
}

6.二分法查找(要求数据按顺序排列)

public class ErFenFa {
	public static void main(String[] args) {
		int[] arr = new int[] {-12,-9,0,3,14,26,38,66,95};
		int dest = 3;
		int first = 0;
		int end = arr.length-1;
		boolean isFlag=true; 
		
		while(first <= end ) {
			int mid = (first + end)/2;
			if(dest == arr[mid]) {	
				System.out.print("目标元素已找到，位置为："+mid);
				isFlag = false;
				break;
			}else if(dest > arr[mid]){
				first = mid+1;
			}else{
				end = mid-1;
			}		
	}
		if(isFlag) {
			System.out.print("目标元素并未找到");
		}
}
}

冒泡排序(未写)
快速排序(未写)

5.Arrays工具类的使用

import java.util.Arrays;

public class ArrayTest {
	public static void main(String[] args) {
		int[] arr = new int[] {1,3,4,6};
		int[] arr1 = new int[] {1,9,6,4};
		
		//boolean equals(int[]a,int[] b) 判断两个数组是否相等
		boolean test = Arrays.equals(arr, arr1);
		System.out.println(test);
		
		//String toString(int[] a)输出数组信息
		System.out.println(Arrays.toString(arr));
		
		//void fill(int[] a,int val)将指定值填充到数组之中
		Arrays.fill(arr1, 10);
		System.out.println(Arrays.toString(arr1));
		
		//void sort(int[] a)对数组进行排序
		Arrays.sort(arr1);
		System.out.println(Arrays.toString(arr1));
		
		//int binary Search(int[] a,int key)对排序后的数组进行二分法检索指定的值
		System.out.println(Arrays.binarySearch(arr, 3));
	}
}

6.数组中的常见异常

1. 数组角标越界的异常

public class ArrayExceptionTest {
	public static void main(String[] args) {
	//1.数组角标越界的异常，ArrayIndexOutBoundsExcetion
		int[] arr = new int[] {4,5,6,7,9};
		for(int i=0;i<=arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}

2. 空指针异常
   小知识：一 旦程序出现异常，未处理时，就终止执行。

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