Java学习第11天

数组的基本操作

1. 获取元素： 元素类型 变量 = 数组名[index];
2. 设置元素： 数组名[index] = 值；
3. 遍历数组元素：建议使用for循环，事先知道循环次数；
4. 数组长度：int len = 数组名.length;length是属性不是方法；
5. 索引范围：从0开始，逐一递增。[0, 数组名.length - 1]

//数组的基本操作
class ArrayOprateDemo 
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{1,3,5,7,9};	//静态初始化
		System.out.println("数组的长度：" + arr.length);
		System.out.println("获取数组的第一个元素：" + arr[0]);
		System.out.println("获取数组的最后一个元素：" + arr[4]);
		//修改数组第一个元素
		arr[0] = 100;
		System.out.println("获取数组的第一个元素：" + arr[0]);
		
		//遍历数组元素
		for(int index = 0;index < arr.length;index ++){
			System.out.println("数组的元素：" + arr[index]);
		}

		int[] nums = new int[5];//动态初始化
		for(int index = 0;index < nums.length;index ++){//证明默认初始值是0
			System.out.println("数组的元素：" + nums[index]);
		}

	}
}

操作数组常见的两个异常

NullPointerException: 空指针异常（空引用）；
当数组还未初始化就直接操作数组。
String[ ] bs = null;
System.out.println(bs.length);
ArrayIndexOutOfBoundsException: 数组的索引越界异常。

获取数组中的最大和最小的元素

注意方法的思路与设计过程。

//求出数组的最大和最小元素
class ArrayOprateDemo2 
{
	//获取数组最大元素
static int getMax(int[] arr){
	int max = arr[0];//假设第一个元素是最大值
	for(int index = 0;index < arr.length;index ++){
		if(max < arr[index]){
			max = arr[index];//如果某元素大于最大值，将其赋值给max
		}
	}
	return max;
}

	//获取数组最小元素
static int getMin(int[] arr){
	int min = arr[0];//假设第一个元素是最小值
	for(int index = 0;index < arr.length;index ++){
		if(min > arr[index]){
			min = arr[index];//如果某元素小于最小值，将其赋值给min
		}
	}
	return min;
}

	public static void main(String[] args) 
	{
		int[] arr = new int[]{1,3,5,7,9,27,978,0};
		int max = ArrayOprateDemo2.getMax(arr);//调用最大值方法
		System.out.println("max = " + max);//978
		int min = ArrayOprateDemo2.getMin(arr);//调用最小值方法
		System.out.println("max = " + min);//0
	}
}

打印数组元素

直接打印的时候，打印出来的是hashCode值，如：[I@7439aca7.
我们需要 [ A, B, D, E ] 这样的效果；

//打印数组元素
class ArrayOprateDemo3 
{
	//打印元素的方法
	static void arrayPrint(String[] arr){
		if(arr == null){//为了当数组为空引用是打印而不是报错
			System.out.println("null");
			return;//结束方法，否则依然报错
		}
		String ret = "[";
		for(int index = 0;index < arr.length;index ++){
			ret = ret + arr[index];
			if(index != arr.length - 1){
				ret = ret + ",	";
			}
		}
		ret = ret + "]";
		System.out.println(ret);
	}
	public static void main(String[] args) 
	{
		String[] arr = {"H","A","B","C","D","E"};
		ArrayOprateDemo3.arrayPrint(arr);//调用打印方法
	}
}

逆序排列数组元素

原数组 [ A, B, D, E ]
逆序操作
新数组 [ F, D, B, A ]

//数组的逆序操作
class ArrayOprateDemo4 
{

	//创建逆序方法
	static String[] reverse(String[] oldArr){
		//创建一个新的数组用于存放逆序数组
		String[] newArr = new String[oldArr.length];
		for(int index = oldArr.length - 1;index >= 0;index --){//与遍历数组进行对比
			newArr[oldArr.length - 1 - index] = oldArr[index];//寻找老数组与新数组索引之间的关系？
		}
			return newArr;
	}

	//打印元素的方法
	static void arrayPrint(String[] arr){
		if(arr == null){//为了当数组为空引用是打印而不是报错
			System.out.println("null");
			return;//结束方法，否则依然报错
		}
		String ret = "[";
		for(int index = 0;index < arr.length;index ++){
			ret = ret + arr[index];
			if(index != arr.length - 1){
				ret = ret + ",	";
			}
		}
		ret = ret + "]";
		System.out.println(ret);
	}
	public static void main(String[] args) 
	{
		String[] oldArr = {"A","B","C","D","E"};
		ArrayOprateDemo4.arrayPrint(oldArr);//调用打印方法
		String[] newArr = ArrayOprateDemo4.reverse(oldArr);//调用逆序方法
		ArrayOprateDemo4.arrayPrint(newArr);//调用打印方法
	}
}

获取元素出现的索引（第一次/最后一次出现），线性搜索

int[ ] arr = {10,20,30,10,50,-30,10,0,15,10};
获取元素10在arr数组中第一次出现的索引（firstIndexOf）: 0

//获取元素出现的索引（第一次/最后一次出现），线性搜索
	/*
		查询key元素在arr数组中第一次出现的位置
			arr：从哪一个数组中去查询
			key：当前去查询的元素
		返回：如果key存在与arr数组中则返回第一次出现的索引
			如果不存在arr数组中，返回-1.
	*/
class ArraySearchDemo 
{
	//获取第一次索引方法
	static int indexOf(int[] arr,int key){
		for(int index = 0;index < arr.length;index ++){
			if(arr[index] == key){
				return index;
			}
			System.out.println(arr[index]);
		}
		return -1;
	}
	
	public static void main(String[] args) 
	{
		int[] arr = {10,20,30,10,50,-30,10,0,15,10};
		int beginIndex = ArraySearchDemo.indexOf(arr,10);
		System.out.println(beginIndex);
	}
}

获取元素10在arr数组中最后一次出现的索引（lastIndexOf）: 9

//获取元素出现的索引（第一次/最后一次出现），线性搜索
	/*
		查询key元素在arr数组中最后一次出现的位置
			arr：从哪一个数组中去查询
			key：当前去查询的元素
		返回：如果key存在于arr数组中则返回最后一次出现的索引
			如果不存在arr数组中，返回-1.
	*/
class ArraySearchDemo2 
{
	//获取最后一次索引方法
	static int indexOf(int[] arr,int key){
		for(int index = arr.length - 1;index >= 0;index --){
			if(arr[index] == key){
				return index;
			}
			System.out.println(arr[index]);
		}
		return -1;
	}
	
	public static void main(String[] args) 
	{
		int[] arr = {10,20,30,10,50,-30,10,0,15,10};
		int lastIndex = ArraySearchDemo2.indexOf(arr,10);
		System.out.println(lastIndex);
	}
}