黑马程序员—基础篇之初识java数组

数组的学习

1：数组的来历；

java程序运算过程中，需要使用大量的数据，常见的数据形态有常量与变量。当需要一次性使用多个变量时，需要进行多次定义。为避免该现象的发生，Java语言提供了一种一次性声明创建多个变量的用于存储数据机制，该机制即为数组。

2：数组与数据类型：

数组是一种特殊的数据类型，数组在内存中的以“引用”的形式描述引用即参照，即对应存储的数据指向另一个实际存储数据的区域，中间的联系使用内存地址进行

3：什么是数组；

数组是一种存放数据的容器

4.数组有什么特点：

1同个数组的数据类型都相同；2且数组具有一个固定长度；3数组中的元素都有一个唯一的编号，叫做数组的索引或者数组元素下标，索引自0开始；访问数组中的元素要通过索引，创建数组的内存空间要使用关键词new来实现。

5：数组的表现格式；

格式：
		数据类型[] 变量名 = new 数据类型[元素个数];//这里元素个数又叫元素长度。
		int[] arr = new int[3];
		int arr[] = new int[3];
		int[] arr = new int[]{1,2,3};
		int[] arr = {1,2,3};

6.数组的操作：

6.1数组的修改；格式：数组名[索引] = 值;
int []  arr = new int[4];      arr[1] = 100;

5.2数组的读取；格式：数组名[索引];
int []  arr = new int[4];      System.out.println(arr[0]);

7.数组元素的默认值；

数组中的元素在数组初始化时已经为其分配了值，其值是二进制位表示形式中对应全部为0的表示形式。

7.1,不同类型有不同的初始值：

整型初始值全部为0
实型初始值全部为0.0
布尔型初始值全部为false
字符型初始值全部为/u0000对应的空字符
其他类型初始值全部为null

8.数组的遍历；

当我们要取出数组中的所有元素，我们就需要逐个读取数组中的每一个元素，这个行为就叫做遍历。基于数组的特性，可以使用循环进行对元素进行遍历。

9.1.如何遍历数组；

遍历数组时，获取数组的元素总数可以使用length来获取，具体格式如下：
数组名.length
arr.length
数组长度值不可修改，在数组初始化阶段已经设置完成

二维数组的学习笔记

二维数组的理解：

距离，生活中，比如一层鸡蛋盒里面有十多只鸡蛋，那么可以将此理解成一个普通数组，比如一个教师小组有若干人。

若是一箱油若干层鸡蛋或者一个教师有若干组。这样可以看着是一个大的数组内有若干小数组。

对于此类，我们可以将此定义为二维数组。

1.二维数组的基本概念：

1.1：二维数组可以看做是一种特殊的一维数组，即数组中的元素全部是一维数组；

1.2：二维数组中保存的一维数组必须结构相同，即保存的数组存储的数据类型必须完全相同；

1.3：二维数组的长度仅仅表明其中保存的一维数组的数量，并不能约束其中保存的一维数组的长度；

2.二维数组的内存结构及存储位置：

二维数组可以看成是特殊的一维数组，二维数组内存结构与一维数组内存结构极其相似，只是在一维数组保存的数据方面略有不同；

二维数组数组中的数据均保存在第二维的数组中，因此在访问时，二维数组中每个元素均拥有两个索引值，任意两个数组元素的两个索引值不完全相同；

3.二维数组的格式定义：

3.1：格式1：
数据类型[][]  数组名 ;
int[][]   arr ;double[][]  arr1;
boolean[]  arr2  [];long  arr3 [] [];

3.2：格式2：
数据类型[] [] 数组名 =  new  数据类型[长度] [长度];
int[][] arr = new int[4][5];
double  [][]  arr1 = new double[5][10];
long[][]  errorArray = new int[10][20];

3.3：格式3：
数据类型[][]  数组名 = new  数据类型[][]{{数组元素列表1},{数组元素列表2},……};
int[][] arr = new int[][]{{1,3},{7,9}};
long[][] arr1 = new long[][] {{2,4},{6L,8},{10L,12L}};
long[][]  errorArray = new long[] {{3.14 , 80L}};
int[][] arr2 = new int[][]{};
int[][] arr2 = new int[][]{{},{}};

3.4：格式4：
数据类型[][]  数组名 = {{数组元素列表1}, {数组元素列表2},……};不能分开赋值
int[][]  arr = {{1,3},{5,7}};
int[][]  errorArray1 = {{1,3},5,7,{9,11}};
int[][]  errorArray2 ={1,3,5,7,9};
int[][]  array3 ;
array3 = {{1,3},{5,7}};

4.二维数组数据操作：

4.1数组元素的修改：格式：数组名[第一层索引] [第二层索引] = 值;
int [][]  arr = new int[4][4];       arr[1][1] = 100;

4.2数组元素的读取：

格式：数组名[第一层索引] [第二层索引];
int [][]  arr = new int[4][9];       System.out.println(arr[0][0]);
System.out.println(arr[10][10]);

4.3二维数组的遍历；二维数组的遍历看做是特殊的一维数组，从第一层中取出的数据不是真实数据，而是一个一维数组，然后对取出的数组再进行遍历

小结：

根据二维数组的思想，继续延伸，可以派生出三维数组，四维数组，多维数组，

特性与二维数组基本相同，仅仅在数据访问方面需要提供更多的索引才可以操作最终存储的数据；

常见数组操作中，一般是查找最值或者进行排序；

查找：数组中元素众多，最快速度的查找出需要的数据成为数组操作中的一个重要操作，常用查找方式如下：二分法查找，索引查找法，哈希查找法；

二分查找法：

二分法查找又名折半查找法，首先要保障要查询的数据是有序的，然后与数据总量一半位置处的数据进行比对，以升序排列为例，

如果比对的结果发现查找数据比比对数据大，则在后半段再次重复上述操作，直到找到最终的数据。如果原始数据中不包含要查找的数据，

数据查找将失败，通常返回一个固定的值-1作为查找失败的结果。

public class Lookup {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/**
		 * 二分法查找
		 */
		int a[] = { 23, 45, 98, 100, 110, 120, 140 };
		int search = 120;// 记录要查找的元素
		int lower = 0;// 记录第一个元素
		int temp = a.length - 1;
		int index = -1;
		while (lower <= temp) {
			index = (lower + temp) / 2;// 记录中间元素，用两边之和除2.
			int currentValue = a[index];
			if (currentValue == search) {// 如果得到的数与要查找的数相等则break退出;
				break;
			} else if (currentValue < search) {// 如果得到的数要小于查找的数、就用下标加1;否则减一
				lower = index + 1;
			} else {
				temp = index - 1;
			}
		}
		if (lower <= temp) {
			System.out.println(search + "在数组中第：" + (index + 1) + "位");
		} else {
			System.out.println("里面没有这个元素");
		}
	}
}

最值：最大或者最小值，数组的最值可通过对数组中元素遍历，逐一比对，最终找到数组元素的最值；

排序方式有多中，常见的有冒泡排序和选择排序。

选择排序：

选择排序法是将原始数组空间分为两个部分，第一部分用于存放已经排序完成的数据，第二部分用于存在未完成排序的数据；

实现：排序过程中，每次从未完成排序的区域中找出最大/小值并将其放置到未完成排序区域的首位，

然后改变两个区域的空间大小，并反复上述过程，直到未排序区只有一个数据；

冒泡排序：

冒泡排序法是较为常用的排序方法，日常生活中大多数的排序方案均为冒泡排序法；

实现过程：排序过程中，使用第一个元素与第二个元素进行比较，并将其较大/小的放在后面，然后使用第二个与第三个元素进行比较，重复上述操作，

当数组遍历一轮时，最大/小的元素将置于数组末端；第二轮，改变遍历数组范围，从第一个元素到倒数第二个元素，对其进行上述操作

；第三轮对第一个元素到倒数第三个元素进行上述操作，如此反复，最终对数组实现排序；

public class SortTest {
	public void sort(int[] args) {

		for (int m : args) {
			System.out.print("排序前 " + args[m] + " ");
		}

		int time1 = 0, time2 = 0;
		for (int i = 0; i < args.length - 1; i++) {
			++time1;
			for (int j = i + 1; j < args.length; j++) {
				++time2;
				int temp;
				if (args[i] > args[j]) {
					temp = args[j];
					args[j] = args[i];
					args[i] = temp;
				}
			}
		}
		System.out.println();
		System.out.println("外循环次数：" + time1 + "内循环次数：" + time2);
		for (int n : args) {
			System.out.print("排序后 " + n + " ");
		}
	}

	public static void main(String[] args) {
		int[] arg = new int[] { 2, 1, 4, 5, 8, 7, 6, 3, 9, 0 };
		new SortTest().sort(arg);
	}
}