Hashtable排序的几种方法-蒲公英云

Hashtable排序的几种方法

Hashtable 利于用键值快速查找，却没有提供排序的方法，所以它的排序需要借住数组或其它集合来实现。

排序方法一：
将hash表中的值放入entrySet，利用Comparator中的compare方法实现排序

import java.util.Arrays;
  import java.util.Comparator;
  import java.util.Hashtable;
  import java.util.Map;
  import java.util.Set;     
  public class demo5 {
      public static void main(String[] args) {
           Hashtable ht = new Hashtable();
           ht.put(1, 5);
           ht.put(2, 7);
           ht.put(3, 3); 
          //将哈希表ht的键值对放入entrySet进行遍历
          Map.Entry[] set = SortByKey(ht);
          //Map.Entry[] set = SortByValue(ht);
          for (int i = 0; i < set.length; i++) {
            System.out.println(set[i].getKey().toString()+":"+set[i].getValue().toString());
          }
      }      
           //hashtable按键排序
            public static Map.Entry[] SortByKey(Hashtable ht) {
              long  start = System. currentTimeMillis();
              Set set = ht.entrySet();
              Map.Entry[] entries = (Map.Entry[]) set.toArray(new Map.Entry[set.size()]);
              Arrays.sort(entries, new Comparator() {
                public int compare(Object arg0, Object arg1) {
                  Object key1 = ((Map.Entry) arg0).getKey();
                  Object key2 = ((Map.Entry) arg1).getKey();
                  return ((Comparable) key1).compareTo(key2);
                }
              });
              Long end = System. currentTimeMillis();
              System. out.println( "耗时：" + (end - start) + " ms" );
              return entries;
            }
          //hashtable按值排序
            public static Map.Entry[] SortByValue(Hashtable ht) {
              long  start = System. currentTimeMillis();
              Set set = ht.entrySet();
              Map.Entry[] entries = (Map.Entry[]) set.toArray(new Map.Entry[set
                  .size()]);
              Arrays.sort(entries, new Comparator() {
                public int compare(Object arg0, Object arg1) {
                  int key1 = Integer.parseInt(((Map.Entry) arg0).getValue()
                      .toString());
                  int key2 = Integer.parseInt(((Map.Entry) arg1).getValue()
                      .toString());
                  return ((Comparable) key1).compareTo(key2);
                }
              });
              Long end = System. currentTimeMillis();
              System. out.println( "耗时：" + (end - start) + " ms" );
              return entries;
            }    
       }

排序方法二：
利用两个数组，一个装键，一个装值，然后重写快速排序的方法

import java.util.Hashtable;
public class demo4 {
   public static void main(String[] args) {
     Hashtable ht = new Hashtable();
     ht.put(1, 5);
     ht.put(2, 7);
     ht.put(3, 3); 
     int[] arrKey = new int[ht.size()];//暂存 Hashtable 的值
     int[] arrValue = new int[ht.size()];//暂存 Hashtable 的值
    for (int i = 0; i < arrValue.length; i++) {
        arrKey[i]=i+1;
        arrValue[i]=(int) ht.get(i+1);
     }
    QuickSort(arrValue,arrKey,0,arrValue.length-1);
    for (int i = 0; i < arrValue.length; i++) {
    System.out.println(arrKey[i]+":"+arrValue[i]);
     }    
   `在这里插入代码片`}  
   //重写快速排序：同时将键值进行排序
   public static void QuickSort(int arr[],int arr1[],int _left,int _right){
    long  start = System. currentTimeMillis();
       int right=_right;
       int left=_left;
       int temp=0,temp1=0;
       if(left<=right){
           temp1=arr1[left];
           temp=arr[left];
           while(left!=right){
               while(right>left&&arr[right]>temp)
                   right--;
                   arr1[left]=arr1[right];
                   arr[left]=arr[right];                    
                   while(left<right&&temp>arr[left])
                        left++;
                       arr1[right]=arr1[left];
                       arr[right]=arr[left]; 
                   }
                   arr1[right]=temp1; 
                   arr[right]=temp;
                   QuickSort(arr,arr1,_left,left-1);
                   QuickSort(arr,arr1,right+1,_right);                                                
             }
       Long end = System. currentTimeMillis();
    System. out.println( "耗时：" + (end - start) + " ms" );
       }
}