Java 在列表中查找唯一的条目<；对象[]>；

相反，我得到：

{1,abc,21/1/2001},{2,acc,21/1/2001}

---

如何在本例中找到唯一的条目？

Java中的数组没有平等的概念，因此无法实现这一点。您需要定义一个带有数字、字符串和日期的自定义类，并自己实现equals/hashCode以允许此操作。

最简单的方法是使用

集。我强烈建议创建一个类来捕获int、string和date对象

{1,abc,21/1/2001},{1,abc,(21/1/2001},{2,acc,21/1/2001}

然后您可以重写方法
equals
和
hashCode
，以从集合中获得预期的行为
我会将对象数组中的所有数据封装到POJO中。

在POJO中，您可以定义自己的equals方法。e、 g

public class Foo {
    private int num;
    private String letters;
    private Date date;
}

Java中的数组不重写
hashCode（）
和
equals（）
，因此比较具有相同内容（具有相同长度和相等元素）的两个数组会意外地产生false

如果您使用
列表
，它应该可以正常工作。您可以利用
Arrays.asList（）
实用程序。
您可以使用使用自定义
比较器初始化的
TreeSet
进行所需检查；对于数组和默认比较器，这是不可能的。
您可以在
对象[]
周围实现一个薄包装器，它将提供适当的
hashCode（）
和
equals（）
。这两种方法很容易在和方面实现：

公共类Cmp{
公共静态类ObjArray{
私有最终对象[]arr；
公共对象数组（对象[]arr）{
this.arr=arr；
}
@凌驾
公共int hashCode（）{
返回数组.deepHashCode（arr）；
}
@凌驾
公共布尔等于（对象obj）{
if（this==obj）
返回true；
if（obj==null）
返回false；
如果（getClass（）！=obj.getClass（））
返回false；
ObjArray other=（ObjArray）obj；
返回数组.deepEquals（arr，other.arr）；
}
}
公共静态void main（字符串参数[]）{
List listObj=new ArrayList（）；
listObj.add（新对象[]{1，“abc”，新日期（2001年1月21日）}）；
listObj.add（新对象[]{1，“abc”，新日期（2001年1月21日）}）；
listObj.add（新对象[]{2，“acc”，新日期（2001年1月21日）}）；
Set unique=新的HashSet（）；
unique.addAll（listObj）；
System.out.println（唯一）；
}
}
HashSet与
Comparable
无关。它只使用
hashCode
和
equals
。但是，您也可以使用
映射
并使用
对象[].toString（）
作为键。我相信这会起作用，因为数组的
toString
包含了数组的所有元素（在某一点上）。这是一个“难闻”的解决方案，同样，“正确”的解决方案就是上面提到的那个。
public class Foo {
    private int num;
    private String letters;
    private Date date;
}

public class Bean {
    private int i;
    private String l;
    private Date d;
    public int getI() {
        return i;
    }
    public void setI(int i) {
        this.i = i;
    }
    public String getL() {
        return l;
    }
    public void setL(String l) {
        this.l = l;
    }
    public Date getD() {
        return d;
    }
    public void setD(Date d) {
        this.d = d;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((d == null) ? 0 : d.hashCode());
        result = prime * result + i;
        result = prime * result + ((l == null) ? 0 : l.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Bean))
            return false;
        Bean other = (Bean) obj;
        if (d == null) {
            if (other.d != null)
                return false;
        } else if (!d.equals(other.d))
            return false;
        if (i != other.i)
            return false;
        if (l == null) {
            if (other.l != null)
                return false;
        } else if (!l.equals(other.l))
            return false;
        return true;
    }
}

public class Cmp {

    public static class ObjArray {
        private final Object[] arr;
        public ObjArray(Object[] arr) {
            this.arr = arr;
        }
        @Override
        public int hashCode() {
            return Arrays.deepHashCode(arr);
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            ObjArray other = (ObjArray)obj;
            return Arrays.deepEquals(arr, other.arr);
        }
    }

    public static void main(String args[]) {
        List<ObjArray> listObj = new ArrayList<ObjArray>();
        listObj.add(new ObjArray(new Object[]{1,"abc",new Date(21/1/2001)}));
        listObj.add(new ObjArray(new Object[]{1,"abc",new Date(21/1/2001)}));
        listObj.add(new ObjArray(new Object[]{2,"acc",new Date(21/1/2001)}));
        Set<ObjArray> unique = new HashSet<ObjArray>();
        unique.addAll(listObj);
        System.out.println(unique);
    }


}