Array.sort 用于抽象类扩展器数组

Question

我有一个类 Shape 有一个私有字段 shapeColor，类 Triangle 、 Rectangle 和 Circle 扩展了 Shape 并有自己的其他字段。 我写了Shape的比较方法。 （我需要按颜色名称对它们进行排序）

public int compare (Shape obj) {
        return (this.getShapeColor().compareTo(obj.getShapeColor()));
    }

在 psvm 的主类中我有下一个代码：

Shape[] arr3 = new Shape[10];
arr3[6] = new Rectangle("RED", 11, 22);
arr3[1] = new Rectangle("GREEN", 12, 23);
arr3[7] = new Rectangle("BLACK", 13, 24);
arr3[3] = new Rectangle("YELLOW", 14, 25);
arr3[4] = new Rectangle("WHITE", 15, 26);
arr3[5] = new Circle("BLUE", 4);
arr3[0] = new Circle("BROWN", 5);
arr3[2] = new Triangle("BROWN", 5, 3, 4);
arr3[8] = new Triangle("ROYAL BLUE", 5, 7, 8);
arr3[9] = new Triangle("CHILD'S SURPRISE", 6, 4, 6);

        Arrays.sort(arr3, Shape::compare);

问题是 Shape 类在我的任务中必须是抽象的，但是 Arrays.sort(arr3, Shape::compare);没用。我该如何解决这个问题？

Answer 1

我建议这样一个抽象的形状基类：

public abstract class Shape implements Comparable<Shape> {
    private String color;

    public Shape(String color) {
        super();
        this.color = color;
    }
    
    // geters & setters
    
    @Override
    public int compareTo(Shape other) {
        if ((getAsciiSum(this.color)).compareTo(getAsciiSum(other.color)) < 0) {
            return -1;
        }
        if ((getAsciiSum(this.color)).compareTo(getAsciiSum(other.color)) == 0) {
            return 0;
        }
        return 1;
    }
    
    // toString
    
    public int getAsciiSum() {
        return getAsciiSum(this.color);
    }

    private Integer getAsciiSum(String str) {
        int sum = 0;
        for (Character ch : str.toCharArray()) {
            int asciiValue = ch;
            sum += asciiValue;
        }
        return sum;
    }
    
    // finish

和形状扩展器如下

圈子：

public class Circle extends Shape implements ShapeType {

    private int radius;

    public Circle(String color) {
        super(color);
    }

    public Circle(String color, int radius) {
        this(color);
        this.radius = radius;
    }       
    
    // geters & setters, toString

矩形：

public class Rectangle extends Shape implements ShapeType {

    int width;
    int highth;

    public Rectangle(String color) {
        super(color);
    }

    public Rectangle(String color, int width, int highth) {
        this(color);
        this.width = width;
        this.highth = highth;
    }

    // geters & setters, toString 

三角形：

public class Triangle extends Shape implements ShapeType {

    private int sideOne;
    private int sideTwo;
    private int sideThree;

    public Triangle(String color) {
        super(color);
    }

    public Triangle(String color, int sideOne, int sideTwo, int sideThree) {
        this(color);
        this.sideOne = sideOne;
        this.sideTwo = sideTwo;
        this.sideThree = sideThree;
    }


    // geters & setters, toString 

在以下命令之后：

    System.out.println("\nbefore sort:");
    print(arr3);

    Arrays.sort(arr3, Shape::compareTo);

    System.out.println("\nafter sort:");
    print(arr3);

我们可以得到结果-

排序前：

Circle [AsciiSum=392, color=BROWN, radius=5]|i=0

Rectangle [AsciiSum=369, color=GREEN, width=12, highth=23]|i=1

Triangle [AsciiSum=392, color=BROWN, sideOne=5, sideTwo=3, sideThree=4]|i=2

Rectangle [AsciiSum=476, color=YELLOW, width=14, highth=25]|i=3

Rectangle [AsciiSum=385, color=WHITE, width=15, highth=26]|i=4

Circle [AsciiSum=296, color=BLUE, radius=4]|i=5

Rectangle [AsciiSum=219, color=RED, width=11, highth=22]|i=6

Rectangle [AsciiSum=349, color=BLACK, width=13, highth=24]|i=7

Triangle [AsciiSum=719, color=ROYAL BLUE, sideOne=5, sideTwo=7, sideThree=8]|i=8

Triangle [AsciiSum=1147, color=CHILD'S SURPRISE, sideOne=6, sideTwo=4, sideThree=6]|i=9

排序后：

Rectangle [AsciiSum=219, color=RED, width=11, highth=22]|i=0

Circle [AsciiSum=296, color=BLUE, radius=4]|i=1

Rectangle [AsciiSum=349, color=BLACK, width=13, highth=24]|i=2

Rectangle [AsciiSum=369, color=GREEN, width=12, highth=23]|i=3

Rectangle [AsciiSum=385, color=WHITE, width=15, highth=26]|i=4

Circle [AsciiSum=392, color=BROWN, radius=5]|i=5

Triangle [AsciiSum=392, color=BROWN, sideOne=5, sideTwo=3, sideThree=4]|i=6

Rectangle [AsciiSum=476, color=YELLOW, width=14, highth=25]|i=7

Triangle [AsciiSum=719, color=ROYAL BLUE, sideOne=5, sideTwo=7, sideThree=8]|i=8

Triangle [AsciiSum=1147, color=CHILD'S SURPRISE, sideOne=6, sideTwo=4, sideThree=6]|i=9

-- 编辑--

当然可以按字典顺序比较颜色字段中的字符串，然后 compareTo 方法可以很简单，如：

@Override
public int compareTo(Shape other) {
    if ((this.color).compareTo(other.color) < 0) {
        return -1;
    }
    if ((this.color).compareTo(other.color) == 0) {
        return 0;
    }
    return 1;
}

排序后的数组元素顺序如下：

Rectangle [AsciiSum=349, color=BLACK, width=13, highth=24]|i=0

Circle [AsciiSum=296, color=BLUE, radius=4]|i=1

Circle [AsciiSum=392, color=BROWN, radius=5]|i=2

Triangle [AsciiSum=392, color=BROWN, sideOne=5, sideTwo=3, sideThree=4]|i=3

Triangle [AsciiSum=1147, color=CHILD'S SURPRISE, sideOne=6, sideTwo=4, sideThree=6]|i=4

Rectangle [AsciiSum=369, color=GREEN, width=12, highth=23]|i=5

Rectangle [AsciiSum=219, color=RED, width=11, highth=22]|i=6

Triangle [AsciiSum=719, color=ROYAL BLUE, sideOne=5, sideTwo=7, sideThree=8]|i=7

Rectangle [AsciiSum=385, color=WHITE, width=15, highth=26]|i=8

Rectangle [AsciiSum=476, color=YELLOW, width=14, highth=25]|i=9

    

Answer 2

Arrays.sort() 需要一个数组和Comparator。
你可以像这样定义你的Comparator

Comparator shapeComparator = new Comparator<Shape>() {
                                     @Override
                                     public int compare(Shape o1, Shape o2) {
                                          return o1.color.compareTo(o2.color);
                                     }
                            };

您可以像这样将定义的shapeComparator 赋予Arrays.sort()

Arrays.sort(shapes, shapeComparator);

Answer 3

Class Shape{
protected String color;

@Override
public int hashCode(){
         //give your definition
}

@Override
public int equals(){
  //give your definition
}

}
Class Rectangle extends Shape{
  private int height;
  private int length;
}
Class Circle extends Shape{
  private int redius;
}

Class Triangle extends Shape{
  //declare your member variable 
}

尝试编写一个比较器类并在 Arrays.sort(arr, shapeComparator) 中传递它的引用。

并自动 sort() 方法根据它对形状类数组进行排序。

class SortbyColor implements Comparator<Shape> {
    // Used for sorting in ascending order of
    // Color
    public int compare(Shape a, Shape b)
    {
        return a.color.compareTo(b.color);
    }
}

OR上面的比较器代码也可以改写为

Comparator shapeComparator = new Comparator<Shape>() {
                                     @Override
                                     public int compare(Shape a, Shape b) {
                                          return a.color.compareTo(b.color);
                                     }
                            };

现在调用Arrays.sort(arr, new SortbyColor())，你的数组会自动变短