Java常用基本算法
4.1 算法
前面我们已经讲过，程序=数据结构+算法。
什么是算法？对一个现有的问题我们采取的解决过程及方法，即为算法。一个用算法实现的程序会耗费两种资源：处理时间和内存。
算法的效率分析标准：
时间复杂度
空间复杂度
简单性和清晰性
对于时间复杂度，可以通过System.currentTimeMillis()方法来测试。例如：public class Test
{
public static void main(String args[])
{
System.out.println(System.currentTimeMillis());
fun();
System.out.println(System.currentTimeMillis());
}
public static void fun()
{
double a = 0;
for(int i = 0; i < 10000; i++)
for(int j = 0; j < 10000; j++)
for(int k = 0; k < 100; k++)
a++;
}
}
前后两次获得当前系统时间的差值就是运行所消耗的时间（毫秒为单位）。
通过System.currentTimeMillis()方法来测试的缺点：
a.不同的平台执行的时间不同
b.有些算法随着输入数据的加大，测试时间会变得不切实际！
4.2 查找
4.2.1 查找之线性查找（直接查找）
算法思路：从数组的第一个元素开始查找，并将其与查找值比较，如果相等则停止，否则继续下一个元素查找，直到找到匹配值。
注意：被查找的数组中的元素可以是无序的、随机的。
实例：
import java.util.*;
public class Demo1
{
public static void main(String args[])
{
int iArr[] = {32, 9, 78, 44, 29, 18, 97, 49, 56, 61};
System.out.println("数组的所有元素为：");
for(int i : iArr)
System.out.print(i + " ");
System.out.println();
System.out.print("请输入你要查找的元素：");
Scanner scan = new Scanner(System.in);
int iNum = scan.nextInt();
int index = straightSearch(iArr, iNum);
if(index == -1)
System.out.println("没有找到元素" + iNum);
else
System.out.println("找到元素" + iNum + ", 下标为:" + index);
}
public static int straightSearch(int[] arr, int num)
{
int i = 0;
for(; i < arr.length; i++)
{
if(arr[i] == num)
return i;
}
return -1;
}
}
4.2.2 查找之折半查找（二分查找）
算法思路：假设被查找数组中的元素是升序排列的，那我们查找值时，首先会直接到数组的中间位置(数组长度/2)，并将中间值和查找值比较，如果相等则返回，否则，如果当前元素值小于查找值，则继续在数组的后面一半查找(重复上面过程)；如果当前元素值大于查找值，则继续在数组的前面一半查找，直到找到目标值或者无法再二分数组时停止。
注意：二分查找只是针对有序排列的各种数组或集合。
实例：
//不利用递归实现
import java.util.*;
public class Demo1
{
public static void main(String args[])
{
int iArr[] = {1, 2, 3, 4, 6, 8, 22, 44, 99, 111, 112, 116};
System.out.println("数组的所有元素为：");
for(int i : iArr)
System.out.print(i + " ");
System.out.println();
System.out.print("请输入你要查找的元素：");
Scanner scan = new Scanner(System.in);
int iNum = scan.nextInt();
int index = binarySearch(iArr, iNum, 0, iArr.length-1);
if(index == -1)
System.out.println("没有找到元素" + iNum);
else
System.out.println("找到元素" + iNum + ", 下标为:" + index);
}
public static int binarySearch(int[] arr, int num, int iMin, int iMax)
{
while(iMin <= iMax)
{
int iMid = (iMin + iMax) / 2;
if(num == arr[iMid])
return iMid;
else if(num < arr[iMid])
iMax = iMid-1;
else
iMin = iMid+1;
}
return -1;
}
}
//利用递归实现
import java.util.*;
public class Demo1
{
public static void main(String args[])
{
int iArr[] = {1, 2, 3, 4, 6, 8, 22, 44, 99, 111, 112, 116};
System.out.println("数组的所有元素为：");
for(int i : iArr)
System.out.print(i + " ");
System.out.println();
System.out.print("请输入你要查找的元素：");
Scanner scan = new Scanner(System.in);
int iNum = scan.nextInt();
int index = binarySearch(iArr, iNum, 0, iArr.length-1);
if(index == -1)
System.out.println("没有找到元素" + iNum);
else
System.out.println("找到元素" + iNum + ", 下标为:" + index);
}
public static int binarySearch(int[] arr, int num, int iMin, int iMax)
{
int iMid = (iMin + iMax) / 2;
if (num < arr[iMin] || num > arr[iMax])
return -1;
else if (num == arr[iMid])
return iMid;
else if (num < arr[iMid])
return binarySearch(arr, num, iMin, iMid - 1);
else
return binarySearch(arr, num, iMid + 1, iMax);
}
}
4.3 排序
4.3.1 排序之插入排序
4.3.1.1 插入排序之直接插入排序
算法思路：直接插入排序(straight insertion sort)是一种最简单的排序方法。它的基本操作是将一个记录插入到一个长度为m (假设)的有序表中，使之仍保持有序，从而得到一个新的长度为m + 1的有序表。设有一组关键字｛K1 ，K2 ，…，Kn｝；排序开始就认为K1 是一个有序序列；让K2 插入上述表长为 1 的有序序列，使之成为一个表长为 2 的有序序列；然后让K3 插入上述表长为 2 的有序序列，使之成为一个表长为 3 的有序序列；依次类推，最后让Kn插入上述表长为n-1 的有序序列，得一个表长为n 的有序序列。
实例：
//49, 38, 65, 97, 76, 13, 27 初始情况
//[49], 38, 65, 97, 76, 13, 27 从下标1开始
//[38, 49], 65, 97, 76, 13, 27
//[38, 49, 65], 97, 76, 13, 27
//[38, 49, 65, 97], 76, 13, 27
//[38, 49, 65, 76, 97], 13, 27
//[13, 38, 49, 65, 76, 97], 27
//[13, 27, 38, 49, 65, 76, 97]
代码实现：
public class Test
{
public static void main(String [] args){
int a[] = {49, 38, 65, 97, 76, 13, 27};
straightInsertSort(a);
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
}
public static void straightInsertSort(int a[]){
int i, m;
for (i = 1; i < a.length; i++) //共进行n-1趟插入
{
m = i;
while (m >= 1 && a[m] < a[m-1]) //短路表达式
{
a[m] = (a[m]+a[m-1]) - (a[m-1] = a[m]); //比前一个小, 则与之交换
m--;
}
}
}
}
4.3.1.2 插入排序之折半插入排序
算法思路：折半插入排序(Binary insertion sort)当直接插入排序进行到某一趟时，对于a[i]来讲，前边i-1个记录已经按有序。此时不用直接插入排序的方法，而改为先用折半查找法找出r[i]应插的位置，然后再插入。这种方法就是折半插入排序。
基本步骤：
a、初始化：设定有序区为第一个元素，设定无序区为后面所有元素
b、依次取无序区的每个元素
c、通过二分法查找有序区，返回比这个数小的最大数
d、保留此位置数据
e、从此位置的元素到有序区的最后一个元素，依次后移
f、用保留的数据填充此位置
代码实现：
public class Test
{
public static void main(String [] args){
int a[] = {49, 38, 65, 97, 76, 13, 27};
binaryInsertSort(a);
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
System.out.println();
}
public static void binaryInsertSort(int a[]){
for (int i = 1; i < a.length; i++) //共进行n-1趟插入
{
int iTmp = a[i]; //将待插入数据临时保存到iTmp中去.
int m = findPosition(a, a[i], 0, i - 1); //m是a[i]应该呆的位置
for (int j = i; j > m; j--)
a[j] = a[j-1]; //整体向后移动一个位置
a[m] = iTmp; //m是a[i]应该呆的位置
}
}
public static int findPosition(int a[], int num, int iMin, int iMax)
{
if (num < a[iMin])
return iMin; //超出范围,直接返回
if (num > a[iMax])
return iMax + 1; //超出范围,直接返回
int iMid = (iMin + iMax) / 2; //选取中值,准备二分
if (a[iMid] >= num) //继续二分: 递归
return findPosition(a, num, iMin, iMid - 1); //目标在左边,递归左边(p[m]已经比较过,排出查找范围)
else //if (a[m] < num)
return findPosition(a, num, iMid + 1, iMax); //目标在右边,递归右边(p[m]已经比较过,排出查找范围)
}
}
4.3.1.3 插入排序之希尔排序
算法思路：希尔排序(Shell Sort): 是插入排序的一种。因D．L．Shell于1959年提出而得名。先取一个小于数组长度n的整数d1(一般为n/2)作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2 代码实现： public class Test { public static void main(String [] args){ int a[] = {49, 38, 65, 97, 76, 13, 27}; shellSort(a); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println(); } public static void shellSort(int a[]){ int k = a.length / 2; //k值代表前文中的增量d值 while (k >= 1) //当增量k值变化到0，结束循环 { for (int i = 0; i < k; i++) //将数组分成k组, 然后对每组进行直接插入排序. { for (int j = i+k; j < a.length; j += k) //共进行? 趟插入 { int m = j; while (m >= k && a[m] < a[m-k]) //短路表达式 { a[m] = (a[m]+a[m-k]) - (a[m-k]=a[m]); //比前一个小, 则与之交换 m -= k; } } } k = k / 2; } } } 4.3.2 排序之选择排序 4.3.2.1 选择排序之直接选择排序 算法思路：简单选择排序(simple selection sort)也是直接选择排序。是一种较为容易理解的方法。对于一组关键字{K1,K2,…,Kn}，首先从K1,K2,…,Kn中选择最小值，假如它是Kz，则将Kz与K1对换；然后从K2，K3，…，Kn中选择最小值Kz，再将Kz与K2对换。如此进行选择和调换n-2趟，第(n-1)趟，从Kn-1、Kn中选择最小值Kz将Kz与Kn-1对换，最后剩下的就是该序列中的最大值，一个由小到大的有序序列就这样形成。 代码实现： public class Test { public static void main(String [] args){ int a[] = {49, 38, 65, 97, 76, 13, 27}; simpleSelectSort(a); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println(); } public static void simpleSelectSort(int a[]){ for(int i = 1; i < a.length; i++) { int iMax = 0; for(int j = 1; j <= a.length - i; j++) { if(a[j] > a[iMax]) iMax = j; } if(iMax != a.length-i) a[iMax] = (a[iMax]+a[a.length-i]) - (a[a.length-i]=a[iMax]); } } } 4.3.3 排序之交换排序 4.3.3.1 交换排序之冒泡排序 算法思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。 在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。 代码实现： public class Test { public static void main(String [] args){ int a[] = {49, 38, 65, 97, 76, 13, 27}; bubbleSort(a); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println(); } public static void bubbleSort(int a[]){ for(int i = 1; i < a.length; i++) { for(int j = 0; j < a.length - i; j++) { if(a[j] > a[j+1]) a[j] = (a[j]+a[j+1]) - (a[j+1]=a[j]); } } } } 4.3.3.2 交换排序之双向冒泡排序 算法思路：是冒泡排序的升级。双向冒泡是一个大泡从头往后冒，一个小泡从后往前冒。相对冒泡排序可减少时间。 代码实现： public class Test { public static void main(String [] args){ int a[] = {49, 38, 65, 97, 76, 13, 27}; doubleBubbleSort(a); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println(); } public static void doubleBubbleSort(int a[]){ int n = a.length; for(int i = 1; i <= n/2; i++) { for(int j = i-1; j < n - i; j++) { if(a[j] > a[j+1]) a[j] = (a[j]+a[j+1]) - (a[j+1]=a[j]); if(a[n-1-j] < a[n-2-j]) a[n-1-j] = (a[n-1-j]+a[n-2-j]) - (a[n-2-j]=a[n-1-j]); } } } } 4.3.3.3 交换排序之快速排序 算法思路：快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过"一趟排序"将要排序的数据分割成独立的两部分，其中左部分的所有数据都比右部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 算法过程：设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。 一趟快速排序的算法是： 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；注意该key值在整个过程中永远不变，始终是和key进行比较。 3）从j开始由后向前搜索，找到第一个小于key的值A[j]，并与A[i]交换； 4）从i开始由前向后搜索，找到第一个大于key的值A[i]，并与A[j]交换； 5）重复第3、4步，直到i=j； 注意: 3)和4)步是在程序中没找到时候才j--和i++，直至找到为止。找到并交换的时候i 和j指针位置不变。 值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 一趟快排演示： key = 49 49i 38 65 97 76 13 27j 先找j开始，发现27比key小，交换i、j的值 27i 38 65 97 76 13 49j 再从i开始，发现27和38都比key小，即i++ 27 38 49i 97 76 13 65j 直到i对应的值比key大，则i、j交换 27 38 13i 97 76 49j 65 以此类推 27 38 13 49i 76 97j 65 27 38 13 49ij 76 97 65 代码实现： public class Test { public static void main(String [] args){ int a[] = {49, 38, 65, 97, 76, 13, 27}; quickSort(a, 0, a.length-1); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println(); } public static void quickSort(int a[], int iMin, int iMax){ if (iMin >= iMax) return; else if (iMin + 1 == iMax) // 若只有两个元素,直接比较 { if (a[iMin] > a[iMax]) { a[iMin] = (a[iMin]+a[iMax]) - (a[iMax]=a[iMin]); } return; } int iPos = partition(a, iMin, iMax); quickSort(a, iMin, iPos - 1); //left quickSort(a, iPos + 1, iMax); //right } public static int partition(int a[], int i, int j){ int iKey= a[i]; //选取key do { //由后向前找到第一个比nKey小的元素, 并与a[i]交换 while (a[j] >= iKey && i < j) j--; if (i < j) a[i] = (a[i]+a[j]) - (a[j]=a[i]); //由前向后找到第一个比nKey大的元素, 并与a[j]交换 while (a[i] <= iKey && i < j) i++; if (i < j) a[i] = (a[i]+a[j]) - (a[j]=a[i]); } while (i < j); return j; } } 例如求平方根的(n)，求a的b次方(a, b)，求绝对值(n)等很多。下面是一些演示。publicclassMathTest { publicstaticvoidmain(String[]args) { intn=16; ？ 3)); ？ ？ } } publicclassMathDemo{ publicstaticvoidmain(Stringargs[]){ /** *abs求绝对值 */ 的时候会取偶数 */ // // // // // // // // // // /** *round四舍五入，float时返回int值，double时返回long值 */ //10 //11 //11 //11 //-10 //-11 //-11 //-10 } } 函数（方法） 描述 IEEEremainder(double,double) 按照IEEE754标准的规定，对两个参数进行余数运算。 abs(inta) 返回int值的绝对值 abs(longa) 返回long值的绝对值 abs(floata) 返回float值的绝对值 abs(doublea) 返回double值的绝对值 acos(doublea) 返回角的反余弦，范围在到pi之间 asin(doublea) 返回角的反正弦，范围在-pi/2到pi/2之间 atan(doublea) 返回角的反正切，范围在-pi/2到pi/2之间 atan2(doublea,doubleb) 将矩形坐标(x,y)转换成极坐标(r,theta) ceil(doublea) 返回最小的（最接近负无穷大）double值，该值大于或等于参数，并且等于某个整数cos(double) 返回角的三角余弦 exp(doublea) 返回欧拉数e的double次幂的值 floor(doublea) 返回最大的（最接近正无穷大）double值，该值小于或等于参数，并且等于某个整数log(doublea) 返回（底数是e）double值的自然对数 max(inta,intb) 返回两个int值中较大的一个 max(longa,longb) 返回两个long值中较大的一个 max(floata,floatb) 返回两个float值中较大的一个 max(doublea,doubleb) 返回两个double值中较大的一个 min(inta,intb) 返回两个int值中较小的一个 min(longa,longb) 返回两个long值中较小的一个 min(floata,floatb) JAVA中常用类的常用方法 一、类 1、clone()方法 创建并返回此对象的一个副本。要进行“ 克隆” 的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法 功能：比较引用类型数据的等价性。 等价标准：引用类型比较引用，基本类型比较值。 存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内 容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法 返回该对象的哈希码值。 5、notify()方法 唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法 唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比 较，不考虑大小写。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) java程序员必学的十种程序算法 算法1：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。 算法步骤： 1 从数列中挑出一个元素，称为“基准”（pivot）， 2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 算法2：堆排序算法 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤： 创建一个堆H[0..n-1] 把堆首（最大值）和堆尾互换 3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置 4. 重复步骤2，直到堆的尺寸为1 算法3：归并排序 归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 算法步骤： JAVA屮常用类的常用方法 一．java?丨ang.Object 类 1、clone()方法 创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.wendangku.net/doc/a95158772.html,ng. Cloneable 接口。 2、equals(Objectobj)方法 0 功能：比较引用类型数据的等价性。 0 等价标准.?引用类型比较引用，基木类型比较值。 0 存在特例.?对File、String、Date及封装类等类型来说，是比较类型及对象的内稃而+ 考虑引用的是否为同一实例。 3、finalize〇方法 当垃圾丨"丨收器确定>(、存在对该对象的更多引用时，由对象的垃圾丨"丨收器调用此方法。 4、hashCode〇方法返 回该对象的哈希码值。 5、notify〇方法 唤醒在此对象监视器上等待的中?个线祝。 6、notifyAII〇方法 唤醒在此对象监视器上等待的所有线程= 7、toString()方法 返W该对象的字符串表示。在进行String与其它类型数据的连接操作时，&动调用tostringo 方法。可以根据耑要重写toStringO方法。 8、wait()方法 在其他线程调用此对象的n〇tify()方法或notifyAIIO方法前，异致当前线程等待。 二、字符串相关类 I String 类 charAt(int index)返回指定索引处的char值。compareTo{String anotherString)按字 典顺序比较两个字符串。compareTolgnoreCase(Stringstr)按字典顺序比较两个字 符串，不考虑人小写。concat(String str)将指定字符串连接到此字符串的结尾。 endsWith(String suffix)测试此字符串是否以指定的〗?缀结束。equals{Object anObject)将此字符串与指定的对象比较。 equalslgnoreCase(String anotherString)将此String 与另一个String 比较，考虑人小'与’。indexOf(int ch)返H指定字符在此字符串屮第一次出现处的索引。 indexOf(String str)返回第一次出现的指定子字符串在此字符串屮的索引， lastlndexOf(intch)返回指定字符在此字符串中最后??次出现处的索引。 length()返|n丨此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 split(String regex)根据给定正则表达式的匹配拆分此字符串。startsWith{String prefix)测试此字符 串是否以指定的前缀开始。substring(int beginlndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginlndex, int endlndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginlndex 处开始，一直到索引endlndex-1处的字符。 t〇CharArray()将此字符串转换为一个新的字符数组。 冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量， 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序 JAVA中常用类的常用方法 一、https://www.wendangku.net/doc/a95158772.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.wendangku.net/doc/a95158772.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开 JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i 例如求平方根的Math.sqrt(n)，求a的b次方Math.pow(a, b)，求绝对值Math.abs(n)等很多。下面是一些演示。 public class MathTest { public static void main(String[] args) { int n = 16; System.out.println(Math.sqrt(n)); System.out.println(Math.pow(2, 3)); System.out.println(Math.abs(-4)); System.out.println(Math.log10(100)); } } public class MathDemo { public static void main(String args[]){ /** * abs求绝对值 */ System.out.println(Math.abs(-10.4)); //10.4 System.out.println(Math.abs(10.1)); //10.1 /** * ceil天花板的意思，就是返回大的值，注意一些特殊值 */ System.out.println(Math.ceil(-10.1)); //-10.0 System.out.println(Math.ceil(10.7)); //11.0 System.out.println(Math.ceil(-0.7)); //-0.0 System.out.println(Math.ceil(0.0)); //0.0 System.out.println(Math.ceil(-0.0)); //-0.0 /** * floor地板的意思，就是返回小的值 */ System.out.println(Math.floor(-10.1)); //-11.0 System.out.println(Math.floor(10.7)); //10.0 System.out.println(Math.floor(-0.7)); //-1.0 Java程序员必知的8大排序本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 1.package com.njue; 2. 3.public class insertSort { 4.public insertSort(){ 5. inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17, 18,23,34,15,35,25,53,51}; 6.int temp=0; 7.for(int i=1;i java中常用的一些方法 字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同 前缀startsWith(String s) 后缀endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型Integer.parseInt(字符串) long型Long.parseLong(字符串) float型Folat.valueOf(字符串).floatValue() double型Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索 如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符）StringTokenizer(String s,String delim) delim是自己定义的分隔符 nextToken() 逐个获取字符串中的语言符号 boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false countTokens() 得到一共有多少个语言符号 文本框和文本区 1、文本框 TextField() 构造文本框，一个字符长 TextField(int x) 构造文本框，x个字符长 TextField(String s) 构造文本框，显示s setText(String s) 设置文本为s getText() 获取文本 setEchoChar(char c) 设置显示字符为c setEditable(boolean) 设置文本框是否可以被修改 addActionListener() 添加监视器 removeActionListener() 移去监视器 2、文本区 TextArea() 构造文本区 TextArea(String s) 构造文本区，显示s TextArea(String s,int x,int y) 构造文本区，x行，y列，显示s TextArea(int x,int y) 构造文本区，x行，y列 TextArea(String s,int x,ing y,int scrollbar) scrollbar的值是： TextArea.SCROLLBARS_BOTH TextArea.SCROLLBARS_VERTICAL_ONLY TextArea.SCROLLBARS_HORIZONTAL_ONLY TextArea.SCROLLBARS_NONE setText(String s) 设置文本为s java常用类知识点总结 Java常用类 要求: 1、掌握String和StringBuffer的区别，可以熟练使用String和StringBuffer的各 种方法进行相关操作。 2、能够自己编写一个得到日期的操作类，并将日期进行格式化操作。 3、掌握比较器及其基本原理，并可以通过比较器进行对象数组的比较操作。 4、掌握对象克隆技术及其实现 5、能够灵活应用正则表达式对字符串的组成进行判断 6、掌握Math、Random、基本数据类型的包装类的使用 7、描述出Object System对垃圾收集的支持 8、使用NumberFormat、DecimalFormat、BigInteger、BigDecimal进行数字的操 作 String和StringBuffer String的内容一旦声明不可改变，如果要改变，改变的是String的引用地址，如果一个字符串要经常改变，必须使用StringBuffer。 在一个字符串内容需要频繁修改时，使用StringBuffer可以提升操作性能，因为StringBuffer内容可以改变，而String内容不可改变。StringBuffer支持的方法大部分与String类似。 StringBuffer常见用法: (1) 字符串的连接操作 String类可以通过“+“进行字符串的连接，而StringBuffer中却只能使用append方法进行字符串的连接，而且此方法返回一个StringBuffer类的实例，这样就可以采用代码链的形式一直调用append方法。 (2) 在任意位置处为StringBuffer添加内容 可以使用insert方法在指定位置上为StringBuffer添加内容 字符串的反转操作(较为常见的操作，使用reverse方法) (3) 替换指定范围的内容 replace方法可对指定范围的内容进行替换。在String中如果要替换，使用的是replaceAll (4) 字符串截取(使用subString方法从指定范围中截取内容) (5) 删除指定范围的字符串(使用delete方法删除指定范围内容) (6) 查找指定内容是否存在(indexOf查找指定内容，查找到返回内容的位置， 没查到返回-1) 问题:(1)String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有, 没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢,答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改， 或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符 Java排序算法 1）分类： 1）插入排序（直接插入排序、希尔排序） 2）交换排序（冒泡排序、快速排序） 3）选择排序（直接选择排序、堆排序） 4）归并排序 5）分配排序（箱排序、基数排序） 所需辅助空间最多：归并排序 所需辅助空间最少：堆排序 平均速度最快：快速排序 不稳定：快速排序，希尔排序，堆排序。 1）选择排序算法的时候 1.数据的规模； 2.数据的类型； 3.数据已有的顺序 一般来说，当数据规模较小时，应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。考虑数据的类型，比如如果全部是正整数，那么考虑使用桶排序为最优。考虑数据已有顺序，快排是一种不稳定的排序（当然可以改进），对于大部分排好的数据，快排会浪费大量不必要的步骤。数据量极小，而起已经基本排好序，冒泡是最佳选择。我们说快排好，是指大量随机数据下，快排效果最理想。而不是所有情况。 3）总结： ——按平均的时间性能来分： 1）时间复杂度为O(nlogn)的方法有：快速排序、堆排序和归并排序，其中以快速排序为最好； 2）时间复杂度为O(n2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特别是对那些对关键字近似有序的记录序列尤为如此； 3）时间复杂度为O(n)的排序方法只有，基数排序。 当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。 ——按平均的空间性能来分（指的是排序过程中所需的辅助空间大小）： 1）所有的简单排序方法(包括：直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1)； 2）快速排序为O(log n )，为栈所需的辅助空间; 3）归并排序所需辅助空间最多，其空间复杂度为O(n ); 4）链式基数排序需附设队列首尾指针，则空间复杂度为O(rd )。 ——排序方法的稳定性能： 1）稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变。 2）当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。 3）对于不稳定的排序方法，只要能举出一个实例说明即可。 4）快速排序，希尔排序和堆排序是不稳定的排序方法。 4）插入排序： 包括直接插入排序，希尔插入排序。 直接插入排序：将一个记录插入到已经排序好的有序表中。 1, sorted数组的第0个位置没有放数据。 Java标准包中基本常用类和方法 java.util.Vector; java.util.ArrayList; java.util.Date; java.util.Calendar; java.util.Hashtable; java.util.Properties; java.util.Random; java.util.Timer; java.awt.* javax.swing.* Thread String Java常用方法: 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同 前缀startsWith(String s) 后缀endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型Integer.parseInt(字符串) long型Long.parseLong(字符串) float型Folat.valueOf(字符串).floatValue() double型Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索 如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符） StringTokenizer(String s,String delim) delim是自己定义的分隔符 nextToken() 逐个获取字符串中的语言符号 仲恺农业工程学院实验报告纸 计算科学与工程（院、系）网络工程专业班组Java语言程序设计课 学号姓名实验日期2010/11/19 教师评定 实验五：Java语言中的常用类 一、实验目的 1、掌握Java语言中的常用类。 2、学习用Java语言中的常用类编写程序。 二、实验要求 1、字符串调用public String toUpperCase()方法返回一个字符串，该字符串把当前字符串中的小写字母变成大写字母；字符串调用public String toUpperCase()方法返回一个字符串，该字符串把当前字符串的大写字母变成小写字母。String 类的String toUpperCase()方法返回一个字符串，该字符串是把调用该方法的字符串与参数指定的字符串连接。 2、String类的public charAt（int index）方法可以得到当前字符串index 位置上的一个字符。编写程序使用该方法得到一个字符串中的第一个和最后一个字符。 3、输出某年某月的日历页，通过键盘输入年份和月份。 二、实验程序和结果 1、 public class Stg{ public static void main(String args[]){ String s2=new String("LI ZHI DONG"); String s3=s1.concat(s2); System.out.println("连接后的字符："+s3); char a[]=s3.toCharArray(); for(int n=0;n Java数据结构和算法 第0讲综述 参考教材：Java数据结构和算法（第二版），[美] Robert lafore 1. 数据结构的特性 数据结构< 缺点 优点 数组插入快；如果知道下标，可以非常快地存取查找慢，删除慢，大小固定 有序数组比无序的数组查找快删除和插入慢，大小固定 提供后进先出方式的存取存取其他项很慢 < 栈 队列提供先进先出方式的存取存取其他项很慢 链表插入快，删除快— 查找慢 二叉树查找、插入、删除都快（如果树保持平衡）删除算法复杂 红-黑树查找、插入、删除都快；树总是平衡的算法复杂 算法复杂 2-3-4树` 查找、插入、删除都快；树总是平衡的；类 似的树对磁盘存储有用 哈希表如果关键字已知，则存储极快；插入快删除慢，如果不知道关键字则存 储很慢，对存储空间使用不充分堆插入、删除快；对大数据项的存取很快对其他数据项存取慢 对现实世界建模有些算法慢且复杂 》 图 2. 经典算法总结 查找算法：线性查找和二分查找 排序算法： 用表展示 ！ 第一讲数组 1.Java中数组的基础知识 1）创建数组 在Java中把数组当作对象来对待，因此在创建数组时必须使用new操作符： < 一旦创建数组，数组大小便不可改变。 2）访问数组数据项 3）数组的初始化 当创建数组之后，除非将特定的值赋给数组的数据项，否则它们一直是特殊的null对 等效于下面使用new来创建数组并初始化： | 2.面向对象编程方式 1）使用自定义的类封装数组 | # ! 子问题须与原始问题为同样的事，且更为简单； b. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。 1.三角数字 该数列中的首项为1，第n项是由第n-1项加n后得到的。 1）使用循环查找第n项 常用类 Object类 它是Java所有类的根类.所以Java的所有对象都拥有Object类的成员. 1．一般方法 boolean equals(Object obj) //本对象与obj对象相同，返回true String toString() //返回本对象的字符串表达形式，默认返回类名称和十六进制数的编码，即：getClass().getName+’@’+Integer.toHexString(hashCode()); 如果要显示自定义的对象，则需要覆盖这个方法。 protected void finalize() throws Throwable //对象销毁时被自动调用, native int hashCode() 返回对象的Hash码，Hash码是表示对象的唯一值，故Hash码相同的对象是同一对象。 2．控制线程的方法 final native void wait() //等待对象 final native void notify() //通知等待队列中的对象进入就绪队列 final native void notifyAll()//通知所有处于等待队列中的对象进入就绪队列 3．关于Object类的几点说明： 3.1. native <方法> 是指用C++语言编写的方法。 3.2.“==”运算符一般用于基本数据类型的比较，如果用于两个引用对象的比较，则 只有当两个引用变量引用同一个对象时，才返回true,否则返回false. String s1=new Strng(“java”); String s2=new Strng(“java”); System.out.pritnln(s1==s2); //显示false 但是，假如不使用new 关键字，创建String 型对象s3,s4,则它们引用的是同一个对象。 String s3=“java”; String s4=“java”;因为没有使用new 关键字，所以s4 引用既存的对象 System.out.pritnln(s3==s4); //显示true, 3.3. 比较对象内容时,使用equals()函数 Object 类的equals()定义 Public boolean equals(Object obj){ return (this==obj); } 由于String 类覆盖了继承自Object类的equals()方法,它比较的是引用对象的内容. 所以,没有覆盖equals()方法的类的对象使用该方法与另一对象进行比较时,永远返 回false; 只是因为此时进行比较调用的是Object的equals方法. 4. Object引用型变量 Object引用型变量可以用来引用所有的对对象. Object[] obs=new Object[3]; obs[0]=new Strng(“12345”);//将String对象赋给obs[0] obs[0]=new Boolean(true); obs[0]=new Integer(100); 5. toString()方法 以下内容节选自Java私塾自编经典教材： 下面是Java实现的一些常见排序算法。 1：冒泡排序 对几个无序的数字进行排序，比较常用的方法是冒泡排序法。冒泡法排序是一个比较简单的排序方法，在待排序的数列基本有序的情况下排序速度较快。 基本思路：对未排序的各元素从头到尾依次比较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第一轮比较排序后便可把最大（或最小）的元素排好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所要的顺序。 可以看出如果有N个元素，那么一共要进行N-1轮比较，第I轮要进行N-I次比较。（如：有5个元素，则要进行5-1轮比较。第3轮则要进行5-3次比较） 示例如下： public class Test { public static void main(String[] args) { //需要排序的数组，目前是按照升序排列的 int a[] = new int[5]; a[0] = 3; a[1] = 4; a[2] = 1; a[3] = 5; a[4] = 2; //冒泡排序 for(int i=0;i 字符串操作：字符串的比较： boolean equals()比较此字符串与指定的对象。 Int compareTo() 比较源与（）的大小，两串大小相等返回0 加IgnoreCase()不考虑大小写boolean contains(CharSequence s) 当且仅当此字符串包含 char 值的指定序列时，才返回 true。 字符串的长度与组合： char charAt(int index)返回指定索引处的 char 值。 String concat(String str)将指定字符串联到此字符串的结尾。 int length() 返回此字符串的长度。 获取子串： String substring(int beginIndex) 返回一个从beginIndex到末尾的子串 String substring(int beginIndex, int endIndex) 返回一个从beginIndex到endIndex-1的字串 字符串的转换、替换和分隔： char[] toCharArray() 将此字符串转换为一个新的字符数组。 String toString() 返回此对象本身（它已经是一个字符串！）。 String toLowerCase() 变为全小写 String toUpperCase() 变为全大写 String trim() 返回字符串的副本，忽略前导空白和尾部空白。 String replace(char oldChar, char newChar) 用 newChar 替换此字符串中出现的所有 oldChar，返回新字符 String replaceAll(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。 String replaceFirst(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的第一个子字符串。 String[] split(String regex) 在给定字符处拆分原字符串为若干字串。 找出相应字符或字串（找不到返回-1） int indexOf() 返回（？）填入的字符（串）在源中的第一个索引；（？,num）从num索引开始查找 int lastIndexOf()返回最后一次出现的指定值索引。 将字符和数值转化为字符串： Static String valueOf() 将（）填入的参数（任意、包括Obj）转化为字符串 StringBuilder类：构建： StringBuilder() 构建一个容量为16的空字符串生成器，（）填入数字构造指定大小，填入String 构造含有指定字符。 int capacity() 返回当前容量。 char charAt(int index) 指定索引处的 char 值。添改： StringBuilder append() 将特定内容由（）传入buffer StringBuilder insert(int offset,？) 将？变量插在此序列的offset 前 void setCharAt(int index, char ch) 改变索引处的字符为ch。 StringBuilder replace(int start, int end, String str) 替换从start至end-1处字符为str StringBuilder reverse() 反转字符序列。删除： StringBuilder delete(int start, int end) 移除从start索引到end-1索引的字符串。 StringBuilder deleteCharAt(int index) 移除此序列指定位置上的 char。查找： int indexOf(String str) 同String用法 int lastIndexOf()同String用法 int length() 返回长度（字符数）。返回值： int capacity() 返回当前容量。javamath类常用方法
JAVA中常用类的常用方法
java程序员必知的十种程序算法
JAVA中常用类的常用方法
JAVA数组的排序方法实例
JAVA中常用类的常用方法
JAVA中运用数组的四种排序方法
JavaMath类常用方法
java中8大排序方法
java中常用的一些方法
java常用类知识点总结
Java各种排序算法
Java标准包中基本常用类和方法
实验五：Java语言中的常用类
Java数据结构和算法笔记
(完整版)Java常用类
Java实现的常见排序算法
java常用类及用法
- java二分法查找和冒泡排序方法的实现
- 冒泡排序法、选择排序法、插入排序法(java案例详解)
- 排序算法比较_java课程设计_刘阳辉
- Java之冒泡排序方法实例讲解
- JAVA堆排序和几种排序方法实现代码
- Java实现的常见排序算法
- java排序算法大全
- JAVA数组入门与选择排序算法讲义
- JAVA中运用数组的四种排序方法
- 几种常见排序算法(JAVA实现)
- JAVA常用基本算法
- JAVA常用4种排序方法
- 如何击败JAVA自带排序算法
- 跟我学Java面向对象程序设计技术及应用——应用冒泡排序算法实现数组元素排序的Java程序实现示例
- 程序员必知的十种程序算法
- Java数据结构和算法笔记
- Java排序算法
- 选择排序算法运行时间测试(java)
- JAVA数组的排序方法实例
- Java各种排序算法