1

我有一个由类对象组成的 ArrayList。该类有几个字符串字段。在某些类中，必须从 ArrayList 中删除一些相同的字段。

我需要检查的类中的字段是 sorted_pa​​rticipants，它在某些对象中设置为相同。

这是我的课：

public class Neo4jCompensation {
   private String number_of_participants;
   private String amount;
   private String sorted_participants;
   private String unsorted_participants;
   private String href_pdf_compensation;
   private String signed_by_all;

    public Neo4jCompensation() {
        this.number_of_participants = "";
        this.amount = "";
        this.sorted_participants = "";
        this.unsorted_participants = "";
        this.href_pdf_compensation = "";
        this.signed_by_all = "";
    }



    public String getNumber_of_participants() {
        return number_of_participants;
    }

    public void setNumber_of_participants(String number_of_participants) {
        this.number_of_participants = number_of_participants;
    }

    public String getAmount() {
        return amount;
    }

    public void setAmount(String amount) {
        this.amount = amount;
    }

    public String getSorted_participants() {
        return sorted_participants;
    }

    public void setSorted_participants(String sorted_participants) {
        this.sorted_participants = sorted_participants;
    }

    public String getUnsorted_participants() {
        return unsorted_participants;
    }

    public void setUnsorted_participants(String unsorted_participants) {
        this.unsorted_participants = unsorted_participants;
    }

    public String getHref_pdf_compensation() {
        return href_pdf_compensation;
    }

    public void setHref_pdf_compensation(String href_pdf_compensation) {
        this.href_pdf_compensation = href_pdf_compensation;
    }

    public String getSigned_by_all() {
        return signed_by_all;
    }

    public void setSigned_by_all(String signed_by_all) {
        this.signed_by_all = signed_by_all;
    }


}

所以我有一个充满类的第一个列表：

 ArrayList<Neo4jCompensation> results_list=new ArrayList<Neo4jCompensation>();

我认为找到重复项的非常好的方法是制作一个列表的副本，比较两者的相同类字段值并删除重复项。这就是我找到重复项的方式

 ArrayList<Neo4jCompensation> results_list1=new ArrayList<Neo4jCompensation>();

 for(Neo4jCompensation pp:results_list)
 {

 Neo4jCompensation ss=new Neo4jCompensation();
 ss.setAmount(pp.getAmount());
 ss.setHref_pdf_compensation(pp.getHref_pdf_compensation());
 ss.setNumber_of_participants(pp.getNumber_of_participants());
 ss.setSigned_by_all(pp.getSigned_by_all());
 ss.setSorted_participants(pp.getSorted_participants());
 ss.setUnsorted_participants(pp.getUnsorted_participants());
 results_list1.add(ss);
 }

for (int i = 0; i < results_list.size(); i++) {
                 Neo4jCompensation kk=new Neo4jCompensation();
                  kk=results_list.get(i);

                for (int j = 0; j < results_list1.size(); j++) {
                    Neo4jCompensation n2=new Neo4jCompensation();
                    n2=results_list1.get(j);
                    if(i!=j)
                    {
                        String prvi=kk.getSorted_participants().trim();
                        String drugi=n2.getSorted_participants().trim();
                    if(prvi.equals(drugi))
                    {

                      // results_list1.remove(j); 
                    out.println("<p> Are equal su  :"+i+" i "+j+"</p>");
                    }
                    }

                }

            }

因为我知道我不能同时循环并从 ArrayList 中删除元素，所以我尝试使用这样的迭代器......

int one=0;
int two=0;   

 Iterator<Neo4jCompensation> it = results_list.iterator();
 while (it.hasNext()) {
  Neo4jCompensation kk=it.next();

   Iterator<Neo4jCompensation> it1 = results_list1.iterator();
     while (it1.hasNext()) {

  Neo4jCompensation kk1=it1.next();
  String oo=kk.getSorted_participants().trim();
  String pp=kk1.getSorted_participants().trim();
  if(one<two && oo.equals(pp))
  {
  it1.remove();
  }
  two++;
  }
     one++;
 }

但它失败了，并且在 ArrayList results_list1 中没有返回任何内容 - 在使用迭代器删除之前，它具有正确的元素。如何从数组列表中删除与 ArrayList 中的某些其他对象具有相同字段值的对象。

4

3 回答 3

0

为什么不使用.removeAll()

results_list1.removeAll(resultList);

这将要求您实施equals并hashcode在Neo4jCompensation

public class Neo4jCompensation {

       //Omitted Code

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


}
于 2013-05-24T00:39:54.407 回答
0

另一种方法可能是：

覆盖 Neo4jCompensation 中的 equals 方法并检查 sorted_pa​​rticipants 并相应地返回。然后使用 Set 作为对象的集合。Set 不允许重复，它使用 equals 来确定相等性。

于 2013-05-24T00:43:35.573 回答
0 
for (int i = 0; i < results_list.size(); i++) {
   Neo4jCompensation kk=new Neo4jCompensation();
   kk=results_list.get(i);
   for (int j = 0; j < results_list1.size(); j++) {
       Neo4jCompensation n2=new Neo4jCompensation();
       n2=results_list1.get(j);
       if(results_list1.contains(kk) { results_list1.remove(j); }
}

但是您可能希望使用Set而不是List或维护顺序的数据结构，例如SortedMap，并带有标记值。

于 2013-05-24T00:44:20.107 回答