（一）排序：
这里所说的三种排序都是内部排序： 冒泡排序，插入排序，选择排序
1： 冒泡排序：
冒泡排序使之将相邻的两个数值相互比较，第一个数值比第二个大就交换位置，将最大的数值沉到最底下， 每一次这样循环一次之后都会有一个最大的数在后面，每确定一个最大的数，那个数在最后面不动它，这是内循环 然后将外循环的次数减少一次。
// 优化后的冒泡排序
// 最好情况时间复杂度：o(n)
// 最坏情况时间复杂度：o(n^2)
// 稳定性：稳定
public static int[] bubbleSout(int[] array) {
int i, j;
boolean swap = false;
for (i = 0; i < array.length - 1; i++) { // 用 i 控制外层循环
for (j = 0; j < array.length - 1 - i; j++) { // 用 j 控制内层循环，j< array.length-1-i; 是因为，再次排序之后内循环的次数要减少一次
if (array[j] > array[j + 1]) { // 如果前面的数大于后面的数，二者交换位置
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
swap = true; // 此处使用boolean变量来检查是否第一遍循环过程是否交换过数值，也就是说检验原始数据是否已经是有序数据
}
}
if (swap) { //优化代码 // 如果swap没有变换，说明原始数据是有序数据，
break;
}
}
return array;
}
(2) : 插入排序：
插入排序从下表为1 的数值开始，依次和前面的数比较大小，大的数依次往后挪，小的数直接将要排序的数放到这个数后面
//插入排序
// 最好情况时间复杂度：o(n)
// 最坏情况时间复杂度：o(n^2)
// 稳定性：稳定
public static int[] insertSort(int[] array) {
int i, j;
int temp;
for (i = 1; i < array.length; i++) { // 用 i 控制外层循环
temp = array[i]; // 将用插入比较的值放到temp 临时变量中去
for (j = i - 1; j >= 0; j--) { // 用 j 控制内层循环，依次向前走
if (array[j] > temp) { // 如果temp小于当前数值，
array[j + 1] = array[j]; //就将大的数往后挪
} else {
break; // 如果不是，则停止循环
}
}
array[j+1] = temp; // 直接将temp也就是要插入的数放到该数后面
}
return array;
}
(3): 选择排序:
选择排序相对简单一些，就是讲数字依次与后面的数值比较，将大的换到后面，小的挪到前面。
//选择排序
// 最好情况时间复杂度：o(n^2)
// 最坏情况时间复杂度：o(n^2)
// 稳定性：不稳定
public static int [] selectSort(int [] array) {
int i, j;
for (i = 0; i < array.length; i++) {
for (j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) { // 每一次循环结束后都有一个小的数字放到前面去。
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
return array;
}
二： 多维数组：
（1）：
多为数组同一维数组一样，在使用new初始化之前，并不能使用它，
声明一个多位数组：
数据类型 [ ] [ ] balance =new 数据类型 [ ] [ ] ；
（2）： 初始化：
对于规则的基本类型多维数组，初始化为0；
对于引用类型的多维数组，初始化为null；
/ /数组的静态初始化
int[][] a= {{1,2,3},{4,4,4},{5,5,5}};
//数组的动态初始化
int[][] b=new int[3][];
a[0] = new int[2];
a[1] = new int[2];
a[2] = new int[2];
a[0][0]=0;
a[0][1]=0;
a[1][0]=1;
a[1][1]=1;
a[2][0]=2;
a[2][1]=2;
（2）：多维数组的打印：
调用Arrays.deepToString( ); 方法；不过需要注意的是，如果不是基本数据类型，只能打印出地址；
（3）： 四种拷贝方式对多维数组的拷贝都属于浅拷贝：
一张图解析：
第一层数组只是存储了第二层数组的地址，所以此处的尽管使用for循环拷贝，System.arraycopy()方法、clone（）方法、Arrays.copyof（）方法都只是将第一层数组内储存的地址值引用过来，所以都是浅拷贝。
public static void main9(String[] args) {
TestArray[] t1 = new TestArray[4];
t1[0] = new TestArray();
t1[1] = new TestArray();
t1[2] = new TestArray();
t1[3] = new TestArray();
// 使用copyOf方法拷贝引用类型的数组：
TestArray[] t2 = Arrays.copyOf(t1,t1.length);
// 用arraycopy方法
TestArray[] t3 = new TestArray[4];//t2[0]
//用clone方法拷贝数组
System.arraycopy(t1,0,t3,0,t1.length);
TestArray[] t4 = t1.clone();//t4[0]
// 用for循环拷贝数组
TestArray[] t5 = new TestArray[4];//t2[0]
for(int i = 0;i < t1.length;i++) {
t5[i] = t1[i];
}
}