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

Question

I'm learning about comparable and am implementing it in my Inventory class. However when I go to compile the code, the compiler gives an error.

InventoryItem.java uses unchecked or unsafe operations.

Can anyone please help me out. What is wrong with my code and what can I do to fix this issue. Thank you for your help in advance.

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

At a guess I'd say this line is causing the issue (Your compiler tells you exactly which line is the problem, this might be useful to include in your next question):

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

You are calling compareTo with a InventoryItem where it is expecting an Object . You could add a @SuppressWarnings annotation which would make it go away :)

The basic idea of Comparable and Comparator is they apply a sorting order to an Object so that the standard JDK Collections objects can do all the hard work for you.

In your case your comparesTo method does the correct thing, however I'm not sure if this is good planning or good luck, so things to note:

1. InventoryItem.comparesTo method needs to evaluate the current instance to the provided instance and return an integer signifying the ordering, -1 means the instance (ie this ) should be ordered before the argument, 0 means they are the same and 1 means the instance is after the argument. Something like this lets the JDK do all the hard work for you

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

2. In order to use Comparable all you really need to do is implement it and then use the standard JDK Collections classes to do all the heavy lifting for you, eg:

    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. I realise this might not be as much fun as writing your own sorting algorithms but if you want to do that with no compiler warnings then you need to start looking at generics