Question

我有一个Woning（house）和一个子类KoopWoning（可购买的House）和一个子类HuurWoning（可租用的House）。 KoopWoning和Huurwoning扩展了Woning。 HuurWoning只是一个Woning，而KoopWoning有一个额外的可变能量级别。 KoopWoning还有一个函数getEnergylevel，它返回KoopWoning的energylevel。我还有一个Portefeuille课程，里面有一个Woningen的arraylist。

我正在从文本文件中读取Portefeuille中的所有Woningen。在第5课中，我希望能够对Portefeuille的Woningen的ArrayList（来自文本文件）进行排序。我有一个函数woningenTot（int maxprijs），它返回一个ArrayList，其中包含所有满足要求的Woningen（价格低于maxprijs）。这些Woningen我想在屏幕上打印。

问题如下：文件中还可能存在KoopWoning。在那种情况下，我也希望能够对能量级别进行排序。但是，我无法对能量水平进行分类。我无法调用函数getEnergylevel，因为它是一个ArrayList，而Woning不包含函数getEnergylevel。

那我怎么解决这个问题呢？如果它太模糊，我可以包含代码，但它非常大：O

感谢任何帮助;我已经花了几个小时来完成这个程序，仅此一个问题至少需要1.5小时:(

编辑：这是KoopWoning课程的代码

public class KoopWoning extends Woning implements EnergiepeilWoning {
private char energiepeil;

public KoopWoning (Adres adres, int kamers, int vraagPrijs, char energiepeil) {
    super(adres, kamers, vraagPrijs);
    this.energiepeil = energiepeil; 
}

public char getEnergiepeil () {
    return energiepeil;
}

public boolean compareEnergiepeil (Object other) {
    boolean res = false;
    if (other instanceof KoopWoning) {
        KoopWoning that = (KoopWoning) other;
        res = (this.getEnergiepeil() == that.getEnergiepeil());
    }
    return res; 
}

public String toString () {
    String res = adres + ", " + kamers + " kamers, prijs " + prijs + ", energiepeil " + energiepeil;
    return res;
}

这是Woning类的代码

public class Woning {
protected int kamers;
protected int prijs;
protected Adres adres;
protected String tag;

public Woning (Adres adres, int kamers, int prijs) {
    this.adres = adres;
    this.kamers = kamers;
    this.prijs = prijs;     
}

public String toString () {
    String res = adres + ", " + kamers + " kamers, prijs " + prijs;
    return res;
}

public void setTag (String tag) {
    this.tag = tag;
}

public String getTag () {
    return tag;
}

public boolean kostHooguit (int maxprijs) {
    return (prijs <= maxprijs);
}

public boolean equals (Object other) {
    boolean res = false;
    if (other instanceof Woning) {
        Woning that = (Woning) other;
        if (this.adres.equals(that.adres))
            res = true;
    }
    return res;
}

public static Woning read (Scanner sc) {
    try {
        Adres adress = Adres.read(sc);
        int kamer = sc.nextInt();
        sc.next();
        sc.next();
        int prijs = sc.nextInt();
        String check = sc.next();
        if (check.equals("energiepeil")) {
            char peil = sc.next().charAt(0);
            KoopWoning kwoning = new KoopWoning (adress, kamer, prijs, peil);
            return kwoning;
        }
        else {
            Woning woning = new Woning (adress, kamer, prijs);
            return woning;
        }
    }
    catch (Exception e) {
        System.out.println("Woning: Exception is caught");
        System.out.println(e.getMessage());
        Adres adress = new Adres ("", "", "", "");
        Woning woning = new Woning (adress, 0, 0);
        return woning;
    }
}
}

最后，Portefeuille类的代码

public class Portefeuille {

private ArrayList<Woning> woninglijst;

public Portefeuille () {
    woninglijst = new ArrayList<Woning>();
}

public void voegToe (Woning woning) {
    if (!woninglijst.contains(woning))
        woninglijst.add(woning);
}

public ArrayList<Woning> woningenTot (int maxprijs) {
    ArrayList<Woning> woninglijst2 = new ArrayList<Woning>();
    for (int i = 0; i < woninglijst.size(); i++) {
        if(woninglijst.get(i).kostHooguit(maxprijs))
            woninglijst2.add(woninglijst.get(i));
    }
    return woninglijst2;
}

public String toStringExt () {
    String res = "[";
    for (int i = 0; i < woninglijst.size(); i++)
        res = res + woninglijst.get(i).toString() + "; ";
    if (woninglijst.size() != 0)
        res = res.substring (0, res.length() - 2);
    res = res + "]";
    return res;
}

public String toString () {
    String res = "";
    for (int i = 0; i < woninglijst.size(); i++)
        res = woninglijst.get(i).toString2();
    return res;
}

public boolean equals (Object other) {
    boolean res = false;
    if (other instanceof Portefeuille) {
        Portefeuille that = (Portefeuille) other;
        if (this.woninglijst.size() == that.woninglijst.size()) {
            int i = 0;
            while (i < this.woninglijst.size() && this.woninglijst.get(i).equals(that.woninglijst.get(i)))
                i = i + 1;
            res = (i == this.woninglijst.size());
        }
    }
    return res;
}

public static Portefeuille read (String infile) {
    try {
        Scanner sc = new Scanner (new File(infile));
        ArrayList<Woning> wlijst = new ArrayList<Woning>();
        Portefeuille p = new Portefeuille();
        int woningen = sc.nextInt();
        int i = 0;
        while (i < woningen) {
            sc.nextLine();
            String tag = sc.nextLine();
            wlijst.add(Woning.read(sc));
            p.voegToe(wlijst.get(i));
            i++;
        }
        sc.close();
        return p;
    }

    catch (Exception e) {
        System.out.println("Portefeuille: Exception is caught");
        Portefeuille p = new Portefeuille();
        return p;
    }   
}
}

修改

我自己修好了。谢谢你回答大家：）

Answer 1

您可以在顶级类上定义类似getSortableValue()的方法，并实现它以返回默认字段（您没有提及您需要为{{1}排序的字段}}）。在Woningen中，您重写此方法以返回KoopWoning。然后，您始终对energyLevel返回的值进行排序。

Answer 2

您可以在Comparator上定义Woning，确定两个Woning的相对排序。你可以通过一个方法来查看两个参数的实际类型，然后采取适当的行动，或者更好的方法是使用一个可重写的Woning方法返回一些可用于排序的值。

例如，如果您决定任何具有能量水平的东西应该在没有能量水平的任何东西之后，那么您可以KoopWoning返回具有long的高阶位的能量水平的东西。，因此它总是高于没有任何一个的任何东西（基本上你将默认能量水平设置为零）。

然后，您可以使用

Collections.sort(arrayList, myComparator);

根据您创建的Comparator对列表进行排序。

Guava库中有一些很好的类可以帮助Comparator构建多个键，但如果你的情况相当简单，你可能不需要它们。

Answer 3

您可以让他们实施Comparable，就像Woning implements Comparable<Woning>一样。这将允许您实现（必需）方法：

@override
public int compareTo(Woning other) {
    int result = Integer.compareto(maxPrijs, other.maxPrijs);
    if (result != 0) return result;
    result = Integer.compareto(someField, other.someField);
    if (result != 0) return result;
    // etc...
    return 0;
}

子类KoopWoning extends Woning implements Comparable<KoopWoning>可以有这样的方法：

@override
public int compareTo(KoopWoning other) {
    int result = Integer.compareto(energylevel, other.energylevel);
    if (result != 0) return result;
    return super.compareTo(other);
}

然后你需要做的就是在列表中加载所有Woning实例并执行

Collections.sort(list);

子类继承Comparable是可选的，因此HuurWoning的排序方式与Woning类似。

ArrayList <superclass>但使用ArrayList <subclass> .methodofsubclass </subclass> </superclass>

修改

3 个答案: