如何創建自定義比較排序的編號系統

Question

這裏是我到目前爲止的代碼：

package Demo; 

import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 

public class Demo { 

    public static void main(String[] args) { 

     ArrayList<String> list = new ArrayList<String>(); 

     list.add("3.3.x"); 
     list.add("1.2.x"); 
     list.add("2.3.x"); 

     VersionComparator x = new VersionComparator(); 

     Collections.sort(list, x); 

     for(String str : list) 
      System.out.println(str); 

    } 

    static class VersionComparator implements Comparator { 
     public int compare(String str1, String str2) { 

      String firstNumberStringOne = str1.split(".")[0]; 
      String firstNumberStringTwo = str2.split(".")[0]; 
      String secondNumberStringOne = str1.split(".")[1]; 
      String secondNumberStringTwo = str2.split(".")[1]; 

      return; 
     } 

     @Override 
     public int compare(Object o1, Object o2) { 
      // TODO Auto-generated method stub 
      return 0; 
     } 
    } 
} 

我想通過月經前出現的第一個號在我的列表中的項目進行排序。如果這兩個數字相等，則轉到第二個數字並比較這些數字。如果平等，只要歸還他們。

我不確定如何使用比較器。我試圖實現它，編譯器抱怨說我需要在第二個比較方法中添加override。我也不知道如何進行比較，如何返回。我明白，如果它相等，那麼它返回一個0並且它小於那麼它返回一個-1並且大於1.但是在編碼方面，我失去了程序如何知道如何排序它。

Answer 1

有你的代碼幾個問題：

1. 您正在使用原始類型，因此在

   class VersionComparator implements Comparator 
   

   比較Comparator<T>將嘗試使用Object as T這意味着它的聲明爲compare(T t1, T t2)的比較方法將是compare(Object t1, Object o2)。所以，如果你想比較Strings化妝比較絃樂像

   class VersionComparator implements Comparator<String> 
   

   現在就知道T是String所以比較方法會是這個樣子 compare(Object t1, Object o2){..}

2. 當你調用split(".")你是不是分裂上的點，但在任何字符（因爲split是使用正則表達式，而在正則表達式.表示在線分離器\n和\r旁任何字符）。因爲在開始時你會得到一些空的元素，然後將被清除，因爲split刪除空的尾隨元素。更多的信息在這裏：https://stackoverflow.com/a/21790319/1393766。

   要解決此問題，您需要使用"\\."來轉義.。

這應該涵蓋代碼中的主要問題。但是，如果你想創建一個很好的解決方案，那麼考慮避免排序Strings，而是你自己的Version類的實例。
這種方法的優點在於，每次您想比較兩個字符串（可能會很昂貴）時，您不必將字符串解析爲int，但可以將解析版本"1.2.3"存儲爲數組[1, 2, 3]並重新使用它需要的時候。
另外Version類可以實現Comparable<Vector>來提供默認比較方法。

所以，你的代碼可以看起來更像：

class Version implements Comparable<Version> { 

    private String versionStr; 
    private int[] arr; 

    public String getVersionStr() { return versionStr; } 

    @Override public String toString() { return versionStr; } 

    @Override 
    public int compareTo(Version o) { 

     int result = Integer.compare(arr[0], o.arr[0]); 

     if (result != 0) 
      return result; 

     return Integer.compare(arr[1], o.arr[1]); 
    } 

    public Version(String versionStr) { 
     this.versionStr = versionStr; 
     this.arr = Stream.of(versionStr.split("\\.")) 
       .limit(2)//get only two first elements 
       .mapToInt(Integer::parseInt)//convert String to int 
       .toArray();//return array of integers 
    } 

} 

class Demo { 

    public static void main(String[] args) { 

     List<Version> list = new ArrayList<Version>(); 

     list.add(new Version("3.3.x")); 
     list.add(new Version("1.2.x")); 
     list.add(new Version("1.11.x")); 
     list.add(new Version("2.3.x")); 

     Collections.sort(list); 

     for (Version str : list) 
      System.out.println(str); 
    } 
} 

Answer 2

你VersionComparator類正在實施Comparator接口，其中，所述方法compare將2個Object！而非2個String S的原始形式。

通過供給String作爲一種類型的參數實現的接口。然後編譯器會識別出你的compare方法，將String作爲接口的正確實現的參數。您不需要compare方法採取Object s。

static class VersionComparator implements Comparator<String> { 

你當然需要實現在compare method比較邏輯，返回一個int小於0，0，或大於0，如果str1根據比較小於，等於或大於str2您自定義排序順序。

Answer 3

public static void main(String[] args) { 
    ArrayList<String> list = new ArrayList<String>(); 
    list.add("3.3.x"); 
    list.add("1.2.x"); 
    list.add("1.11.x"); 
    list.add("1.1.x"); 
    list.add("2.3.x"); 

    Collections.sort(list, new VersionComparator()); 

    for(String str : list) 
     System.out.println(str); 

} 

static class VersionComparator implements Comparator<String> { 
    //Temporary Cache Map to hold Split String value. String as Key and Split String array as value is this in this map. 
    Map<String, String[]> mCacheMap = new HashMap<>(); 

    @Override 
    public int compare(String string1, String string2) { 

     if(!mCacheMap.containsKey(string1)){ 
      //Put Split String of string1 to map if it does not contain it. 
      mCacheMap.put(string1, string1.split("\\.")); 
     } 
     if(!mCacheMap.containsKey(string2)){ 
      //Put Split String of string2 to map if it does not contain it. 
      mCacheMap.put(string2, string2.split("\\.")); 
     } 
     //Get First Digit of first string1 from Map 
     Integer string1Val1 = Integer.valueOf(mCacheMap.get(string1)[0]); 
     //Get First Digit of second string2 from Map    
     Integer string2Val1 = Integer.valueOf(mCacheMap.get(string2)[0]); 

     //Compare Both Digit. compareTo Method return a negative integer, zero, or a positive integer as first Integer value is less than, equal to, or greater than the seconf Integer value. 
     int cmp = string1Val1.compareTo(string2Val1); 

     if(cmp != 0){ 
      return cmp; 
     }else { 
      //If First digit of both string is same compare second digit. 
      Integer string1Val2 = Integer.valueOf(mCacheMap.get(string1)[1]); 
      Integer string2Val2 = Integer.valueOf(mCacheMap.get(string2)[1]); 
      return string1Val2.compareTo(string2Val2); 
     } 

    } 
} 

結果：

1.1.x 
1.2.x 
1.11.x 
2.3.x 
3.3.x