具有许多条件的可比接口

Question

The Question is how can use comparable interface and collections.sort to do the sorting with model , production and price. Can i do these three sorting in ascending order within "public int compareto(car other)"?

For example, It will be sorted with model in alphabetical order. If model is same, then sorted with production in alphabetical order. if production is also same , then finally sorted with price in ascending order.

Thank you for attention, i stuck with this problem many days. Please help me.

public static void main(String[] args) {
 ArrayList<Car> car = new ArrayList<car>();


  //   something ignored//

    Collections.sort(car); <----------------------Problem

    for (Car c : car) {
        System.out.println(c);
    }
}



class car implements Comparable<car>{

protected String model;
protected String production;
protected int price;


public Tablet(String model ,String production , int price)
{
    this.model=model;
    this.price=price;
    this.production = production;

}
public int compareTo (car other)
{ 
         ?????????????????
}
 }




    class mini-bus extends car
{
private door;
 public Tablet(String model ,String production , int price ,int door)
{
   super(model , production ,  price);
   this.door = door;
}
} 

Answer 1

The principle is quite straightforward:

• Compare the first pair of properties. If they are different, return the negative/positive compare value; otherwise...
• Compare the second pair of properties. If they are different, return the negative/positive compare value; otherwise...
• ... (repeat for as many pairs of properties as you have) ...
• Compare the last pair of properties. This is the last property, so return the compare value.

For example:

int compareModels = this.model.compareTo(that.model);
if (compareModels != 0) {
  return compareModels;
}
int compareProd = this.production.compareTo(that.production);
if (compareProd != 0) {
  return compareProd;
}
return Integer.compare(this.price, that.price);

Note that there is also a nice class in Guava called ComparisonChain which reduces a lot of this boilerplate logic:

return ComparisonChain.start()
    .compare(this.model, that.model)
    .compare(this.production, that.production)
    .compare(this.price, that.price)
    .result();

This stops comparing once a difference is found between any pair of properties. It will still access the subsequent properties, but that should hopefully be an irrelevantly cheap thing to do anyway.

Answer 2

Here is the general approach to the problem of multi-attribute sorting:

• Decide on the ordered list of attributes by which you sort
• For each attribute on your list, compare the values on both sides
• If the result is not zero, return it right away
• If the result is zero, go to the next attribute on your list
• If you ran out of attributes, return zero

If the number of attributes is fixed, the "loop" on the ordered list of attributes is unrolled, ie each individual attribute is compared separately:

int res;
res = this.getA().compareTo(other.getA()); // e.g. model
if (res != 0) return res;
res = this.getB().compareTo(other.getB()); // e.g. production
if (res != 0) return res;
res = this.getC().compareTo(other.getC());
if (res != 0) return res;
...
// For the last attribute return the result directly
return this.getZ().compareTo(other.getZ()); // e.g. price

Answer 3

This should do:

public int compareTo(Car other){
        if(this.getModel().compareTo(other.getModel()) != 0){
            return this.getModel().compareTo(other.getModel());
        }else if(this.getProduction().compareTo(other.getProduction()) != 0){
            return this.getProduction().compareTo(other.getProduction());
        }else{
            return Integer.compare(this.getPrice(), other.getPrice());
        }
    }