声明：由于学习环境为JDK1.8,所有有关Java的代码均在JDK1.8环境中测试通过，若环境发生变换，代码可能会发生错误。
本周的学习难度较上周有明显提升，今天所学习的排序算法有很多需要理解的地方，今后还需多加练习和使用。
一：数组拷贝
System类中有一个静态方法：
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
上面的参数意思依次为：源数组，源数组的起始位置，目标数组，目标数组的起始位置，拷贝的数组元素个数
课堂练习：
package copy;
public class ArrayCopy {
public static void main(String[] args) {
int[] a={1,2,3,4,5,6,7,8,9};
int[] b={11,22,33,44,55,66,77,88,99};
System.arraycopy(a,1,b,4,3);
System.out.println("复制后的数组：");
for (int i = 0; i < b.length; i++) {
System.out.print(b[i]+" ");
}
}
}
运行结果：
二：排序算法
1.冒泡排序：共有n个数据，则需要进行n-1趟排序(可优化)，每一趟排序都会通过“两两交换”的方式对数据进行比
较，每一趟排序后都会将本趟排序的最大值“冒”到后面。
课堂练习：
package com.abc;
public class BubbleSort {
public static void main(String[] args) {
int[] a={55,33,22,66,11,88,44,99,77};
bubbleSort(a);
}
public static void bubbleSort(int[] a){
for(int i=1;i<=a.length-1;i++){
for(int j=0;j<a.length-i;j++){
if(a[j+1]<a[j]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
System.out.println("第"+i+"次交换，结果是");
for(int x:a){
System.out.print(x+" ");
}
System.out.println();
}
}
}
运行结果：
2. 插入排序：对一个有n个元素的数据序列，排序需要进行n-1趟插入操作(可优化)。
第一趟插入将第2个元素插入前面的有序子序列(此时前面只有一个元素)。
第二趟插入将第3个元素插入前面的有序子序列，前面两个元素是有序的。
第n-1趟插入将第n个元素插入前面的有序子序列，前面n-1个元素是有序的。
课堂练习：
package com.abc;
public class InsertSort {
public static void main(String[] args) {
int[] a={44,33,77,66,11,99,88,55};
insertSort(a);
System.out.println("排序后的结果是：");
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
public static void insertSort(int[] a){
for(int i=1;i<=a.length-1;i++){
int data=a[i];
int j=i-1;
while(j>=0 && data<a[j]){
a[j+1]=a[j];
j--;
}
a[j+1]=data;
}
}
}
运行结果：
3. 快速排序：从待排序的数据序列中任取一个数据(如第一个数据)作为分界值，所有比它小的数据元素放到左边，所
有比它大的数据元素放到它的右边。
接下来，对左右两个子序列按照上述方法进行递归排序，直到排序完成。
课堂练习：
package com.abc;
public class QuickSort {
public static void main(String[] args) {
int[] a={33,44,11,66,55,99,22};
quickSort(a,0,a.length-1);
for(int i=0;i<=a.length-1;i++){
System.out.print(a[i]+" ");
}
}
public static void quickSort(int[] array,int start,int end){
if(end<=start){
return;
}
int data=array[start];
int i=start+1;
int j=end;
while(true){
while(i<=end && array[i]<=data){
i++;
}
while(j>=start+1 && array[j]>=data){
j--;
}
if(j>i){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}
else{
break;
}
}
array[start]=array[j];
array[j]=data;
quickSort(array,start,j-1);
quickSort(array,j+1,end);
}
}
运行结果：
三：二维数组
1.二维数组的声明与实例化：数据类型[][]
数组名称=new 数据类型[行的个数][列的个数];
注意：二维数组的length属性就是它所包含的“行的个数”。
二维数组访问具体元素的语法： 数组名称[行的索引][列的索引]
eg.String[][] array=new String[4][3];
array[0][0]="风清扬";
array[0][1]="孙武";
array[0][2]="曼施坦因";
array[1][0]="马云";
array[1][1]="猪八戒";
array[2][0]="王健林";
array[2][1]="小王子";
array[3][2]="扫地僧";
声明了一个4行3列的二维数组，其中数组各个位置的元素如上，未被实例化的位置将被置为null
2.二维数组的静态初始化
数据类型[][] 数组名称={
{元素1,元素2,....},
{元素1,元素2,....},
...
};
eg.
String[][] array={
{"Apple","Orange","Banana"},
{"Dog","Cat"},
{"Phone","Machine","Book","Java","兵法"}
这样声明的数组元素固定，每行的长度互相不受影响