从LIFO命令列表中获取对象？ （后进先出）（初学者）

Question

（请注意，这是一个初学者问题）

我有两个类; MailItem和MailServer。我有一个测试类，在那里我发送和发送MailItem到我的MailServer。我向一个特定用户发送MailItems，我希望以LIFO顺序（后进先出）检索这些邮件，因此发送的最新邮件必须是我收到的第一个邮件。

这是我的课程。

的MailItem类：

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在LIFO中检索它们，但它不适用于我。我做错了什么？

Answer 1

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

或者，也可以代替将商品加入列表的前面，但我还没有检查，如果这打破任何其他方法：

private LinkedList<MailItem> items; 

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