决定使用可比或比较器

Question

My program implements a Product class whose objects contain the following instance variables: name , priority , price , and amount .

I have a LinkedList of Product objects that I need to sort before doing any other operations on the LinkedList .

I want to sort the list first by priority (from lowest to highest). If priority is the same, then look at the price (lowest to highest), then the name (alphabetical order).

I have done a lot of reading about Collections.sort , Comparable , and Comparator . I believe I need to use the Comparable interface and implement a compareTo method. My thinking is that because both priority , price , and name have a "natural" ordering it makes more sense to use Comparable .

public class Product extends ProductBase implements PrintInterface, Comparable<Product>{
    private String name;
    private int priority; 
    private int cents;
    private int quantity;

    // setters and getters

    /**
    * Compare current Product object with compareToThis
    * return 0 if priority, price and name are the same for both  
    * return -1 if current Product is less than compareToThis
    * return 1 if current Product is greater than compareToThis
    */ 

    @override
    public int compareTo(Product compareToThis)
}

Then when I want to sort my LinkedList I just call Collections.sort(LinkedList) . Before I start writing the code, can you tell me if I am I missing or forgetting anything?

** * ** * ** * **** UPDATE * ** * ** * ** * ** * ** * ** * ** * ** * ** * ** *

I just created a separate class called ProductComparator with a compare method.

This is part of the LinkedList class..

import java.util.Collections;

public class LinkedList {

private ListNode head; 

public LinkedList() { 
    head = null;
}
     // this method will sort the LinkedList using a ProductComparator
public void sortList() {
    ListNode position = head;
    if (position != null) {
        Collections.sort(this, new ProductComparator());
    }
}
// ListNode inner class
private class ListNode {

    private Product item;
    private ListNode link;

    // constructor
    public ListNode(Product newItem, ListNode newLink) {
        item= newItem;
        link = newLink;
    }
}

}

I am getting the following error from the IDE when I compile.

The method sort(List, Comparator) in the type Collections is not applicable for the arguments (LinkedList, ProductComparator).

Does anyone know why I am getting this error and can point me in the right direction to resolve it?

Answer 1

If there is a "natural" ordering, use Comparable. Rule of thumb for figuring out if the ordering is "natural" is, whether the order of the objects will always be that.

Having said that, the decision whether to use Comparable or Camparator is not the kind of decision you need to think too much about. Most IDEs have refactoring tools which makes the conversion between a Comparable and a Comparator very easy. So if you choose to walk the wrong path now, changing that will not require too much effort.

Answer 2

The order you define here on your Product is very specific and

• will probably change in future versions of your program
• might be enriched with contextual parameterization
• won't cover new features

So it can hardly been said "natural".

I'd suggest to define a constant, for example

public static Comparator<Product> STANDARD_COMPARATOR = new Comparator<Product>() {
    public int compare(Product p1, Product p1) {
        return ...
    }
};

then you'll be able to easily sort anywhere with

Collections.sort(myProductList, Product.STANDARD_COMPARATOR);

Your code will evolve in a better manner as you'll add other comparators.

Just like you should generally prefer composition over inheritance, you should try to avoid defining the behavior of your objects in immutable manner.

Answer 3

If your order was based only on numbers, Comparable would be fine.

However, since your order (sometimes) involves lexical order of text, a Comparator class is better, since use of Comparable would mean using String.compareTo which would prevent you from having internationalization.

A separate class which implements Comparator can make use of a localized Collator for comparing Strings. For instance:

public class ProductComparator
implements Comparator<Product> {
    private final Collator collator;

    public ProductComparator() {
        this(Locale.getDefault());
    }

    public ProductComparator(Locale locale) {
        this.collator = Collator.getInstance(locale);
    }

    public int compare(Product product1,
                       Product product2) {

        int c = product1.getPriority() - product2.getPriority();
        if (c == 0) {
            c = product1.getPrice() - product2.getPrice();
        }
        if (c == 0) {
            c = collator.compare(product1.getName(), product2.getName());
        }
        return c;
    }
}

Regardless of whether you go with Comparable or Comparator, it is wise to make sure Product has an equals method which checks the same attributes as the comparison code.