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

（请记住这是初学者的问题）

我有两个班<代码>邮件项目和

邮件服务器

。我有一个测试类，在那里我制作邮件并将邮件发送到我的邮件服务器。我将邮件发送给一个特定的用户，我希望以后进先出的顺序（后进先出）检索这些邮件，因此最晚发送的邮件必须是我收到的第一个邮件

这是我的课

邮件项目类：

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

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

邮件服务器类：

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

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在后进先出中检索它们，但对我来说不起作用。我做错了什么？

您的

post

方法将项目添加到列表的末尾，并且

getNextMailItem

方法开始搜索列表前面的项目。因此，您可以获得FIFO（=队列）行为

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

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

publicmailitem getNextMailItem（字符串who）{
ListIterator it=items.ListIterator（items.size（））；
while（it.hasPrevious（））{
MailItem=it.previous（）；
如果（item.getTo（）.equals（who））{
it.remove（）；
退货项目；
}
}
返回null；
}

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

private LinkedList<MailItem> items;

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

私有链接列表项；
公开作废邮件（邮件项目）{
如果（！isEmpty（项目））{
项目。添加第一个（项目）；
}
}

您的

post

方法将项目添加到列表的末尾，而

getNextMailItem

方法开始搜索列表前面的项目。因此，您可以获得FIFO（=队列）行为

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

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

publicmailitem getNextMailItem（字符串who）{
ListIterator it=items.ListIterator（items.size（））；
while（it.hasPrevious（））{
MailItem=it.previous（）；
如果（item.getTo（）.equals（who））{
it.remove（）；
退货项目；
}
}
返回null；
}

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

private LinkedList<MailItem> items;

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

私有链接列表项；
公开作废邮件（邮件项目）{
如果（！isEmpty（项目））{
项目。添加第一个（项目）；
}
}

谢谢，我使用了第二部分，因为它没有破坏其他方法。谢谢，我使用了第二部分，因为它没有破坏其他方法。