爪哇：排序1d的對象數組是否完整或不是

Question

我試圖壓縮一個對象的數組，這些對象將穿插着完整的項目。我想把所有的元素放在一開始就按照它們開始的順序排列，最後用空的元素。

有問題的對象使用String字段，「name」和int字段「weight」。空的版本分別具有「無名」和0。因此，該方法需要處理的類型數組將包含類似如下內容：

• Fred | 4
• Bob | 3
• 沒有名字| 0
• Gina | 9
• 沒有名字| 0
• Yuki | 7

通過該方法餵養後，數組應該去弗雷德，鮑勃，吉娜，結城，沒有名字，沒有名字。

我對一步一個念頭就是剛剛弄清楚這充滿，哪些不是，所以我想出了這個：

public void consolidate() { 
    boolean[] fullSlots = new boolean[spaces.length]; 

    // pass 1: find empties 
    for (int i = 0; i < spaces.length; i++) { 
     fullSlots[i] = spaces[i].getName().equals("no name"); 
    } 
} 

空間是對象的數組，getName（）獲取的名稱來自對象的字段。

我不確定該從哪裏出發。建議？

編輯：好的，這裏就是被感染想出了：

public void consolidate() 
{ 
    int numberOfEmpties = 0, spacesLength = spaces.length; 
    Chicken[] spaces2 = new Chicken[spacesLength]; 
    for(int i = 0; i < spaces.length; i++) 
    { 
     spaces2[i] = new Chicken(spaces[i].getName(), 
             spaces[i].getWeight()); 
    } 

    // pass 1: find empties 
    for (int i = 0, j = 0; i < spacesLength; i++) 
    { 
     if (spaces2[i].getName().equals("no name") == false) 
     { 
      spaces[j] = new Chicken(spaces2[i].getName(), 
             spaces2[i].getWeight()); 
      j++; 
     } 
     else 
     { 
      numberOfEmpties++; 
     } 
    } 
    for (int i = spacesLength - 1; numberOfEmpties > 0 ; numberOfEmpties--, i--) 
    { 
     spaces[i] = new Chicken("no name", 0); 
    } 
} 

測試和工作。

Answer 1

生病承擔其類的方法：

public void consolidate() 
{ 
    int lengthOfSpaces = spaces.length , i, numberOfEmpties = 0; 
    Type[] spacesNumberTwo = new Type[lengthOfSpaces ]; 

    // pass 1: find empties 
    for (i = 0; i < lengthOfSpaces ; i++) 
    { 
     if(spaces[i].getName().equals("no name") == false) 
      spacesNumberTwo[i] = new Type(spaces[i].getName(), spaces[i].getInt()); 
     else 
      numberOfEmpties++; 
    } 
    for (i = lengthOfSpaces - 1; numberOfEmpties > 0 ; numberOfEmpties--, i--) 
    { 
      spacesNumberTwo[i] = new Type("no name", 0); 
    } 
    spaces = spacesNumberTwo 
} 

Answer 2

Java的Arrays.sort是穩定，這意味着等元素的相對順序不會改變。

這種保證是穩定的：相同的元素不會因排序而重新排序。

您可以使用排序算法的這個屬性來用一個簡單的比較所有的元素進行排序：

Arrays.sort(
    spaces 
, new Comparator() { 
      public int compare(Object o1, Object o2) { 
       MyClass a = (MyClass)o1; 
       MyClass b = (MyClass)o2; 
       boolean aIsEmpty = "no name".equals(a.getName()); 
       boolean bIsEmpty = "no name".equals(b.getName()); 
       if (aIsEmpty && !bIsEmpty) { 
        return 1; 
       } 
       if (!aIsEmpty && bIsEmpty) { 
        return -1; 
       } 
       return 0; 
      } 
    } 
); 

這將非空的名字前面的空名稱的項目的所有項目進行排序，兩組對象的相對順序保持不變。

如果您的空間限制允許您創建MyClass的新數組，您可以使用更簡單的算法：遍歷原始數組一次，並計算非空項目。然後創建一個新數組，並創建兩個索引：idxNonEmpty = 0和idxEmpty = NonEmptyCount+1。然後再次遍歷原始數組，將非空對象寫入idxNonEmpty++，並將空對象寫入idxEmpty++。