Sort awt Rectangle by Surface Area using Comparable - sorting

Question

This code compares awt rectangles by surface area but I am getting an error when I use collections.sort. I want it to output a sorted ArrayList of awt rectangles based on their surface area.
surface area = width * height.
I have created a sorting class and extended the comparable interface and I am calling/invoking this class as a parameter in Collections.sort(rectangleList, new SortBySurfaceArea());, however when I put a cursor over collections.sort, I get this pop-up error.
no suitable method found for sort(List<Rectangle>,SortBySurfaceArea)
method Collections.<T#1>sort(List<T#1>) is not applicable
(cannot infer type-variable(s) T#1
(actual and formal argument lists differ in length))
method Collections.<T#2>sort(List<T#2>,Comparator<? super T#2>) is not applicable
(cannot infer type-variable(s) T#2
(argument mismatch; SortBySurfaceArea cannot be converted to Comparator<? super T#2>))
where T#1,T#2 are type-variables:
T#1 extends Comparable<? super T#1> declared in method <T#1>sort(List<T#1>)
T#2 extends Object declared in method <T#2>sort(List<T#2>,Comparator<? super T#2>)
(Alt-Enter shows hints)
Code listing follows:
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* #author HP
*/
public class RectangleSurfaceAreaComparable {
/**
* #param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Rectangle rectangle_0 = new Rectangle(50, 4);
Rectangle rectangle_1 = new Rectangle(80, 3);
Rectangle rectangle_2 = new Rectangle(90, 2);
System.out.println(surfaceArea(rectangle_0.getWidth(), rectangle_0.getHeight()));
List<Rectangle> rectangleList = new ArrayList<>();
rectangleList.add(rectangle_0);
rectangleList.add(rectangle_1);
rectangleList.add(rectangle_2);
for (Rectangle rectangle : rectangleList) {
System.out.println("" + rectangle);
}
Collections.sort(rectangleList, new SortBySurfaceArea());
for (Rectangle rectangle : rectangleList) {
System.out.println("" + rectangle);
}
}
/**
*
* #param width
* #param height
* #return
*/
public static double surfaceArea(double width, double height) {
double sa = width * height;
return sa;
}
}
SortBySurfaceArea.java
import java.awt.Rectangle;
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* #author HP
*/
public class SortBySurfaceArea implements Comparable<Rectangle> {
#Override
public int compareTo(Rectangle o) {
return (o.height * o.width);
}
}

Answer 1

Collections.sort needs a Comparator, not a Comparable, so your SortBySurfaceArea could be:
import java.awt.Rectangle;
import java.util.Comparator;
public class SortBySurfaceArea implements Comparator<Rectangle>
{
public int compare(Rectangle o1, Rectangle o2)
{ return o1.height*o1.width-o2.height*o2.width; }
}
No I want to use comparable
How about this? (You might want to call SortBySurfaceArea differently, e. g. SortableRectangle.)
import java.awt.Rectangle;
public class SortBySurfaceArea extends Rectangle implements Comparable<Rectangle>
{
public SortBySurfaceArea(Rectangle r) { super(r); }
public int compareTo(Rectangle o) { return height*width-o.height*o.width; }
}
…
List<SortBySurfaceArea> rectangleList = new ArrayList<>();
rectangleList.add(new SortBySurfaceArea(rectangle_0));
rectangleList.add(new SortBySurfaceArea(rectangle_1));
rectangleList.add(new SortBySurfaceArea(rectangle_2));
…
Collections.sort(rectangleList);