InventoryItem.java使用未經檢查或不安全的操作

Question

我正在學習可比較性，並正在我的庫存類中實施它。但是，當我去編譯代碼時，編譯器會給出一個錯誤。

InventoryItem.java uses unchecked or unsafe operations.

誰能請幫助我。我的代碼出了什麼問題，我該如何解決這個問題。提前謝謝你的幫助。

class InventoryItem implements Comparable<InventoryItem> 
{ 
    private String name; 
    private int uniqueItemID; 

    public InventoryItem() 
    { 
      name = " "; 
      uniqueItemID = 0; 
    } 

    public InventoryItem(String newName, int newItemID) 
    { 
      name = newName; 
      uniqueItemID = newItemID; 
    } 

    public InventoryItem(InventoryItem i) 
    { 
      name = i.name; 
      uniqueItemID = i.uniqueItemID; 
    } 

    public void setName(String newName) 
    { 
      name = newName; 
    } 

    public void setItemID(int newItemID) 
    { 
      uniqueItemID = newItemID; 
    } 

    public int getItemID() 
    { 
      return uniqueItemID; 
    } 

    public String getName() 
    { 
      return name; 
    } 

    public int compareTo(InventoryItem i) 
    { 
      int anotherUniqueID = i.getItemID(); 
      return (this.uniqueItemID - anotherUniqueID); 
    } 

    public static void sort(Comparable[] a, int numberUsed) 
    { 
      int index, indexOfNextSmallest; 

      for(index = 0; index < numberUsed - 1; index++) 
      { 
        indexOfNextSmallest = indexOfSmallest(index, a, numberUsed); 
        interchange(index, indexOfNextSmallest, a); 
      } 
    } 

    private static int indexOfSmallest(int startIndex, Comparable[] a, int numberUsed) 
    { 
      Comparable min = a[startIndex]; 
      int indexOfMin = startIndex; 
      int index; 

      for(index = startIndex + 1; index < numberUsed; index++) 
      { 
        if(a[index].compareTo(min) < 0) 
        { 
          min = a[index]; 
          indexOfMin = index; 
        } 
      } 
      return indexOfMin; 
    } 

    private static void interchange(int i, int j, Comparable[] a) 
    { 
      Comparable temp; 
      temp = a[i]; 
      a[i] = a[j]; 
      a[j] = temp; 
    } 
} 

public class InventoryItemTester 
{ 
    public static void main(String [] args) 
    { 
      InventoryItem[] items = new InventoryItem[3]; 

      items[0] = new InventoryItem("Pens", 2); 
      items[1] = new InventoryItem("Pencils", 3); 
      items[2] = new InventoryItem("Notebooks", 1); 

      System.out.println("Before sorting"); 
      System.out.println(items[0]); 
      System.out.println(items[1]); 
      System.out.println(items[2]); 


      InventoryItem.sort(items, items.length); 

      System.out.println("After sorting"); 
      System.out.println(items[0]); 
      System.out.println(items[1]); 
      System.out.println(items[2]); 
    } 
} 

Answer 1

在猜測我會說這行導致了問題（你的編譯器會告訴你到底是哪行的問題，這可能是有用的，你的下一個問題包括）：

private static int indexOfSmallest(int startIndex, Comparable[] a, int numberUsed) 
    { 
     Comparable min = a[startIndex]; 
     int indexOfMin = startIndex; 
     int index; 

     for(index = startIndex + 1; index < numberUsed; index++) 
     { 
here==========> if(a[index].compareTo(min) < 0) 
       { 

您打電話給compareTo InventoryItem期待Object。你可以添加一個@SuppressWarnings註釋，它可以讓它消失:)

Comparable和Comparator的基本思想是它們將一個排序順序應用於一個Object，這樣標準的JDK Collections對象可以爲你做所有的辛苦工作。

在你的情況你comparesTo方法不正確的東西，但我不知道這是否是良好的規劃或好運氣，這樣的事情需要注意：

1. InventoryItem.comparesTo方法需要評估當前實例到提供的實例並返回一個表示該排序的整數，-1表示該實例（即this）應該在參數之前排序，0表示它們相同，1表示該實例在參數之後。這樣的事情讓JDK做所有的辛勤工作，爲您

   public int compareTo(InventoryItem i) 
   { 
       return Integer.valueOf(this.uniqueItemID).compareTo(i.uniqueItemID); 
   } 
   

2. 爲了使用可比你真正需要做的是落實它，然後使用標準JDK集合類來完成所有的繁重你，例如：

   import java.util.ArrayList; 
   import java.util.Collections; 
   import java.util.List; 
   
   public class InventoryItemTest 
   { 
       public static void main(String [] args) 
       { 
   
        List<InventoryItem> items = new ArrayList<InventoryItem>(); 
   
        items.add(new InventoryItem("Pens", 2)); 
        items.add(new InventoryItem("Pencils", 3)); 
        items.add(new InventoryItem("Notebooks", 1)); 
   
        System.out.println("Before sorting"); 
        System.out.println(items); 
   
   
        Collections.sort(items); 
   
        System.out.println("After sorting"); 
        System.out.println(items); 
       } 
   
   } 
   

3. 我知道這可能不是儘可能多的樂趣，寫你自己的排序算法，但如果你想做到這一點，沒有編譯器警告，那麼你需要開始尋找泛型