在Java中数组的概念以及对一个数组进行排序

1、
首先，了解什么是数组。
数组就是存储多个数据的容器，这里面的数据类型必须全部相同。
他的特点：
（1）在Java中，数组中元素的数据类型是相同的；
（2）数组被初始化以后，他在内存中所占的空间就被固定下来了，因此数组的长度是固定的；
（3）即使数组中的内容被清空，但是他所在的内存空间还在，所以，数组的长度依然不变。
定义的方式：
数组类型[] 数组名 = new 数组类型[数组长度或者元素个数];
例如：int[] array = new int[10];//定义一个长度为10的int类型的数组array
遍历数组的方式：
（1）for循环遍历

int[] arr= {2,234,49,85,866,232,2656,333,566};
for( int i = 0;i < arr.length;i++){
		int value = arr[i];//当前遍历到的第i个值
		System.out.println("索引为"+i+"的值为："+value);
	}

（2）增强for循环

int[] arr= {2,234,49,85,866,232,2656,333,566};
for(int value:arr) {
	System.out.println(value);
}

二维数组：
二维数组中的每一个元素是一个一维数组。
二维数组的定义格式：
（1）定义一个3*4的二维数组，其中二维数组长度是3，二维数组中的每一个元素又是一个长度为4的一维数组
int[][] arr = new int[3][4];
（2）只确定了二维数组的长度，但是每一个一维数组的长度不确定
int[][] arr = new int[3][];
（3）直接定义里面的元素
int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
二维数组的遍历：
（1）for循环遍历

int[][] array= {{1,2},{3,4,5,6},{7,8,9}};
for(int i = 0;i < array.length;i++){
	int[] arr = array[i];
	for(int j = 0;j < arr.length;j++){
	System.out.println(arr[j]);
	}
}

（2）增强for循环

int[][] array= {{1,2},{3,4,5,6},{7,8,9}};
for (int[] arr: array) { //arr代表每一次遍历到的一维数组
   for (int value : arr) {
   System.out.println(value);
   }
}

2、下面介绍几种常用的数组的排序：
（1）冒泡排序
他是交换排序的一种，每一次比较两个元素，如果前一个元素大于后一个元素，那就进行交换，进行多次比较之后得出结果。每一次比较之后，最后一个元素就是这一轮中的最大值，所以多次比较结束后就能达到排序的目的。
例如：{1，3，55，7，9，8}
第 0 趟： 找最大值，把最大值放到了数组的最后面
{1，3，55，7，9，8}
{1，3，55，7，9，8}
{1，3，7，55，9，8}
{1，3，7，9，55，8}
{1，3，7，9，8，55}

第 1 趟：
{1，3，7，9，8，55}
{1，3，7，9，8，55}
{1，3，7，9，8，55}
{1，3，7，8，9，55}

第 2 趟：
{1，3，7，8，9，55}
{1，3，7，8，9，55}
{1，3，7，8，9，55}

第 3 趟：
{1，3，7，8，9，55}
{1，3，7，8，9，55}

第 4 趟：
{1，3，7，8，9，55}

综上：我们发现一共要进行5次比较，也就是元素个数-1；每一次又要比较长度-1-次数次，一次可以把它归类成：先按照比较趟数length-1，在比较次数length-1-i来做。
代码如下：

pubilc class BubbleSort{
	public static void main(String[] args){
		//对这个数组进行从小到大排序
		int[] arr= {2,255,565,22,33,697,2356,11644,15};
		for(int i = 0;i < arr.length-1;i++){//表示要进行多少趟比较
			for(int j = 0;j < arr.length-1-i;j++){//表示每一趟要进行多少次比较
				if(arr[j] > arr[j+1]){//如果前一个元素>后一个元素，则进行交换
				int temp = arr[j];//定义一个暂存变量存放原来的数据，避免覆盖后找不着
				arr[j] = arr[j+1];
				arr[j+1] = temp;//arr[j+1]的值应该等于arr[j]没有被覆盖的值
				}	
			}
		}
		System.out.println(Arrays.toString(arr));
	}
}

（2）选择排序
选择排序就是第一次从这个数组中找出一个最小的元素，放在这个数组的最开始位置，之后就从这个元素后面再去找后面这组元素中最小的放到之前那个最小的元素后面，以此类推，直到要排序的元素个数为0。
例如：{1，3，55，7，9，8}
第 0 次：
{1，3，55，7，9，8}

第 1 次：
{1，3，55，7，9，8}

第 2 次：
{1，3，7，55，9，8}

第 3 次：
{1，3，7，8，55，9}

第 4 次：
{1，3，7，8，9，55}

第 5 次：
{1，3，7，8，9，55}

综上：有多少个元素就要进行多少趟比较，每一次就相当于一个循环。
简单选择排序代码如下：

public class SimpleSelectionSort{
	public static void main(String[] args){
	int[] arr = { 200, 255, 565, 22, 2, 33, 697, 2356, 11644, 15 };
		// 要进行多少趟
		for (int i = 0; i < arr.length; i++) {
			// 执行每一趟的操作，即找出剩余元素的最值，第0趟就是从索引位置为0的位置往后找最值
			// 第一趟就是从索引位置为1的元素开始往后找最值
			// 找当前这趟i索引位置的最值
			int min = i;// 假设当前i位置的元素为最值
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[min]) {
					min = j;// 如果比较到的元素比min位置的元素小，就让min的值为当前元素的索引

				}
			}
			if (min != i) {// 如果当前位置不是最值，则需要把当前位置的值和最值进行交换位置
				int temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
			System.out.println("第" + i + "趟找出了" + i + "索引位置的最值：" + arr[i] + ",交换最之后的数组为：" + Arrays.toString(arr));//把每一次的比较打印出来观察每一次比较的结果
		}
		System.out.println(Arrays.toString(arr));
	}
}

（3）插入排序
选择一个数插入到一个数组中使其排序仍然有序，首先要明确插入的位置，其次把数据插入到该位置，该位置原有的数据以后其后面的数据后挪。
例如：{1，3，55，7，9，8} 进行排序：
从前往后依次取出元素，往前面已经排好序的数据中插入
第一次取1：
只有元素 1，我们认为该元素就是有序的
1

第二次取3：
把元素3，往前面的数据堆里面插入，保证插入之后，前面的数据还是有序的；
1，3

第三次取55：
把元素55，往前面的数据堆里面插入，保证插入之后，前面的数据还是有序的；
1，3，55

第四次取7：
把元素7，往前面的数据堆里面插入，保证插入之后，前面的数据还是有序的；
1，3，7，55

第五次取9：
把元素9，往前面的数据堆里面插入，保证插入之后，前面的数据还是有序的；
1，3，7，9，55

第六次取8：
把元素8，往前面的数据堆里面插入，保证插入之后，前面的数据还是有序的；
1，3，7，9，8，55
1，3，7，8，9，55

理论上有多少个数据，就执行多少次的插入，但是对于第一个元素，不需要进行插入操作，因此一共需要进行 数据-1 次插入；

代码如下：

public class InsertionSorttest {
	public static void main(String[] args) {
		int[] arr= {265,33,2,11,56,999,123,55,6};
		for(int i=1;i<arr.length;i++) {//从索引位置1开始往后的所有元素都要执行插入操作，因为索引为0的元素就一个
			int temp=arr[i];//要插入的元素
			System.out.println("要插入的数据："+arr[i]);
			//如果要插入的元素比该元素前面一个位置的元素值还大，说明比前面排好序的任意一个都大
			//则不需要进行插入操作，否则进行插入
			if(temp<arr[i-1]) {//轮流跟前面的元素比较寻找插入点	
				int j;
				//执行后挪操作和表示没有找到插入点，当不在执行循环里面后移操作的时候，
				//表示找到插入点，哪个元素不后移,不后移的元素后面一个位置就是插入点
				//而不执行循环的那个j索引就是不执行后移的元素
				for(j=i-1;j>=0 && temp<arr[j];j--) {
					arr[j+1]=arr[j];
				}
				//插入点是j+1，原因是本次循环结束之后，执行了迭代操作j--
				System.out.println("插入点索引："+(j+1));
				arr[j+1]=temp;
			}
		}
		System.out.println(Arrays.toString(arr));		
	}
}