数组的主要知识点及必须掌握的重要内容

</pre><pre>

<pre name="code" class="java">/**
 * 
 * @author zhaocx1
 *
 */
/* 数组：同一种类型数据的集合，其实数组就是一个容器。
 * 数组的好处，可已给数据元素自行进行编号，从0开始。
 * 数组的格式：1.元素类型[] 数组名=new 元素类型[元素的个数或者长度];例如  int[] in=new int[4];        
 *         2.元素类型[] 数组名=new 元素类型[]{元素，元素...};例如int[] in=new int[]{1,2,4,6}; 或者int[] in={1,2,4,6};
 */
/* 栈内存和堆内存的含义：
 * 栈内存：用于存储局部变量，当数据使用完时，所占空间会自动释放；
 * 堆内存：数组和对象，通过new建立的实例都存放在堆内存中；每一个实体都有内存地址值；实例中的变量都有默认初始化值，实体不再被使用，会在不确定的时间内被垃圾回收器回收
 */

//数组中常见的异常：数组角标越界异常（ArrayIndexOutOfBoundsException);空指针异常(NullPointerException);

//数组中常见的操作：获取最值（最大值，最小值）；排序（选择排序，冒泡排序）；折半查找（二分查找）

/* 二维数组：数组中含有一个数组；
 * 如：int[][] arr=new int[3][2]; 定义一个二维数组arr，有3个一维数组，每一个一维数组的长度为2；
 *    int[][] arr={{1,2,3},{3,4,5,6}};定义一个二维数组arr，二维数组有两个一维数组，一维数组的长度分别为3，4；
 * 获取每一个一维数组分别为：arr[0],arr[1],arr[2]...
 * 每一个一维数组的长度分别为：arr[0].length,arr[1].length,arr[2].length...
 */
//注意特殊的写法：int[]x,y[]:x 为一维数组，y为二维数组

//数组的操作:获取数组中的元素,通常会用到遍历。数组中有一个属性可以直接获取到数组元素的个数:length,使用方式：数组名称.length;
public class ArrayDemo3 {
	public static void main(String[] args) {// 主函数，整个程序运行的切入点
		int[] arr = { 3, 6, 5, 1, 8, 9, 89 };// 定义一个整型数组
		System.out.println("length：" + arr.length);// 打印数组的长度，也就是数组的个数

		printArray(arr);// 调用printArray方法

	}

	// 定义功能，用于打印数据中的元素。元素间用逗号隔开。
	public static void printArray(int[] arr) {// 定义一个单独的方法用于方法内容运行
		System.out.print("[");// 打印输出语句
		for (int x = 0; x < arr.length; x++) {// 定义一个数组长度的循环增量
			if (x != arr.length - 1)
				System.out.print(arr[x] + ", ");// 当元素不是最后一个输出元素本身和逗号
			else
				System.out.println(arr[x] + "]");// 当元素是数组最后一个时输出中括号

		}
	}

}

</pre><pre name="code" class="java">/** * @author zhaocx1 * * 练习：打印一个长方形，三行，四列，每一列用*表示 * 思路： 1.该题涉及到循环中的嵌套循环，一个循环套另一个循环，即大圈套小圈原理， * 2.定义两个循环，外循环控制长方形的行数，内循环控制长方形的列数。 */public class ForForDemo {public static void main(String[] args) { // 主函数，作用是整个程序运行的切入点for (int x = 0; x < 3; x++) { // 外部循环，控制的是行数for (int y = 1; y < 4; y++) { // 内循环，控制的每一行打印的列数System.out.print("*"); // 输出语句}System.out.println(); // 只是一个换行的功能}}}

/**
 * 
 * @author zhaocx1 
 * 练习：打印 ***** 
 *            **** 
 *            *** 
 *            ** 
 *            * 
 * 不是規律的規律： 尖朝上，可以改變條件。讓條件隨着外循環變化。尖朝下，可以初始化值，讓初始化隨着外循環變化。
 * 
 */
public class ForForDemo1 {
	public static void main(String[] args) {//主函数，整个程序运行的切入点
		for (int x = 0; x < 5; x++) {//定义一个外循环，用于控制行数
			for (int y = x; y < 5; y++) {//定义一个内循环，用于控制每一行的列数
				System.out.print("*");//输出打印内容
			}
			System.out.println();//用于每一行的换行
		}

		System.out.println("-------------------");//输出分隔符	
	}
}

/**
 * @author zhaocx1
 * 练习：打印 ：1 
 *              12 
 *              123 
 *              1234 
 *              12345
 */
public class ForForDemo3 {
	public static void main(String[] args)//主函数，整个程序运行的切入点
	{
		
		for (int b = 1; b <= 5; b++) {//外循环，控制行数
			for (int y = 1; y <= b; y++) {//内循环，用于控制每一行打印的内容
				System.out.print(y);//输出每一行打印的内容
			}
			System.out.println();//换行
		}
		System.out.println("---------------------");

		/*
		 * 打印：九九乘法表 
		 */

		for (int x = 1; x <= 9; x++) {//外循环，控制行数
			for (int y = 1; y <= x; y++) {//内循环，控制一行打印内容
				System.out.print(y + "*" + x + "=" + y * x + "\t");//输出，每一行打印内容
			}
			System.out.println();//换行
		}
					
	}
}

/**
 * 
 * @author zhaocx1 练习：获取1-10的和，并打印。
 */

public class ForTest2 {
	public static void main(String[] args) {// 主函数，整个程序运行的切入点

		int sum = 0;// 定义一个变量，用于存储不断变化的和

		int x = 1; // 定义变量，记录住不断变化的被加的数

		while (x <= 100) {// 定义循环，重复加法的过程
			sum += x;
			x++;
		}
		System.out.println("sum=" + sum);
		/*
		 * 总结：循环注意: 一定要明确哪些语句需要参与循环， 哪些不需要，循环用for的形式来体现。 其实这就是累加思想。
		 * 原理：通过变量记录住循环操作后的结果。 通过循环的形式，进行累加的动作。
		 */
	}
}

/**
 * @author zhaocx1
 * 
 * 练习：1.1-100之间，7的倍数的个数，并打印。 
 * 思路：1.先对1-100进行循环(遍历)通过循环的形式，
 *     2.在遍历的过程中，定义条件，只对7的倍数进行操作。 
 *     3.因为7的倍数不确定，只要符合条件就通过一个变量来记录这个变化的次数。
 * 步骤：1.定义循环语句，选择for语句。
 *     2.在循环中定义判断。只要是7的倍数即可。使用if语句，条件x%7==0。
 *     3.定义变量，该变量随着7的倍数的出现为自增。
 */

public class ForTest3 {
	public static void main(String[] args) // 主函数，整个函数的切入点
	{
		int count = 0;// 定义一个计数器，用于记录不断变化的个数
		for (int x = 1; x <= 100; x++) // 定义一个循环增量，对1-100进行遍历
		{
			if (x % 7 == 0)// 判断7的倍数
				count++;
		}
		System.out.println("count=" + count);// 输出，7的倍数的个数

	}
}
/*
 * 计数器思想。 通过一个变量记录住数据的状态变化，也许通过循环完成。
 */

/**
 * @author zhaocx1 
 * 排序：选择排序，冒泡排序 选择排序： 内循环结束一次，最值出现在角标位置上。
 *         练习：对给定的数组进行排序{5,1,6,4,2,8,9}
 * p
 */

public class ArrayTest2 {
	public static void main(String[] args) {//主函数，整个函数的切入点
		int[] arr = { 5, 1, 6, 4, 2, 8, 9 };//定义一个数组
		
		PrintArray(arr);// 排序前

		selectSort(arr);// 排序
	
		PrintArray(arr);// 排序后

	}
	public static void selectSort(int[] arr) {  //定义一个功能，对元素进行排序
		for (int x = 0; x < arr.length - 1; x++) {  //定义一个角标x
			for (int y = x + 1; y < arr.length; y++) {  //定义一个角标y紧挨着x
				if (arr[x] > arr[y]) {   //判断两个元素的大小
					swap(arr, x, y);  //符合条件，对两个元素进行换位

				}
			}
		}
	}
	/*
	 * 发现无论什么排序，都需要对满足条件的元素未知进行置换。
	 * 所以可以把这部分相同的代码提取出来，单独封装成一个函数。
	 */
	public static void swap(int[] arr, int a, int b) {//定义一个功能，对两个元素进行转换
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

	// 定义一个功能，用于打印数组的元素
	public static void PrintArray(int[] arr) {
		System.out.print("[");// 输出语句
		for (int x = 0; x < arr.length ; x++) {// 定义一个循环增量，用于表示元素的角标
			if (x != arr.length - 1)// 判断角标不是最后一个元素时
			{
				System.out.print(arr[x] + ",");// 输出语句
			}

			else
				System.out.println(arr[x] + "]");// 当角标是最后一个元素是，输出语句

		}
	}
}

/**
 * 
 * @author zhaocx1 
 * 冒泡排序：相邻的两个元素进行比较，如果符合条件换位。 第一圈，最值出现在最后一位。
 */
public class ArrayTest3 {
	public static void main(String[] args) {
		int[] arr = { 5, 1, 6, 4, 2, 8, 9 };
		// 排序前
		PrintArray(arr);
		// 排序
		bubbleSort(arr); 					
		// 排序后
		PrintArray(arr);
	}

	public static void bubbleSort(int[] arr) {//定义一个功能，对元素进行排序
		for (int x = 0; x < arr.length - 1; x++) {//定义一个角标x
			for (int y = 0; y < arr.length - x - 1; y++)//让每一次比较的元素减少-1，避免角标越界。
			{
				if (arr[y] >arr[y + 1]) { //判断两个元素的大小
					swap(arr, y, y + 1); //符合条件，对两个元素进行换位
				}
			}
		}
	}

	public static void swap(int[] arr, int a, int b) {// 定义一个功能，对两个元素进行转换
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

	// 定义一个功能，用于打印数组的元素
	public static void PrintArray(int[] arr) {
		System.out.print("[");// 输出语句
		for (int x = 0; x < arr.length; x++) {// 定义一个循环增量，用于表示元素的角标
			if (x != arr.length - 1)// 判断角标不是最后一个元素时
			{
				System.out.print(arr[x] + ",");// 输出语句
			}
			else
				System.out.println(arr[x] + "]");// 当角标是最后一个元素是，输出语句

		}
	}
}

/**
 * @author zhaocx1 数据的查找操作： 折半查找：提高效率 ，但是必须保证该数组时有序的数组。
 *         练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。 如何获取该元素在数组中的位置。
 */

public class ArrayTest4 {
	public static void main(String[] args) {

		// 定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。

		int[] arr = { 2, 4, 5, 7, 19, 32 };//定义一个整型数组

		int index = halfsearch(arr, 5);
		System.out.println("index=" + index);//调用折半的第一种方式

		int index1 = halfSearch_2(arr, 6);//调用折半的第二种方式
		System.out.println("index1=" + index1);
	}

	// 折半的第一种方式
	public static int halfsearch(int[] arr, int key) {
		int min, max, mid;
		min = 0;
		max = arr.length - 1;
		mid = (max + min) / 2;

		while (arr[mid] != key) {
			if (key > arr[mid])
				min = mid + 1;
			else if (key < arr[mid])
				max = mid - 1;

			if (min > max)
				return -1;
			mid = (max + min) / 2;
		}
		return mid;
	}

	// 折半的第二种方式；

	public static int halfSearch_2(int[] arr, int key) {
		int min = 0, max = arr.length - 1, mid;

		while (min <= max) {
			mid = (min + max) >> 1;
			if (key > arr[mid])
				min = mid + 1;
			else if (key < arr[mid])
				max = mid - 1;
			else
				return mid;
		}
		return min;
	}

	// 定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么代表着该key在数 组中不存在。
	public static int getIndex(int[] arr, int key) {
		for (int x = 0; x < arr.length; x++) {
			if (arr[x] == key)
				return x;
		}
		return -1;
	}
}

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 给定一个数组(5,1,6,4,2,8,9)，获取数组中的最大值，以及最小值。
 */

/*
 * 获取数组中的最大值。 思路： 
 * 1.获取最值，需要进行比较，每一次比较都会有一个较大值，因为该值不确定 。 
 * 通过一个变量进行临储。
 * 2.让数组中的每一个元素都和这个变量中的值进行比较， 如果大于了变量中的值，就用该变量记录较大值。
 * 3.当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值。
 * 
 * 步骤： 
 * 1.定义一个变量。初始化为数组中任意一个元素即可。 
 * 2.通过循环语句堆数组进行遍历。
 * 3.在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变来那个。
 * 
 * 需要定义一个功能来完成。以便提高复用性。 
 * 1.明确结果，数组中的最大元素 int 
 * 2.未知内容：一个数组，int[]
 */
public class ArrayTest {

	public static int getMax(int[] arr) {//定义一个获取最大值的功能，并传递一个数组
		int max = arr[0];//定义一个最大值，初始化值为0角标的元素
		for (int x = 1; x < arr.length; x++) {//定义一个循环增量，用于判断数组的角标
			if (arr[x] > max){//进行比较，判断最大值
				max = arr[x];//如果符合条件，将最大值元素赋给已经定义好的变量
			}
		}
		return max;//返回最大值
	}

	/*
	 * 获取最大值的另一种方式。 可不可以临时变量初始化为0呢？ 可以，这种方式其实是在初始化为数据中的任意一个角标。
	 */

	public static void main(String[] args) {//主函数，整个函数的切入点
		int[] arr = { 5, 1, 6, 4, 2, 8, 9 };//定义一个数组
		int max = getMax(arr);//将定义的数组传递到函数中，调用函数
		System.out.println("max=" + max); //输出取得的最大值

	}

}