java - InventoryItem.java 使用未经检查或不安全的操作

Question

我正在学习可比性，并在我的库存类(class)中实现它。但是当我去编译代码时，编译器给出了错误。

InventoryItem.java 使用未经检查或不安全的操作。

谁能帮帮我。我的代码有什么问题以及我能做些什么来解决这个问题。提前谢谢你的帮助。

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)
                {

您正在使用 InventoryItem 调用compareTo，它需要一个Object。您可以添加一个 @SuppressWarnings 注释，这样它就会消失:)

Comparable 和 Comparator 的基本思想是它们对对象应用排序顺序，以便标准 JDK 集合对象可以为您完成所有艰苦的工作。

在你的情况下，你的comparesTo方法做了正确的事情，但是我不确定这是好的计划还是好运气，所以需要注意的事情:

1. InventoryItem.comparesTo 方法需要将当前实例评估为提供的实例，并返回一个表示排序的整数，-1 表示实例(即 this ) 应该排在参数之前，0 表示它们相同，1 表示实例在参数之后。这样的事情可以让 JDK 为您完成所有艰苦的工作

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

2. 为了使用 Comparable，您真正需要做的就是实现它，然后使用标准 JDK Collections 类来为您完成所有繁重的工作，例如:

   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. 我意识到这可能不如编写自己的排序算法那么有趣，但如果您想在没有编译器警告的情况下做到这一点，那么您需要开始考虑泛型