以 LIFO 顺序从列表中获取对象？ （后进先出）（初学者）

Question

（请记住，这是一个初学者问题）

我有两个class； MailItem 和 MailServer。我有一个测试 class，我在其中制作 MailItems 并将其发送到我的 MailServer。我将 MailItems 发送给了一个特定的用户，我希望以 LIFO 顺序（后进先出）检索这些邮件，因此最后发送的必须是我收到的第一个。

这是我的class。

MailItem class:

public class MailItem
{
    private String from;
    private String to;
    private String message;
    private String subject;

    public MailItem(String from, String to, String message, String subject)
    {
        this.from = from;
        this.to = to;
        this.message = message;
        this.subject = subject;
    }

    public String getFrom()
    {
        return from;
    }

    public String getTo()
    {
        return to;
    }

    public String getSubject(){
        return subject;
    }

    public String getMessage()
    {
        return message;
    }

    public void print()
    {
        System.out.println("From: " + from);
        System.out.println("To: " + to);
        System.out.println("Message: " + message);
        System.out.println("Subject: " + subject);
    }
}

邮件服务器class:

public class MailServer
{
    private List<MailItem> items;
    private HashMap<String, List<MailItem>> hashmap;

    public int howManyMessages(){
        return items.size();
    }

    public int howManyUsers(){
        return hashmap.size();
    }

    public MailServer()
    {
        items = new LinkedList<MailItem>();
        hashmap = new HashMap<String, List<MailItem>>();
    }

    public int howManyMailItems(String who)
    {
        int count = 0;
        for(MailItem item : items) {
            if(item.getTo().equals(who)) {
                count++;
            }
        }
        return count;
    }

    public MailItem getNextMailItem(String who)
    {
        Iterator<MailItem> it = items.iterator();
        while(it.hasNext()) {
            MailItem item = it.next();
            if(item.getTo().equals(who)) {
                it.remove();
                return item;
            }
        }
        return null;
    }

    public void post(MailItem item)
    {
        if(!isEmpty(item)){
            items.add(item);
        }
    }

    private boolean isEmpty(MailItem mail){
        if(mail.getFrom() == "" || mail.getTo() == ""){
            return true;
        }
        return false;
    }

    public int createMailbox(String user){
        if(hashmap.containsKey(user)){
            return 0;
        }
        List<MailItem> mil = new ArrayList<MailItem>();
        hashmap.put(user, mil);
        return 1;
    }

    public int createMailbox(String[] users){
        int createdBoxes = 0;
        for(String user: users){
            int created = createMailbox(user);
            if(created == 1){
                createdBoxes++;
            }
        }
        return createdBoxes;
    }

    private List<MailItem> getMailbox(String who){
        if(hashmap.containsKey(who)){
            List<MailItem> ls = hashmap.get(who);
            return ls;
        }else{
            return null;
        }
    }
}

我的测试是这样的：

@Test
    public void testReceiveOrder(){
        mailServer.post(mess1User1to2);
        mailServer.post(mess2User1to2);
        assertEquals(mess2User1to2,mailServer.getNextMailItem("user2"));
    }

当我 运行 这个测试时，我以 FIFO（先进先出）的方式检索这些电子邮件。我没有检索名为 mess2User1to2 的邮件，而是收到了 mess1User1to2。我尝试使用 LinkedList 在 LIFO 中检索它们，但它对我不起作用。我做错了什么？

Answer 1

您的 post 方法将项目添加到列表末尾，您的 getNextMailItem 方法开始搜索列表前面的项目。因此你得到 FIFO (=queue) 行为。

要更改此设置，请从列表末尾开始搜索：

public MailItem getNextMailItem(String who) {
    ListIterator<MailItem> it = items.listIterator(items.size());
    while(it.hasPrevious()) {
        MailItem item = it.previous();
        if(item.getTo().equals(who)) {
            it.remove();
            return item;
        }
    }
    return null;
}

或者，您可以将项目添加到列表的前面，但我没有检查，如果这会破坏任何其他方法：

private LinkedList<MailItem> items;

public void post(MailItem item) {
    if(!isEmpty(item)){
        items.addFirst(item);
    }
}