在Java中使用集合的正確方法？

Question

我有以下代碼。不過，我懷疑這是否是正確的實施方式。

我的意思是：在收集框架有使用和創建類（MemberList）使用ArrayList，LinkedList，優先級隊列管理許多成員可以實現的聚集許多數據結構...

我想使用一個符合我需求的數據結構，並且在搜索，排序，刪除，添加，修改和刪除時，它的可能性最小。

public class MemberList{ 
    /** 
    *a list of accounts existing in the database 
    */ 
    private static List<Member> members = new ArrayList<Member>(); 
    /** 
    * add a member to our member list 
    * @param m the member to be added 
    */ 
    public static void Add(Member m) 
    { 
     members.add(m); 

    /** 
    * delete a member from our member list 
    * @param m the member to be deleted 
    */ 
    public static void Delete(Member m) 
    { 
     Iterator<Member> it = members.iterator(); 
     while(it.hasNext()) 
     { 
      if(m.equals(it.next())) 
      { 
       it.remove(); 
      } 
     } 
    } 

    /** 
    * Search for a specific member in the member list 
    * @param m the member that needs to be found 
    * @return the reference of the object Member 
    * @throws UserNotFoundExeption whether the member was not found in the list 
    */ 

    public static Member Search (Member m) throws UserNotFoundExeption 
    { 
     Iterator<Member> it = members.iterator(); 

     while(it.hasNext()) 
     { 
      if(m.equals(it.next())) 
      { 
       return it.next(); 

      }else{ 
       UserNotFoundExeption ex = new UserNotFoundExeption(it.next().getUsername()); 
       throw ex; 
      } 
     } 
     return null; 
    } 
    /** 
    * The login method enables checking whether the login was made successfully or not. if not, it can throw two 
    * exceptions to handle the errors 
    * @param member 
    * @return 
    * @throws UserNotFoundExeption 
    * @throws FailedLoginException 
    */ 
    public static boolean login (Member m) 
      throws UserNotFoundExeption,FailedLoginException { 

     try{ 
      Member member = Search(m); 
      if (!m.authenticate(member.getPassword())) 
      { 
       FailedLoginException ex2 = new FailedLoginException (member.getPassword()); 
       throw ex2; 
      } 
      else 
      { 
       return true; 
      } 
     }catch(UserNotFoundExeption ex){ 
      throw ex;    
     } 

    } 

    /** 
    * this behavior modify attributes of the corresponding class 
    * @param <T> this generic helps to accept any type of parameter change, hence we can change any type 
    * @param m this is the member that need to change his information 
    * @param choice the choice of which information to change 
    * @param change the new change on the member attribute 
    * @throws UserNotFoundExeption 
    */ 
    public static <T> void Modify(Member m, int choice, T change) throws UserNotFoundExeption 
    { 
     try{ 
      Member member = Search(m); 
      switch(choice) 
      { 
       case 1: 
        member.setUsername((String)change); 
        break; 

       case 2: 
        member.setPassword((String)change); 
        break; 

       case 3: 
        member.setCommunity((Community)change); 
        break; 
      } 
     }catch(UserNotFoundExeption ex){ 
      throw ex;    
     } 

    } 

    /** 
    * display the member list objects information 
    */ 
    public static void Display() 
    { 
     Iterator<Member> it = members.iterator(); 

     while(it.hasNext()) 
     { 
      System.out.println(it.next()); 
     } 
    } 

    /** 
    * Sort objects in the list 
    */ 
    public static void Sort() 
    { 
     Iterator<Member> it = members.iterator(); 
     Member[] Members_Array = members.toArray(new Member[members.size()]); 
     Member temp; 

     for(int i = 0; i<members.size(); i++) 
     { 
      for(int j = 0; j < members.size() - (i+1); j++) 
      { 
       if(Members_Array[j].compareTo(Members_Array[j+1]) > 0) 
       { 
        temp = Members_Array[j]; 
        Members_Array[j] = Members_Array[j+1]; 
        Members_Array[j+1] = temp; 
       } 
      } 
     } 

    }  
} 

謝謝！

Answer 1

這個問題太廣泛了，「在Java中使用集合的正確方法」也是一個哲學問題，所以它不能科學地回答。

針對您的情況，取決於您的成員池，當您需要將成員拉出時，您可能不希望對它們進行迭代。我建議你使用類似HashMap<String,Member>的東西，其中每個成員都有一個可識別的唯一密鑰（例如用戶名）。這將授予您O（1）的訪問速度，並允許您在需要時使用.values()進行迭代。

您可以使用HashMap像這樣：

// This is how you create a hash map: 
HashMap<String,Member> members = new HashMap<String,Member>(); 

// This is how you add an object to it. It is slower than lists, 
// but since reading happens far often, it pays off. 
members.put("ben", new Member()); 

// This is how you access an object in the hash map. 
// Accessing a hash map is O(1). 
Member member = members.get("ben"); 

// This is how you remove an object from the hash map. 
// Removing an object is also O(1) 
members.remove("ben"); 

// Hash maps are also iterable 
for(Member member : members.values()) { 
} 

Answer 2

如果你不想使用JDBC，我會使用數組列表。 但是，如果您的項目要成長，那麼您必須使用JDBC。