数组，可以说数组几乎能表示一切的数据结构，在每一门编程语言中，数组都是重要的数据结构，当然每种语言对数组的实现和处理也不相同，但是本质是都是用来存放数据的的结构。
1：数组：
在Java中，数组是用来存放同一种数据类型的集合，注意只能存放同一种数据类型。
①、数组的声明
第一种方式：
|
1
|
数据类型 [] 数组名称 =
new
数据类型[数组长度];
|
第一种方式：
|
1
|
数据类型 [] 数组名称 =
new
数据类型[数组长度];
|
这里 [] 可以放在数组名称的前面，也可以放在数组名称的后面，我们推荐放在数组名称的前面，这样看上去 数据类型 [] 表示的很明显是一个数组类型，而放在数组名称后面，则不是那么直观。
第二种方式：
|
1
|
数据类型 [] 数组名称 = {数组元素
1
，数组元素
2
，......}
|
这种方式声明数组的同时直接给定了数组的元素，数组的大小有给定的数组元素个数决定。
|
1
2
3
4
|
//声明数组1,声明一个长度为3，只能存放int类型的数据
int
[] myArray =
new
int
[
3
];
//声明数组2,声明一个数组元素为 1,2,3的int类型数组
int
[] myArray2 = {
1
,
2
,
3
};
|
②、访问数组元素以及给数组元素赋值
数组是存在下标索引的，通过下标可以获取指定位置的元素，数组小标是从0开始的，也就是说下标0对应的就是数组中第1个元素，可以很方便的对数组中的元素进行存取操作。
前面数组的声明第二种方式，我们在声明数组的同时，也进行了初始化赋值。
|
1
2
3
4
5
6
|
//声明数组,声明一个长度为3，只能存放int类型的数据
int
[] myArray =
new
int
[
3
];
//给myArray第一个元素赋值1
myArray[
0
] =
1
;
//访问myArray的第一个元素
System.out.println(myArray[
0
]);
|
上面的myArray 数组，我们只能赋值三个元素，也就是下标从0到2，如果你访问 myArray[3] ，那么会报数组下标越界异常。
③、数组遍历
数组有个 length 属性，是记录数组的长度的，我们可以利用length属性来遍历数组。
|
1
2
3
4
5
|
//声明数组2,声明一个数组元素为 1,2,3的int类型数组
int
[] myArray2 = {
1
,
2
,
3
};
for
(
int
i =
0
; i < myArray2.length ; i++){
System.out.println(myArray2[i]);
}
|
数组常见算法：
1:冒泡排序：
冒泡算法的运作规律如下：
①、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
②、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数（也就是第一波冒泡完成）。
③、针对所有的元素重复以上的步骤，除了最后一个。
④、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
package test; public class array { public static void main(String[] arg){ int flag; int [] intarray={12,5,3,7,5,9,10,4,89}; for(int i=0;i<intarray.length;i++){ for(int j=i+1;j<intarray.length;j++){ if (intarray[j]<intarray[i]) { flag=intarray[i]; intarray[i]=intarray[j]; intarray[j]=flag; } } } for (int name:intarray){ System.out.print(name+"'"); } } }
输出结果为：
3'4'5'5'7'9'10'12'89'
冒泡排序解释：
冒泡排序是由两个for循环构成，第一个for循环的变量 i 表示总共需要多少轮比较，第二个for循环的变量 j 表示每轮参与比较的元素下标【0,1，......，length-i】，因为每轮比较都会出现一个最大值放在最右边，所以每轮比较后的元素个数都会少一个，这也是为什么 j 的范围是逐渐减小的。相信大家理解之后快速写出一个冒泡排序并不难。
冒泡排序性能分析：
假设参与比较的数组元素个数为 N，则第一轮排序有 N-1 次比较，第二轮有 N-2 次，如此类推，这种序列的求和公式为：
（N-1）+（N-2）+...+1 = N*（N-1）/2
当 N 的值很大时，算法比较次数约为 N2/2次比较，忽略减1。
假设数据是随机的，那么每次比较可能要交换位置，可能不会交换，假设概率为50%，那么交换次数为 N2/4。不过如果是最坏的情况，初始数据是逆序的，那么每次比较都要交换位置。
交换和比较次数都和N2 成正比。由于常数不算大 O 表示法中，忽略 2 和 4，那么冒泡排序运行都需要 O(N2) 时间级别。
其实无论何时，只要看见一个循环嵌套在另一个循环中，我们都可以怀疑这个算法的运行时间为 O(N2)级，外层循环执行 N 次，内层循环对每一次外层循环都执行N次（或者几分之N次）。这就意味着大约需要执行N2次某个基本操作。
2：选择排序：
选择排序是每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
分为三步：
①、从待排序序列中，找到关键字最小的元素
②、如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换
③、从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束
package test; public class array { public static void main(String[] arg){ int flag; int [] intarray={12,11,3,7,5,9,10,4,89}; for(int i=0;i<intarray.length-1;i++){ int min =i; for(int j=i+1;j<intarray.length;j++){ if(intarray[min]>intarray[j]){ min=j; } } if(i!=min){ flag=intarray[min]; intarray[min]=intarray[i]; intarray[i]=flag; } } for (int name:intarray){ System.out.print(name+"'"); } } }
输出结果为：
3'4'5'7'9'10'11'12'89'
选择排序性能分析：
选择排序和冒泡排序执行了相同次数的比较：N*（N-1）/2，但是至多只进行了N次交换。
当 N 值很大时，比较次数是主要的，所以和冒泡排序一样，用大O表示是O(N2) 时间级别。但是由于选择排序交换的次数少，所以选择排序无疑是比冒泡排序快的。当 N 值较小时，如果交换时间比选择时间大的多，那么选择排序是相当快的。
3：插入排序：
直接插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
插入排序还分为直接插入排序、二分插入排序、链表插入排序、希尔排序等等，这里我们只是以直接插入排序讲解，后面讲高级排序的时候会将其他的。
int
j;
//从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
for
(
int
i =
1
; i < array.length ; i++){
int
tmp = array[i];
//记录要插入的数据
j = i;
while
(j >
0
&& tmp < array[j-
1
]){
//从已经排序的序列最右边的开始比较，找到比其小的数
array[j] = array[j-
1
];
//向后挪动
j--;
}
array[j] = tmp;
//存在比其小的数，插入
}
return
array;
}
在第一轮排序中，它最多比较一次，第二轮最多比较两次，一次类推，第N轮，最多比较N-1次。因此有 1+2+3+...+N-1 = N*（N-1）/2。
假设在每一轮排序发现插入点时，平均只有全体数据项的一半真的进行了比较，我们除以2得到：N*（N-1）/4。用大O表示法大致需要需要 O(N2) 时间级别。
复制的次数大致等于比较的次数，但是一次复制与一次交换的时间耗时不同，所以相对于随机数据，插入排序比冒泡快一倍，比选择排序略快。
这里需要注意的是，如果要进行逆序排列，那么每次比较和移动都会进行，这时候并不会比冒泡排序快。
4：总结：
上面讲的三种排序，冒泡、选择、插入用大 O 表示法都需要 O(N2) 时间级别。一般不会选择冒泡排序，虽然冒泡排序书写是最简单的，但是平均性能是没有选择排序和插入排序好的。
选择排序把交换次数降低到最低，但是比较次数还是挺大的。当数据量小，并且交换数据相对于比较数据更加耗时的情况下，可以应用选择排序。
在大多数情况下，假设数据量比较小或基本有序时，插入排序是三种算法中最好的选择。
后面我们会讲解高级排序，大O表示法的时间级别将比O(N2)小。