1. /**
   
2. * 作者：于陈
   
3. * 功能：演示各种排序
   
4. * 时间：2012年5月5日 19:49:34
   
5. */
   
6. package com.paixu;
   
7. 
   
8. import java.util.*;
   
9. 
   
10. public class Demo1 {
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 int len = 50;
    
14.                 int arr[] = new int[len];
    
15. 
    
16.                 for (int i = 0; i < len; i++) {
    
17.                         int t = (int) (Math.random() * 10000);
    
18.                         arr[i] = t;
    
19.                 }
    
20.                 Boo boo = new Boo();
    
21.                 Calendar car = Calendar.getInstance();
    
22.                 System.out.println("排序前时间：" + car.getTime());
    
23.                 boo.maopaoPaixu(arr);
    
24.                 car = Calendar.getInstance();
    
25.                 System.out.println("排序后时间：" + car.getTime());
    
26.                 System.out.println();
    
27.                 car = Calendar.getInstance();
    
28.                 System.out.println("排序前时间：" + car.getTime());
    
29.                 Selent selent = new Selent();
    
30.                 selent.selentPaixu(arr);
    
31.                 car = Calendar.getInstance();
    
32.                 System.out.println("排序后时间：" + car.getTime());
    
33.         }
    
34. 
    
35. }
    
36. 
    
37. // 选择排序
    
38. class Selent {
    
39.         public void selentPaixu(int arr[]) {
    
40.                 int temp = 0;
    
41.                 for (int i = 0; i < arr.length - 1; i++) {
    
42.                         int min = arr[i];
    
43.                         int minIndex = i;
    
44.                         for (int j = i + 1; j < arr.length; j++) {
    
45.                                 if (min > arr[j]) {
    
46.                                         min = arr[j];
    
47.                                         minIndex = j;
    
48.                                 }
    
49.                         }
    
50.                         temp = arr[i];
    
51.                         arr[i] = arr[minIndex];
    
52.                         arr[minIndex] = temp;
    
53.                 }
    
54. 
    
55.         }
    
56. }
    
57. 
    
58. // 冒泡排序
    
59. class Boo {
    
60.         public void maopaoPaixu(int[] arr) {
    
61.                 int temp = 0;
    
62.                 for (int i = 0; i < arr.length - 1; i++) {
    
63.                         for (int j = 0; j < arr.length - 1 - i; j++) {
    
64.                                 if (arr[j] > arr[j + 1]) {
    
65.                                         temp = arr[j];
    
66.                                         arr[j] = arr[j + 1];
    
67.                                         arr[j + 1] = temp;
    
68.                                 }
    
69.                         }
    
70.                 }
    
71. 
    
72.         }
    
73. }

复制代码

我想简单的测试下各种排序算法的时间复杂度，但是用这个Calendar只能弄出精确到秒的系统时间，虽然也能实现功能，但是貌似不太方便，请问有没有能精确到毫秒的时间方法？怎么用的？

咦，你看一下System类下面的这个方法。
static long currentTimeMillis()
          返回以毫秒为单位的当前时间。
这个就是一毫秒为单位的了

可以用System类中currentTimeMillis()方法来实现，该方法返回的是以毫秒为单位的当前时间long类型的数据，但是有个问题要注意下：时间的精确度取决于底层的操作系统，看操作系统以多少值作为单位来测量时间。使用如下 ：
long startTime = System.currentTimeMillis();
System.out.println("排序前时间：" + startTime);
                boo.maopaoPaixu(arr);              
long endTime = System.currentTimeMillis();
                System.out.println("排序后时间：" + endTime);
                System.out.println("一共用了" + (endTime-startTime) + "毫秒");
这样就可以一目了然了。

java 1.5版本开始支持更小的时间单位，可以到纳秒，网上搜索了下资料，
果然发现了更精确的时间单位：纳秒
于是可以这样计算耗费时间了：
long start = System.nanoTime();  
{
//这里是你要测的代码块...

}
long end = System.nanoTime();  
long time = end - start;//算出时间结果

你想精确到毫秒的话，就请看如下代码：
long start = System.currentTimeMillis();  
{

//这里是你要测的代码块

}
long end = System.currentTimeMillis();  
long time = end - start;//算出时间结果

一般在实际应用中经常使用System.currentTimeMillis() 来记录某段代码的运行时间。
public static long nanoTime()返回最准确的可用系统计时器的当前值，以毫微秒为单位。
JDK API中的例子：
   long startTime = System.nanoTime();
   // ... the code being measured ...
   long estimatedTime = System.nanoTime() - startTime;