檢查ArrayList中的重複

Question

Class:

public class Variant 
{ 
    private String variant; 
    private String quantity; 
    //getters and setters 
} 

ArrayList:

ArrayList<Variant> variantList = getVariantsList(); 

現在我要檢查variantList是否含有variant或不重複的項目？請注意0​​有兩個不同quantity的條目將被視爲重複。

Answer 1

您可以在您的Variant類中簡單地使用equals方法，並提供該方法中的所有平等規則。

@Override 
    public boolean equals(Object obj) { 
     .. 

然後你可以使用包含法或只是把它傳遞給一個Set，消除所有的副本。

如果你想variant有兩個不同數量的條目也被認爲是dup，那麼你可以在你的等號中添加該條件。

Answer 2

您可以使用：

if (variantList.contains(**<some other Variant object>**)){ 
... 
} 

Answer 3

只需選中一個對象與列表中的其他對象

覆蓋在變類的equals方法

@Override 
    public boolean equals(Object obj) { 
     if (obj != null) { 

      if (obj instanceof Variant) { 
       Variant temp = (Variant) obj; 
       return this.quantity.equals(temp.quantity); //for different quantity 
      } else { 
       return false; 
      } 
     } 
     return false; 
    } 

然後檢查：

for (int i = 0; i < variantList.size(); i++) { 
      for (int j = 0; j < variantList.size(); j++) { 
       if (i != j) { 
        if (iList.get(i).equals(iList.get(j))) { 
         //logic when duplicate 
         break; 
        } 
       } 
      } 
     } 

Answer 4

重寫equals(Object obj)方法並嘗試比較變體和數量上的對象。

嘗試通過變體列表循環，並使用variantList.contains(variant)檢查重複性。

Answer 5

你可以簡單地覆蓋你的Variant你的equals方法，並嘗試這樣

List<Varient> list =getVariantsList(); 
     System.out.println("here list size"+list.size()); 
     Set<Varient> set = new HashSet<Varient>(list); 
     System.out.println("here"+set.size()); 

Answer 6

有兩件事情你需要做的：

• 覆蓋的equals()在變類（最小代碼如下）： 請注意，下面的代碼只檢查數量，而不是變體道具。您的IDE也可以幫助您生成equals()。

  @Override 
  public boolean equals(Object object) { 
      boolean isEqual = (this == object); 
      if(object instanceof Variant){ 
       Variant variant = (Variant) object; 
       isEqual = this.quantity.equals(variant.quantity); 
      }else{ 
       isEqual = false; 
      } 
  
      return isEqual; 
  } 
  

• 檢查如果列表中包含的對象 - 這將使用equals()檢查，如果兩者相等。

  for (Variant variant : variantList) { 
      if (variantList.contains(variant)) { 
       //do logic if its present 
      } 
  } 
  

Answer 7

遵循以下原則：

1. 你的類Variant必須override的equals方法，因爲您可以根據質量因此在equals方法檢查定義複製條件對於質量屬性值即

   public class Variant { 
       private String variant; 
       private String quantity; 
   
   public Variant(String variant, String quantity) { 
       this.variant = variant; 
       this.quantity = quantity; 
   } 
   
   @Override 
   public int hashCode() { 
       final int prime = 31; 
       int result = 1; 
       result = prime * result 
         + ((quantity == null) ? 0 : quantity.hashCode()); 
       return result; 
   } 
   
   @Override 
   public boolean equals(Object obj) { 
       if (this == obj) 
        return true; 
       if (obj == null) 
        return false; 
       if (getClass() != obj.getClass()) 
        return false; 
       Variant other = (Variant) obj; 
       if (quantity == null) { 
        if (other.quantity != null) 
         return false; 
       } else if (!quantity.equals(other.quantity)) 
        return false; 
       return true; 
   } 
    
   
   }

2. 創建基本上檢查您的列表中是否包含重複的條目（變體）或不是方法，並返回真正並相應假：

private static boolean isListContainsDuplicateEntries(
      ArrayList variantList) { 
     final List setToReturn = new ArrayList(); 
     for (Variant v : variantList) { 
      if (!setToReturn.contains(v)) { 
       setToReturn.add(v); 
      } else { 
       return true; 
      } 
     } 
     return false; 
    }

1. 現在，測試功能：

   public static void main(String[] args) { 
        Variant variant1 = new Variant("1", "100"); 
        Variant variant2 = new Variant("2", "200"); 
        Variant variant3 = new Variant("3", "200");
    
   
       ArrayList<Variant> variantList = new ArrayList<>(); 
       variantList.add(variant1); 
       variantList.add(variant2); 
       variantList.add(variant3); 
   
       System.out.println(Variant.isListContainsDuplicateEntries(variantList)); 
   

輸出：真

Answer 8

創建一個變體光盤對象：

public class Varient { 

    private String variant; 
    private String quantity; 


public String getVariant() { 
    return variant; 
} 

public void setVariant(String variant) { 
    this.variant = variant; 
} 

public String getQuantity() { 
    return quantity; 
} 

public void setQuantity(String quantity) { 
    this.quantity = quantity; 
} 

@Override 
public boolean equals(Object o) { 
    if (this == o) return true; 
    if (!(o instanceof Varient)) return false; 

    Varient varient = (Varient) o; 

    if (!quantity.equals(varient.quantity)) return false; 
    if (!variant.equals(varient.variant)) return false; 

    return true; 
} 

@Override 
public int hashCode() { 
    int result = variant.hashCode(); 
    result = 31 * result + quantity.hashCode(); 
    return result; 
} 

}

這是您的主要計劃;

public class Test { 
     public static void main (String [] args){ 
// getVariantsList() here your list 
      List<Varient> list =getVariantsList(); 
      Set<Varient> set = new LinkedHashSet<Varient>(list); 
     } 
} 

Answer 9

public class Variant { 

    private String variant; 
    private String quantity; 

    @Override 
    public int hashCode() { 
     final int prime = 31; 
     int result = 1; 
     result = prime * result + ((variant == null) ? 0 : variant.hashCode()); 
     return result; 
    } 

    @Override 
    public boolean equals(Object obj) { 
     if (this == obj) 
      return true; 
     if (obj == null) 
      return false; 
     if (getClass() != obj.getClass()) 
      return false; 
     Variant other = (Variant) obj; 
     if (variant == null) { 
      if (other.variant != null) 
       return false; 
     } else if (!variant.equals(other.variant)) 
      return false; 
     return true; 
    } 

    public String getVariant() { 
     return variant; 
    } 

    public void setVariant(String variant) { 
     this.variant = variant; 
    } 

    public String getQuantity() { 
     return quantity; 
    } 

    public void setQuantity(String quantity) { 
     this.quantity = quantity; 
    } 

    public static void main(String[] args) { 
     // HashSet<Variant> set = new HashSet<>(); 


     // LinkedHashSet<Variant> linkedSet = new LinkedHashSet<>(); // stores 
     // in input order 

     /* 
     * You can use treeset to store data in custom order, in this case 
     * lexicographically 
     */ 
     TreeSet<Variant> treeSet = new TreeSet<>(new VariantComparator()); 
    } 
}