Question

Class:

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

ArrayList:

ArrayList<Variant> variantList = getVariantsList();

现在我想检查variantList是否包含variant的重复条目？请注意，variant有两个不同quantity的条目被视为重复条款。

Answer 1

您可以在@Override public boolean equals(Object obj) { ..类中简单地使用equals方法，并提供该方法中所有相等的规则。

Set

然后您可以使用contains方法或将其传递给variant，这样就可以消除所有重复项。

如果您希望{{1}}有两个不同数量的条目也被视为重复，那么您可以在等号中添加该条件。

Answer 2

只需使用列表

的其他对象检查一个对象

在Variant类

中覆盖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 3

覆盖equals(Object obj)方法并尝试比较变体和数量上的对象。

尝试循环使用variantList，并使用variantList.contains(variant)检查双重性。

Answer 4

您需要做两件事：

覆盖Variant类中的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 5

遵循以下准则：

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


}

创建一种方法，基本上检查您的列表是否包含重复的条目（Variant），并返回 true 和 false 相应地：

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

现在，测试功能：

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

输出：true

Answer 6

您可以使用contains()：

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

Answer 7

您可以在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 8

创建一个varient对象：

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

检查ArrayList是否有重复项

9 个答案: