1.数组

　　概念：同一种类型数据的集合。其实就是数组就是一个容器。

　　好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

　　格式：

　　①. 元素类型[] 数组名 = new 元素类型[元素个数或数组长度];　　例：int[] arr = new int[5];

　　②.元素类型[] 数组名 = new 元素类型[]{元素，元素，....};  例：int[] arr = new int[]{3,5,1,7}; 或者 int[] arr = {3,5,1,7};

　　常见异常：

　　①.ArrayIndexOutOfBoundsException:　　//当访问到数组中不存在的索引时，就会发生该异常。

　　②.NullPointerException:　　//当引用型变量没有任何实体指向指向时，还在用其操作实体。就会发生该异常。

　　③.[I@c17164　　//哈希数地址，@左边部分是实体的类型，这里代表整型数组；@右边是实体的哈希值。

2.数组常见操作

　　①.获取最值（最大值，最小值）

//方法一：值比较
public static int getMax(int[] arr)
{
	//定义变量记录较大的值。
	int maxElement = arr[0];//初始化为数组中的任意一个元素。
	for(int x=1; x<arr.length; x++)
	{
		if(arr[x]>maxElement)
				maxElement = arr[x];
	}
	return maxElement;
}

//方法二：索引比较
public static int getMax_2(int[] arr)
{
	//定义变量记录较大的值。
	int maxIndex = 0;//初始化为数组中任意一个角标。
	for(int x=1; x<arr.length; x++)
	{
		if(arr[x]>arr[maxIndex])
			maxIndex = x;
	}
	return arr[maxIndex];
}

　　②.排序（选择排序，冒泡排序） Java中排序可用字典排序sort(byte[]) 进行排序

//交换数据
public static void swap(int[] arr,int a,int b)
{
	int temp = arr[a];
	arr[a] = arr[b];
	arr[b] = temp;
}

/*
选择排序。0-1，0-2，0-3
*/
public static void selectSort(int[] arr)
{
	for(int x=0; x<arr.length-1; x++)
	{
		for(int y=x+1; y<arr.length; y++)
		{
			if(arr[x]>arr[y])
			{
				swap(arr,x,y);
			}
		}
	}
}
/*
选择排序。索引法
*/
public static void selectSort_2(int[] arr)
{
	for(int x=0; x<arr.length-1; x++)
	{
		int num = arr[x];
		int index = x;
		for(int y=x+1; y<arr.length; y++)
		{
			if(num>arr[y])
			{
				num = arr[y];
				index = y;
			}
		}
		if(index!=x)
			swap(arr,x,index);
	}
}
/*
冒泡排序。0-1，1-2，2-3
*/
//方法①.
public static void bubbleSort(int[] arr)
{
	for(int x=0; x<arr.length-1; x++)
	{
		for(int y=0; y<arr.length-1-x; y++)	//此处-1为了避免索引越界。-x为了让外循环增加一次，内循环参数与比较的元素个数递减。
		{
			if(arr[y]>arr[y+1])	
			{
				swap(arr,y,y+1);
			}
		}	
	}
}
//方法②
public static void bubbleSort_2(int[] arr)
{
	for(int x=arr.length-1;x>0;x--)
	{
		for(int y=0;y<x;y++)
		{　　　　　　　　　　　　　　
			if(arr[y]>arr[y+1])	
			{
				swap(arr,y,y+1);
			}　　　　　　　　　
		}
	}
}

③.查找（基本查找、二分查找）

/*
数组常见功能：基本查找法。
*/
public static int getIndex(int[] arr,int key)
{
	for(int x=0; x<arr.length; x++)
	{
		if(arr[x]==key)
			return x;
	}
	return -1;
}

/*
二分查找法（折半查找法）
*/
public static int halfSearch(int[] arr,int key)		//查找的数组须有顺序的！
{
	int max,min,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(max<min)
			return -1;
		mid = (max+min)/2;
	}
	return mid;
}

public static int halfSearch_2(int[] arr,int key)    //方法二,采用最大值最小大小比较
{
	int max,min,mid;
	min = 0;
	max = arr.length-1;
	while(min<=max)
	{
		mid = (max+min)>>1;
		if(key>arr[mid])
			min = mid + 1;
		else if(key<arr[mid])
			max = mid - 1;
		else
			return mid;
	}
	return -min-1;
}

注意：折半查找需要是有序序列，如果原本数据不是有序的，不能采用排序再查找，这样会破坏原来表索引。方法类似java中提供的binarySearch(arr,num),其中arr为数组，num为要查找的数，如果查找不到即返回-插入点-1。

④.进制转换

public static void trans(int num,int base,int offset)
{
	if(num==0)
	{
		System.out.println("0");
		return ;
	}
	//定义一个对应关系表。
	char[] chs = {'0','1','2','3',
			'4','5','6','7',
			'8','9','A','B',
			'C','D','E','F'};
	/*
	一会查表会查到比较的数据。
	数据一多，就先存储起来，在进行操作。
	所以定义一个数组。 临时容器。
	*/
	char[] arr = new char[32];
	int pos = arr.length;
	while(num!=0)
	{
		int temp = num & base;
		arr[--pos] = chs[temp];
		num  = num >>> offset;
	}
	for(int x=pos ;x<arr.length; x++)
	{
		System.out.print(arr[x]);
	}
	System.out.println();
}

//十进制-->十六进制。 Integer.toHexString
public static void toHex(int num)
{
	trans(num,15,4);
}
//十进制-->二进制。 Integer.toBinaryString
public static void toBinary(int num)
{
	trans(num,1,1);
}
//十进制-->八进制。 Integer.toOctalString
public static void toOctal(int num)
{
	trans(num,7,3);
}

注：查表法：如果数据出现了对应关系，而且对应关系为一方是有序的数字编号，并作为索引使用，这时应想到采用数组的使用，将这些数据存储到数组中，根据运算结果作为索引之间去查数组中对应的元素即可。

3.二维数组

二维数组图解：

二维数组的操作：

//		int[] arr = new int[3];  
//		System.out.println(arr);//[I@1fb8ee3  @左边是实体的类型。 @右边是实体的哈希值。

//		int[][] arr = new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素。
//		System.out.println(arr);//直接打印二维数组。   [[I@c17164
//		System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。 [I@1fb8ee3
//		System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 0



//		int[][] arr = new int[3][];
//		System.out.println(arr);//直接打印二维数组。   [[I@c17164
//		System.out.println(arr[0]);//直接打印二维数组中的角标0的一维数组。null
//		System.out.println(arr[0][0]);//直接打印二维数组中的角标0的一维数组中角标为0的元素。 NullPointerException


	
//		int[][] arr = new int[3][2];
//		System.out.println(arr.length);//打印二维数组的长度。其实就是一维数组的个数。
//		System.out.println(arr[1].length);//打印二维数组中角标为1一维数组的长度。

		int sum = 0;
		int[][] arr = {{3,1,7},{5,8,2,9},{4,1}};

		for(int x=0; x<arr.length; x++)
		{
			for(int y=0; y<arr[x].length; y++)
			{
//				System.out.print(arr[x][y]+",");
				sum += arr[x][y];
				
			}
		}
		System.out.println("sum="+sum);

附一：

　　内存的划分：

　　1.寄存器。

　　2.本地方法区。（跟系统有关系）

　　3.方法区。

　　4.栈内存。

　　　　存储的都是局部变量，而且变量所属的作用域一旦结束，该变量就自动释放。

　　5.堆内存。

　　　　存储是数组和对象（其实数组就是对象） 凡是new建立在堆中。

　　　　特点：

　　　　1，每一个实体都有首地址值。

　　　　2，堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数是0，小数是0.0或者0.0f，boolean false，char '\u0000'。

　　　　3，垃圾回收机制。