Java HashSet等于，hashCode被覆盖，styl有重复项

}

==========================================================================================

 public class DateObj extends Date implements Serializable {

    private static final long serialVersionUID = 1L;

    private String id;
    private String fName;
    private String sName;
    private String days;
    private String country;
    private boolean fitIn;


    public DateObj(String id,String fName, String sName, String country, String days) {
        this.id = id;
        this.fName = fName;
        this.sName = sName;
        this.days = days;
        this.country = country;

    }

    @Override
    public boolean equals(Object obj) {

        DateObj dateObj = (DateObj) obj;
        System.out.println("method Call");


        return getfName().equals(dateObj.getfName());
    }

    public String getfName() {
        return fName;
    }

    public void setfName(String fName) {
        this.fName = fName;
    }

    public String getsName() {
        return sName;
    }

    public void setsName(String sName) {
        this.sName = sName;
    }

    public String getDays() {
        return days;
    }

    public void setDays(String days) {
        this.days = days;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String toString(){
        return fName;
    }

@Override
public int hashCode() {
    return fName.hashCode();
}

导入java.io.BufferedReader；
导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.Comparator；
导入java.util.TreeSet；
公共类数据存储{
私有ArrayList listData=新ArrayList（）；
文件=新文件（“data3.csv”）；
公共静态void main（字符串[]args）{
DataSaveTo dataExperiment=新的DataSaveTo（）；
dataExperiment.go（）；
}
公开作废go（）{
loadData（）；
树集数据=新树集（）；
data.addAll（listData）；
//ObjComparInt comparId=新的ObjComparInt（）；
//ObjectComparable=新的ObjectComparable（）；
//Collections.sort（listData，comparId）；
saveData（）；
//System.out.println（列表数据）；
}
公共void saveData（）{
试一试{
File File=新文件（“dataNoDupl.csv”）；
BufferedWriter bw=新的BufferedWriter（新文件编写器（文件））；
对于（DateObj对象：listData）{
write（obj.getId（）+”；“+obj.getfName（）+”；“+obj.getsName（）+”；“+obj.getCountry（）+”；“+obj.getDays（）+”\n”）；
}
bw.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
System.out.println（“保存数据方法中的异常：”+e）；
}
}
公共void loadData（）{
文件阅读器fr；
试一试{
fr=新文件读取器（文件）；
字符串s=null；
字符串[]标记；
BufferedReader br=新的BufferedReader（fr）；
而（（s=br.readLine（））！=null）{
代币=s.split（“，”）；
createDateObj（代币）；
}
br.close（）；
}catch（filenotfounde异常）{
System.out.println（“LoadData方法中的异常”+e）；
}捕获（IOE异常）{
System.out.println（“LoadData方法第二次捕获中的异常”+e）；
e、 printStackTrace（）；
}
}
私有void createDateObj（字符串[]标记）{
DateObj obj=新的DateObj（令牌[4]，令牌[0]，令牌[2]，令牌[3]，令牌[1]）；
listData.add（obj）；
System.out.println（obj.hashCode（）+“--”+obj.getfName（）+“--”+obj.getsName（））；
}
//名称比较器
公共类ObjectComparator{
@凌驾
公共整数比较（DateObj obj，DateObj obj1）{
返回obj.getfName（）.compareTo（obj1.getfName（））；
}
}
//ID比较器
公共类ObjComparInt实现了Comparator{
@凌驾
公共整数比较（DateObj ob，DateObj ob1）{
返回Integer.parseInt（ob.getId（））-Integer.parseInt（ob1.getId（））；
}
}
}

我希望HashSet调用equal方法，因为重写了hashCode。在equals比较之后，我想删除我要传递到hashSet的集合中的重复项

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

public class DataSaveTo {

    private ArrayList<DateObj> listData = new ArrayList<DateObj>();
    File file = new File("data3.csv");
    public static void main(String[] args) {


        DataSaveTo dataExperiment = new DataSaveTo();
        dataExperiment.go();


    }

    public void go() {



        loadData();

        TreeSet<DateObj> data = new TreeSet<DateObj>();
        data.addAll(listData);
    //  ObjComparInt comparId = new ObjComparInt();
    //  ObjectComparable comparObj = new ObjectComparable();
    //  Collections.sort(listData, comparId);
        saveData();
    //  System.out.println(listData);


    }



    public void saveData() {

        try {
            File file = new File("dataNoDupl.csv");
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            for(DateObj obj : listData){
                bw.write(obj.getId()+";"+obj.getfName()+";"+obj.getsName()+";"+obj.getCountry()+";"+obj.getDays()+"\n ");
            }
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("Exception in save Data method:  "+ e);

        }

    }

    public  void loadData() {
        FileReader fr;
        try {
            fr = new FileReader(file);
            String s = null;
            String[] tokens;
            BufferedReader br = new BufferedReader(fr);
            while((s=br.readLine())!=null){
                tokens = s.split(",");
                createDateObj(tokens);
            }
            br.close();
        } catch (FileNotFoundException e) {
            System.out.println("Exception in LoadData method"+e);
        } catch (IOException e) {
            System.out.println("Exception in LoadData method 2nd catch"+e);
            e.printStackTrace();
        }


    }



    private void createDateObj(String[] tokens) {

        DateObj obj = new DateObj(tokens[4],tokens[0],tokens[2],tokens[3],tokens[1]);
        listData.add(obj);
        System.out.println(obj.hashCode()+"--"+obj.getfName()+"--"+obj.getsName());

    }



    //  Name comparator
    public class ObjectComparable implements Comparator<DateObj>{
        @Override
        public int compare(DateObj obj, DateObj obj1) {
            return obj.getfName().compareTo(obj1.getfName());

        }
    }

        // ID comparator
    public class ObjComparInt implements Comparator<DateObj>{
        @Override   
        public int compare(DateObj ob, DateObj ob1){
            return Integer.parseInt(ob.getId()) - Integer.parseInt(ob1.getId());
            }
        }


    }

HashSet data=newhashset（）；
data.addAll（listData）；

---

在控制台中，它将我打印为true（因为equals方法中的sys.out），但它不做任何事情。我仍然有重复项。

具有相同的

fName

不会得到相同的哈希值。当您在生成哈希代码时考虑<代码> sNeX/Cuth>。 将对象放入

哈希集中时，会生成哈希代码，哈希代码实现会根据
fName
和
sName
生成哈希代码。另一方面，您正在使用相同的方法仅匹配
fName
，并获得
true
打印

首先定义当你要考虑你的对象相同的时候。使用这些标准在<>代码>等值方法中进行匹配，也可以在 Hash码方法中考虑它们。strong>因为如果两个对象相等，则它们的哈希代码必须相等
 hashCode（）的Java声明：

如果根据equals（Object）方法，两个对象相等，则
对两个对象中的每一个调用hashCode方法都必须产生
相同的整数结果

您的实现违反了此规则，您需要更改的实现或实现它

您可能需要更新
equals（）
：

equals方法只使用fName字段，而hashCode同时使用fName和sName。您的equals方法是否也应该被重写以比较fName和sName？请阅读hashcode和equals之间的“契约”。它们必须相等！！您还可以尝试在IDE中重新生成hashCode和equals，然后继续。编辑您的问题，并添加一些遇到问题的示例（以及更新的代码）。此外，请避免缩写-meth！=方法。你能更准确地解释一下你期望的结果吗？是的，不是期望的吗？正如你在EQULS方法中所说的，考虑相同的<代码> fNeN>代码>的对象！user1984327无论您计划了什么样的技巧，您的hashcode实现都是错误的。如果根据equals方法有两个相等的对象，则这些对象的hashcode方法必须相同，否则hashcode实现将被破坏。如果你有例如“Bob Smith”和“Bob Johnson”，它们是相等的，但是在你的例子中有不同的哈希代码，这是错误的。好吧，恐怕，在这种情况下，你必须编写自己的
哈希集
实现！好的，对不起，请告诉我我应该更改什么代码。我找不到为什么我会有重复的实现不需要有意义，它可以始终依赖于规范。实际上，快速查看一下就会发现
HashSet
s使用
HashMap
将其元素作为键持久化
HashSet<DateObj> data = new HashSet<DateObj>();
    data.addAll(listData);

@Override
public boolean equals(Object obj){
    if (obj == null || !(obj instanceof DateObj)) {
        return false;
    }
    DateObj dateObj = (DateObj) obj;
    return getfName().equals(dateObj.getfName()) && getsName().equals(dateObj.getsName());
}