0

当另一个列表循环通过时，我有一些对象（Ranks）被添加到列表中。

这些对象中的每一个都有一个“up”和一个“down”属性，需要分别设置为下一个和上一个元素。如果元素位于列表的顶部，“up”属性应该指向自身，底部元素也是如此。

我正在使用 Vector ( java.util.Vector)，因此我可以使用索引来查找以下和以前的元素。这是添加过程，向上/向下操作：

public void addToRanksInOrderWithUpDown(Rank r) {
    ranksInOrder.addElement(r);
    if (ranksInOrder.size() != 1) {
        Rank ru, rd;
        try {
            ru = ranksInOrder.elementAt(ranksInOrder.indexOf(r)+1);
        } catch (ArrayIndexOutOfBoundsException e) {
            ru = r;
        }
        try {
            rd = ranksInOrder.elementAt(ranksInOrder.indexOf(r)-1);
        } catch (ArrayIndexOutOfBoundsException e) {
            rd = r;
        }
        r.setUp(ru);
        r.setDown(rd);
        ru.setDown(r);
        rd.setUp(r);
    }
}

r作为一个传递的实例Rank。这是循环：

if (g.getRanksInOrder().size() == 1) {
    g.addToRanksInOrder(currentRank);
} else {
    g.addToRanksInOrderWithUpDown(currentRank);
}

addToRanksInOrderaddToRanksInOrderWithUpDown只需执行,的第一步ranksInOrder.addElement(r);。

不幸的是，“up”和“down”通常最终是 Null 或错误的东西。有什么更好的方法来解决这个问题？我可以修复我的代码，还是需要废弃它？

编辑：对不起，但没有一个答案真的有效。问题仍然像以前一样，各种起伏保持为空或错误。

这是一个SSCCE：

public class Rank {
    private Rank up;
    private Rank down;
    private String name;
    public Rank getUp() {
        return up;
    }
    public Rank getDown() {
        return down;
    }
    public Rank getName() {
        return name;
    }
    public void setUp(Rank r) {
        up = r;
    }
    public void setDown(Rank r) {
        down = r;
    }
    public Rank(String s) {
        name = s;
    }
}

public class Ranker {
    private Set<Rank> ranks = new HashSet<Rank>();
    private Vector<Rank> ranksInOrder = new Vector<Rank>(); 
    public Vector<Rank> sort() {
        for (Rank r : ranks) {
            if (ranksInOrder.size == 1) {
                addToRanksInOrder(r);
            } else {
                addToRanksInOrderWithUpDown(r);
            }
        }
        return ranksInOrder;
    }
    private void addToRanksInOrderWithUpDown(Rank r) {
        ranksInOrder.addElement(r);
        if (ranksInOrder.size() != 1) {
            Rank ru, rd;
            try {
                ru = ranksInOrder.elementAt(ranksInOrder.indexOf(r)+1);
            } catch (ArrayIndexOutOfBoundsException e) {
                ru = r;
            }
            try {
                rd = ranksInOrder.elementAt(ranksInOrder.indexOf(r)-1);
            } catch (ArrayIndexOutOfBoundsException e) {
                rd = r;
            }
            r.setUp(ru);
            r.setDown(rd);
            ru.setDown(r);
            rd.setUp(r);
        }
    }
    private void addToRanksInOrder(Rank r) {
        ranksInOrder.addElement(r);
    }
    private String displayAsList(Vector<Rank> vr) {
        String list = "";
        for (Rank r : vr) {
            list += "~" + r.getName() + "\n";
            if (r.getUp() == null) {
                list += " +NULL\n";
            } else {
                list += " +" + r.getUp().getName() + "\n";
            }
            if (r.getDown() == null) {
                list += " -NULL\n";
            } else {
                list += " -" + r.getDown().getName() + "\n";
            }
            list += "----\n";
        }
        return list;
    }
    public static void main(String[] args) {
        for (int i=0;i<11;i++) {
            ranks.add(new Rank("Rank " + i));
        }
        System.out.println(displayAsList(sort()));
    }
}
4

4 回答 4

1

而不是捕获代码块，只需尝试

r.setDown(r);

在您的捕获代码中。

由于addElement总是将元素添加到 Vector 的末尾，因此根本不需要拥有ru。

public void addToRanksInOrderWithUpDown(Rank r) {
    ranksInOrder.addElement(r);
    if (ranksInOrder.size() != 1) {
        Rank rd;
        try {
            rd = ranksInOrder.elementAt(ranksInOrder.indexOf(r)-1);
            r.setUp(rd);
            r.setDown(r);
            rd.setDown(r);
        } catch (ArrayIndexOutOfBoundsException e) {
            r.setUp(r);
            r.setDown(r);
        }

    }
}

希望这可以帮助。

于 2012-12-22T08:17:21.483 回答
1

试试这个

void addToRanksInOrderWithUpDown(Rank r) {
    r.setUp(r);
    if (ranksInOrder.isEmpty()) {
        r.setDown(r);
    } else {
        Rank last = ranksInOrder.get(ranksInOrder.size() - 1);
        r.setDown(last);
        last.setUp(r);
    }
    ranksInOrder.add(r);
}

备注：

使用 Vector 似乎很奇怪，它是一个遗留类，请改用 ArrayList。

您不应该对控制流使用异常，这是一种已知的反模式。参见 J.Bloch 的“Effective Java”，第 57 条：“仅在异常情况下使用异常”。

于 2012-12-22T08:27:39.967 回答
1

向量列表上的第一个元素对于 Rank.up() 将始终为 null，因为没有更多的“向上”元素。除非您同意拥有像 Rank r 这样的第一个元素；r.setUp(r);

向量上的最后一个元素对于 Rank.down() 将始终为 null，因为没有更多的“向下”元素。除非您同意拥有像 Rank r 这样的最后一个元素；r.setDown(r);

因此，解决方案之一是：

public void addToRanksInOrderWithUpDown(Rank r) {

    r.setDown(r); // r will always be the last element for the moment.

    if(ranksInOrder.isEmpty()) {
        // Link r to itself.
        r.setUp(r);
    } else {
        // Link former last element to r and vice versa.
        Rank last = ranksInOrder.lastElement();
        last.setDown(r);
        r.setUp(last);
    }

    ranksInOrder.addElement(r);
}
于 2012-12-22T08:44:02.480 回答
1 
import java.util.HashSet;
import java.util.Set;
import java.util.Vector;

class Rank {
    private Rank up;
    private Rank down;
    private String name;
    public Rank getUp() {
        return up;
    }
    public Rank getDown() {
        return down;
    }
    public String getName() {
        return name;
    }
    public void setUp(Rank r) {
        up = r;
    }
    public void setDown(Rank r) {
        down = r;
    }
    public Rank(String s) {
        name = s;
    }
}

public class Ranker {
    private Set<Rank> ranks = new HashSet<Rank>();
    private Vector<Rank> ranksInOrder = new Vector<Rank>();
    public Vector<Rank> sort() {
        for (Rank r : ranks) {
            *if (ranksInOrder.size() == 0) {*
                addToRanksInOrder(r);
            } else {
                addToRanksInOrderWithUpDown(r);
            }
        }
        return ranksInOrder;
    }
    private void addToRanksInOrderWithUpDown(Rank r) {
        ranksInOrder.addElement(r);
        *int ruEx =0;int rdEx = 0;*
        if (ranksInOrder.size() != 1) {
            Rank ru, rd;
            try {
                ru = ranksInOrder.elementAt(ranksInOrder.indexOf(r)-1);
            } catch (ArrayIndexOutOfBoundsException e) {
                ru = r;
                *ruEx = 1;*
            }
            try {
                rd = ranksInOrder.elementAt(ranksInOrder.indexOf(r)+1);
            } catch (ArrayIndexOutOfBoundsException e) {
                rd = r;
                *rdEx = 1;*
            }
            r.setUp(ru);
            r.setDown(rd);
            *if(ruEx == 0){
                ru.setDown(r);
            }
            if(rdEx == 0){
                rd.setUp(r);
            }*

        }
    }
    private void addToRanksInOrder(Rank r) {
        *r.setDown(r);
        r.setUp(r);*
        ranksInOrder.addElement(r);
    }

    private String displayAsList(Vector<Rank> vr) {
        String list = "";
        for (Rank r : vr) {
            list += "~" + r.getName() + "\n";
            if (r.getUp() == null) {
                list += " +NULL\n";
            } else {
                list += " +" + r.getUp().getName() + "\n";
            }
            if (r.getDown() == null) {
                list += " -NULL\n";
            } else {
                list += " -" + r.getDown().getName() + "\n";
            }
            list += "----\n";
        }
        return list;
    }
    public static void main(String[] args) {

        Ranker r = new Ranker();
        for (int i=0;i<11;i++) {
            r.getRanks().add(new Rank("Rank " + i));
        }
        System.out.println(r.displayAsList(r.sort()));
    }
    public Set<Rank> getRanks() {
        return ranks;
    }
    public void setRanks(Set<Rank> ranks) {
        this.ranks = ranks;
    }
}
于 2012-12-24T15:21:17.633 回答