Java 搜索存储自定义对象的ArrayList

我有一个名为alphabets的自定义类

public class Alphabets {
    String alp;

    public Alphabets(String alp) {
        this.alp = alp;
    }

    public String getAlp() {
        return alp;
    }
}

我有两个

ArrayLists

，每个都包含自定义对象或类型（

String

&

Alphabets

）

ArrayList ar=new ArrayList（）；
ArrayList br=新的ArrayList（）；
字母a=新字母（“a”）；
字母b=新字母（“b”）；
字母b_克隆=新字母（“b”）；
ar.添加（a）；
ar.添加（b）；
br.添加（b_克隆）；
System.out.println（ar.contains（br.get（0））；

输出为false，这在技术上是正确的，但对象中包含的实际值是相等的（在本例中为“B”）。这当然只是代码片段。我需要检查两个完整的

ArrayList

，以查看其中一个列表是否包含来自另一个列表的对象，因此无法使用内置的.contains函数。

---

是否有一种快速的方法或任何解决方案可以解决此问题？

从列表的文档中读取。包含方法

如果此列表包含指定的元素，则返回true。更正式地说，
当且仅当此列表至少包含 一个元素e使得（o==null？e==null:o.equals（e））

因此，基本上您需要做的就是重写

Alphabets

类的equals和hashcode方法

public class Alphabets {
    String alp;

    public Alphabets(String alp) {
        this.alp = alp;
    }

    public String getAlp() {
        return alp;
    }

    // Override the equals method as you need it and contains will be able to use it.
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Alphabets) {
            Alphabets aObj = (Alphabets) obj;
            //
            return aObj.getAlp().equals(getAlp());

        } else {
            return false;
        }
    }

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

现在，您可以构建两个ArrayList的交集，只需像下面这样检查ArrayList的大小：

public static void main(String args[]){  
    ArrayList<Object> ar = new ArrayList<>();
    ArrayList<Object> br = new ArrayList<>();



    Alphabets a = new Alphabets("A");
    Alphabets b = new Alphabets("B");
    Alphabets b_clone = new Alphabets("B");

    ar.add(a);
    ar.add(b);

    br.add(b_clone);

    ArrayList<Object> ar2 = (ArrayList<Object>) ar.clone();

    ar2.retainAll(br);

    // Size 0 = no elements are equal
    // Size > 0 = equal elemts found
    System.out.println(ar2.size());

}

publicstaticvoidmain（字符串args[]）{
ArrayList ar=新的ArrayList（）；
ArrayList br=新的ArrayList（）；
字母a=新字母（“a”）；
字母b=新字母（“b”）；
字母b_克隆=新字母（“b”）；
ar.添加（a）；
ar.添加（b）；
br.添加（b_克隆）；
ArrayList ar2=（ArrayList）ar.clone（）；
ar2.保留（br）；
//大小0=没有相等的元素
//大小>0=找到相等的元素
System.out.println（ar2.size（））；
}

---

编辑：在侧节点上，不要使用rawtypes重写hashCode和equal方法

public class Alphabets {
    String alp;

    public Alphabets(String alp) {
    this.alp = alp;
    }

    public String getAlp() {
    return alp;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((alp == null) ? 0 : alp.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;
        Alphabets other = (Alphabets) obj;
        if (alp == null) {
            if (other.alp != null)
                return false;
        } else if (!alp.equals(other.alp))
            return false;
        return true;
    }
}

现在

公共类测试程序{
公共静态void main（字符串[]args）{
ArrayList ar=新的ArrayList（）；
ArrayList br=新的ArrayList（）；
字母a=新字母（“a”）；
字母b=新字母（“b”）；
字母b_克隆=新字母（“b”）；
ar.添加（a）；
ar.添加（b）；
br.添加（b_克隆）；
System.out.println（ar.contains（br.get（0））；//打印true
}
}

代码运行正常，我得到了想要的输出，但您能否解释一下hashcode和equals函数中到底发生了什么，因为我以前从未重写过这些方法。@JudeFernandes宁愿通读一遍。我想我应该尽量把它写得更好。简而言之，如果需要，equal方法是比较两个对象的标准方法（它通常在正常对象实现中检查这两个对象的哈希代码），如果覆盖它，则可以根据自己的行为比较两个对象。hascode方法之所以存在，是因为如果

A.equals（B）

，那么

A.getHashcode==B.Hashcode

在

equals

方法末尾的logicOr中，只需返回alp==null？other.alp==null:alp.equals（other.alp），甚至是@Andy:Good Point，但这只是eclipse自动生成的equals&hashCode。我只是想传达这个想法…-）

public class Alphabets {
    String alp;

    public Alphabets(String alp) {
    this.alp = alp;
    }

    public String getAlp() {
    return alp;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((alp == null) ? 0 : alp.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;
        Alphabets other = (Alphabets) obj;
        if (alp == null) {
            if (other.alp != null)
                return false;
        } else if (!alp.equals(other.alp))
            return false;
        return true;
    }
}

public class TestProgram {

    public static void main(String[] args){
        ArrayList<Object> ar = new ArrayList<>();
        ArrayList<Object> br = new ArrayList<>();

        Alphabets a = new Alphabets("A");
        Alphabets b = new Alphabets("B");
        Alphabets b_clone = new Alphabets("B");

        ar.add(a);
        ar.add(b);

        br.add(b_clone);

        System.out.println(ar.contains(br.get(0))); // Prints true
    }
}