初窥Java之六

一、二维数组

1、动态创建

数组中元素类型[] 数组名 = new 数组中元素类型[];

例如：int[][] arr = new int[二维数组的长度][一维数组的长度]；

Int[][] arr = new int[4][3]; 创建了一个长度为2的二维数组（也就是创建了一个包含4个一维数组的二维数组），其中一位数组的长度为3

2、静态创建

数组中元素类型[] 数组名 = new 数组中元素类型[]{{1,2,3}，{4,5,6}，{7,8,9}}；

例如：int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

3、二维数组默认值确定

意思是打印二维数组中索引为0的元素：此时索引为0的元素类型为一维数组的int[]类型，但是一维数组并不知道长度，因此，打印的值为null。

意思是打印二维数组中索引为0的一位数组中索引为1的元素：此时索引为0的一位数组中索引为1的元素没有手动赋值，因此，系统会给与默认值，默认值类型与数据类型有关。

总结：在动态创建二维数组中，当二维数组中的一维数组的长度给定之后，一维数组就具有了默认值。

二、冒泡排序（笔试重点）

class TestMaoPao9{
	public static void main(String[] args){
		int[] arr = {5,1,13,3,8,2,11};

		sort(arr);
	}

	/*
		请把以上数组按照从小达到的顺序进行排序

	*/
	//5,1,13,3,8,2,11
	public static void sort(int[] arr){
		/*
		if(arr[0] > arr[1]){
			int temp = arr[0];
			arr[0] = arr[1];
			arr[1] = temp;
		}

		if(arr[1] > arr[2]){
			int temp = arr[1];
			arr[1] = arr[2];
			arr[2] = temp;
		}

		if(arr[2] > arr[3]){
			int temp = arr[2];
			arr[2] = arr[3];
			arr[3] = temp;
		}

		if(arr[3] > arr[4]){
			int temp = arr[3];
			arr[3] = arr[4];
			arr[4] = temp;
		}

		if(arr[4] > arr[5]){
			int temp = arr[4];
			arr[4] = arr[5];
			arr[5] = temp;
		}

		if(arr[5] > arr[6]){
			int temp = arr[5];
			arr[5] = arr[6];
			arr[6] = temp;
		}
		以上代码第一次比较完毕，但是，重复代码太多了，所以我们可以使用循环进行优化。

		*/

		/*

		//第一次比较完毕
		for(int i=0;i<6;i++){
			if(arr[i] > arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}

		//第二次比较完毕
		for(int i=0;i<5;i++){
			if(arr[i] > arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}

		//第三次比较
		for(int i=0;i<4;i++){
			if(arr[i] > arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}

		//第四次比较
		for(int i=0;i<3;i++){
			if(arr[i] > arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}

		//第五次比较
		for(int i=0;i<2;i++){
			if(arr[i] > arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}

		//第六次比较
		for(int i=0;i<1;i++){
			if(arr[i] > arr[i+1]){
				int temp = arr[i];
				arr[i] = arr[i+1];
				arr[i+1] = temp;
			}
		}

		以上代码的重复代码又太多了，因此继续循环优化

		for(int j=0;j<6;j++){
			for(int i=0;i<6-j;i++){
				if(arr[i] > arr[i+1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}

		*/

		//冒泡排序最终代码
		for(int j=0;j<arr.length-1;j++){
			for(int i=0;i<arr.length-1-j;i++){
				if(arr[i] > arr[i+1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}

		/*
			调用方法的三种方式：
					1.方法所在类名.方法名()  前提: 方法有被static所修饰
					2.对象名.方法名() 前提: 方法没有被static所修饰
					3.直接方法名()    前提: 调用方和被调用方都必须在同一个类中，要么都被static所修饰

		*/
		Test3.printArray(arr1);

	}

}

class Test3{
	public static void main(String[] args){
		int[] arr = {23,12,24,54,32};
		printArray(arr);
	}
	//定义一个方法将int[] arr = {23,12,24,54,32}打印成[23,12,24,54,32]
	public static void printArray(int[] arr){
		String str = "[";
		for(int i = 0;i < arr.length;i++){
			str +=arr[i];
			if(i != arr.length - 1){
				str += ",";
			}
		}
		str = str + "]";
		System.out.println(str);
	}
}

　　

三、二分查找

1、查找分为线性查找和二分查找，线性查找代码示例如下：

/**
	设计一个方法，传入一个int的数组，返回该数组中最大的值
*/
/**
	思路：形参：数组
		  定义一个变量max ，每个数都和max进行比较，如果比max大，就将这个数赋值给max，依次进行
*/
class Test8{
	public static void main(String[] args){
		int[] arr = {34,23,56,45,24,55};
		System.out.println(getFirst(arr));
	}
	public static int getFirst(int[] arr){
		int max = arr[0];
		for(int i = 0;i < arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
			}
		}
		return max;
	}
}

　2、二分查找代码示例如下

class Test6{
	public static void main(String[] args){
		int[] arr={1,2,3,4,5,6,7,8,9};
		int index = binarySerch(arr,3);
		System.out.println(index);
	}
	/**
		使用二分查找查找元素3在int[] arr={1,2,3,4,5,6,7,8,9}中的索引值
	*/
	/**
		思路：将3与中间索引对应的值相比较，如果相同，则返回索引，如果3大于中间索引对应的值，则往右查找，否则往左查找。
			  定义minIndex、maxIndex、midIndex三个变量分别储存最小索引、最大索引和中间索引；
	流程分析：第一次查找    minIndex = 0     maxIndex = 8     0 <= 8  midIndex = 4  3<5  往左查找
			  第二次查找    minIndex = 0     maxIndex = 3     0 <= 3  midIndex = 1  3>2  往右查找
			  第三次查找    minIndex = 2     maxIndex = 3     2 <= 3  midIndex = 2  3 = 3 over  返回索引2
		注意：使用二分查找前，数组必须按照一定顺序排列
	*/
	public static int binarySerch(int[] arr,int num){
		int minIndex = 0;
		int maxIndex = arr.length-1;

		while(minIndex <=maxIndex){//此处不知道要循环多少次，因此使用while循环,此处判断条件是重点
			int midIndex = (minIndex+maxIndex) / 2;
			if(num == arr[midIndex]){
				return midIndex;
			}else if(num < arr[midIndex]){
				maxIndex = midIndex - 1;
			}else{
				minIndex = midIndex + 1;
			}
		}
		return -1;
	}
}

　

四、增强for循环

1、语法格式

For（源数据类型 变量名 ： 源）{

　　功能执行语句；

}

注意：源指的是数组或者Iterable的实例对象

2、示例

class Test7{
	public static void main(String[] args){
		int[] arr = {1,2,3,4,5};
		foreachDemo(arr);
		int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9}};
		foreachDemo1(arr1);
	}
	public static void foreachDemo(int[] arr){
		for(int e : arr){        //增强for循环
			System.out.println(e);
		}
	}
	public static void foreachDemo1(int[][] arr1){
		for(int[] e : arr1){   //嵌套式增强for循环
			for(int x : e){
				System.out.println(x);
			}
		}
	}

}

五、可变参数

1、语法格式 ：

　　　　　　数据类型...变量名

2、可变参数作用：调用方法的时候，你传递的实参可以是0个也可以是n个

3、可变参数：其实就是一个数组

4、可变参数的注意事项：

1.可变参数只能定义在参数列表末尾（java规范）

2.在一个方法中，有且只能申明一个可变参数