我有一个列表作为其属性的对象,例如
public class A {
private String aName;
private List<B> bList;
}
public class B {
private String bName;
}
让我们假设我们有两个qazxsw poi列表:
A
考虑到这一点,我想知道比较这两个List<A> existingList = new ArrayList<A>();
// populate it with a list of A's which in turn, each has its own list of B's
List<A> newList = new ArrayList<A>();
// populate it with possibly some new A's and/or, an existing A which its property B has new items
列表的最快方法,并将这两个列表的delta添加到A
。
请注意,我们也在两个列表中比较existingList
的B
列表,所以如果有匹配的A
,但是他们的A
的delta,我们应该能够将它添加到B
的existingList
的A
。
同样,如果我们检测到某个项目已从bList
中删除,我们应该从newList
中删除它。
请注意,这不仅仅是比较两个对象,而是在对象图中深入查找delta并更新或添加新的和/或现有的部分。以下是示例示例:
existingList
第1步:为两个类实现package collection.delta.model;
import java.util.List;
import java.util.Objects;
import org.apache.commons.lang3.StringUtils;
package collection.delta.model;
import java.util.List;
import java.util.Objects;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
public class A {
private String aName;
private List<B> bList;
public String getaName() {
return aName;
}
public void setaName(String aName) {
this.aName = aName;
}
public List<B> getbList() {
return bList;
}
public void setbList(List<B> bList) {
this.bList = bList;
}
public A(String name, List<B> bList) {
this.aName = name;
this.bList = bList;
}
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o == this) {
return true;
}
if (!(o instanceof A)) {
return false;
}
A b = (A) o;
return StringUtils.isNotBlank(aName) && StringUtils.equalsAnyIgnoreCase(b.getaName(), aName)
&& CollectionUtils.disjunction(this.getbList(), b.getbList()).isEmpty();
}
@Override
public int hashCode() {
if (StringUtils.isBlank(aName)) {
return 31;
}
return Objects.hashCode(aName);
}
package collection.delta.model;
import java.util.Objects;
import org.apache.commons.lang3.StringUtils;
public class B {
private String bName;
public String getbName() {
return bName;
}
public void setbName(String bName) {
this.bName = bName;
}
public B(String name) {
this.bName = name;
}
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o == this) {
return true;
}
if (!(o instanceof B)) {
return false;
}
B b = (B) o;
return StringUtils.isNotBlank(bName) && StringUtils.equalsAnyIgnoreCase(b.getbName(), bName);
}
@Override
public int hashCode() {
if (StringUtils.isBlank(bName)) {
return 31;
}
return Objects.hashCode(bName);
}
}
package collection.delta;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import collection.delta.model.A;
import collection.delta.model.B;
public class App {
public static void main( String[] args ) {
List<A> originalA = new ArrayList<A>();
List<A> newA = new ArrayList<A>();
List<B> bListOriginalA1 = new ArrayList<B>();
bListOriginalA1.add(new B("originalA1_B1"));
bListOriginalA1.add(new B("originalA1_B2"));
bListOriginalA1.add(new B("originalA1_B3"));
bListOriginalA1.add(new B("originalA1_B4"));
A originalA1 = new A("originalA1", bListOriginalA1);
List<B> bListOriginalA2 = new ArrayList<B>();
bListOriginalA2.add(new B("originalA2_B1"));
bListOriginalA2.add(new B("originalA2_B2"));
bListOriginalA2.add(new B("originalA2_B3"));
bListOriginalA2.add(new B("originalA2_B4"));
A originalA2 = new A("originalA2", bListOriginalA2);
List<B> bListOriginalA3 = new ArrayList<B>();
bListOriginalA3.add(new B("originalA3_B1"));
bListOriginalA3.add(new B("originalA3_B2"));
bListOriginalA3.add(new B("originalA3_B3"));
bListOriginalA3.add(new B("originalA3_B4"));
A originalA3 = new A("originalA3", bListOriginalA3);
originalA.add(originalA1);
originalA.add(originalA2);
originalA.add(originalA3);
List<B> bListNewA1 = new ArrayList<B>();
bListNewA1.add(new B("originalA1_B1"));
bListNewA1.add(new B("originalA1_B2"));
bListNewA1.add(new B("originalA1_B3"));
bListNewA1.add(new B("originalA1_B4"));
A newA1 = new A("originalA1", bListNewA1);
List<B> bListNewA2 = new ArrayList<B>();
bListNewA2.add(new B("originalA2_B1"));
bListNewA2.add(new B("originalA2_B2"));
bListNewA2.add(new B("originalA2_B3"));
bListNewA2.add(new B("originalA2_B4"));
A newA2 = new A("originalA2", bListNewA2);
List<B> bListNewA3 = new ArrayList<B>();
bListNewA3.add(new B("originalA3_B1"));
bListNewA3.add(new B("originalA3_B2"));
bListNewA3.add(new B("originalA3_B5"));
bListNewA3.add(new B("originalA3_B4"));
A newA3 = new A("originalA3", bListNewA3);
List<B> bListNewA4 = new ArrayList<B>();
bListNewA4.add(new B("A4_B1"));
bListNewA4.add(new B("A4_B2"));
bListNewA4.add(new B("A4_B3"));
bListNewA4.add(new B("A4_B4"));
A newA4 = new A("originalA4", bListNewA4);
newA.add(newA1);
newA.add(newA2);
newA.add(newA3);
newA.add(newA4);
List<A> result = CollectionUtils.disjunction(originalA, newA).stream().collect(Collectors.toList());
for (A a : newA) {
for (A aResult : result) {
if (StringUtils.equalsAnyIgnoreCase(a.getaName(), aResult.getaName())) {
originalA.add(aResult);
}
}
}
System.out.println("");
}
}
和equals()
。
第2步:将列表转换为集合。
步骤3:使用hashCode
方法中的一个或多个Set
,addAll
和/或removeAll
来执行联合,交集和差异等集合操作。
如果您关心订单,那么只需使用equals方法:
retainAll
来自javadoc:
将指定对象与此列表进行比较以获得相等性。当且仅当指定的对象也是列表时,返回true,两个列表具有相同的大小,并且两个列表中的所有对应元素对都相等。 (如果(e1 == null?e2 == null:e1.equals(e2)),则两个元素e1和e2相等。)换句话说,如果两个列表包含相同顺序的相同元素,则它们被定义为相等。此定义确保equals方法在List接口的不同实现中正常工作。
如果要独立于顺序进行检查,可以将所有元素复制到集合,并在结果集合上使用等于:
list1.equals(list2);
这种方法的局限在于它不仅忽略了顺序,而且忽略了重复元素的频率。例如,如果list1是[“A”,“B”,“A”]并且list2是[“A”,“B”,“B”],则Set方法会认为它们是相等的。
如果您需要对顺序不敏感但对重复频率敏感,您可以:
在比较它们之前对两个列表(或副本)进行排序或将所有元素复制到Multiset。
这有效:
public static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
return new HashSet<>(list1).equals(new HashSet<>(list2));
}