Question

我已经将对象（Rank s）添加到列表中，因为另一个列表已循环通过。

这些对象中的每一个都具有“向上”和“向下”属性，这些属性需要分别设置为以下元素和前一个元素。如果元素位于列表的顶部，则“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);
}

addToRanksInOrder只是执行addToRanksInOrderWithUpDown，ranksInOrder.addElement(r);的第一步。

不幸的是，“向上”和“向下”经常最终成为无效或错误的东西。有什么更好的方法来解决这个问题？我可以修复我的代码，还是需要废弃？

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

这是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()));
    }
}

Answer 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);
        }

    }
}

希望这有帮助。

Answer 2

试试这个

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项：“仅对特殊情况使用例外”。

Answer 3

向量列表中的第一个元素对于Rank.up（）始终为null，因为没有更多'up'元素。除非你同意像Rank r这样的第一个元素; r.setUp（R）;

向量上的最后一个元素对Rank.down（）始终为null，因为没有更多'down'元素。除非你同意像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);
}

Answer 4

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;
    }
}

更新链接列表/向量的属性

4 个答案: