Как сравнить две коллекции для "эквивалентности" на основе полей из разных классов Java?

другим возможным решением является написание простого метода сравнения с предикатом (поэтому вы можете явно указать условие, чтобы два класса были похожи на ваши термины). Я создал это в Java 8:

<T, U> boolean compareCollections(Collection<T> coll1, Collection<U> coll2, BiPredicate<T, U> predicate) {

    return coll1.size() == coll2.size()
            && coll1.stream().allMatch(
            coll1Item -> coll2.stream().anyMatch(col2Item -> predicate.test(coll1Item, col2Item))
    );
}

Как вы можете видеть, он сравнивает размер, а затем проверяет, имеет ли каждый элемент в коллекции аналог во второй коллекции (это не сравнение порядка). Он находится в Java 8, но вы можете перенести его на Java 7, реализовав простой Двухпредикатный код, allMatch и anyMatch (одного for-loop для каждого из них должно быть достаточно)

Edit: Java 7 код:

<T, U> boolean compareCollections(Collection<T> coll1, Collection<U> coll2, BiPredicate<T, U> predicate) {

        if (coll1.size() != coll2.size()) {
            return false;
        }

        for (T item1 : coll1) {
            boolean matched = false;
            for (U item2 : coll2) {
                if (predicate.test(item1, item2)) {
                    matched = true;
                }
            }

            if (!matched) {
                return false;
            }
        }
        return true;

    }}
interface BiPredicate <T, U> {
    boolean test(T t, U u);
}

здесь пример использования.

нет очень простого способа.

наиболее общим, который будет работать с обычными коллекциями Java, будет создание класса-оболочки, который будет принимать либо ClassA или ClassB в качестве ввода, а затем переопределить equals / hashcode, как определено вами.

в некоторых случаях вы можете злоупотреблять Comparator, но это ограничило бы вас TreeMap/TreeSet. Вы также можете реализовать equals() метод работы так, что classA.equals(classB); возвращает true, но это может вызвать сложные ошибки, если вы не будете осторожны. Он может также привести к интересным ситуациям, где a.equals(b) и b.equals(c) но !a.equals(c).

некоторая библиотека (гуава?) также имел Comparator механизм стиля для тестирования равенства, но это будет работать только с коллекциями библиотеки.

Apache Commons Lang имеет EqualsBuilder#reflectionEquals(Object, Object):

этот метод использует отражение, чтобы определить, если два Objects равны.

Он использует AccessibleObject.setAccessible чтобы получить доступ к частной поля. Это означает, что при запуске будет выдано исключение безопасности в диспетчере безопасности, если разрешения настроены неправильно. Это также не так эффективно, как явное тестирование. Непримитивный поля сравниваются с помощью equals().

переходные члены не будут проверены, поскольку они, вероятно, получены поля, а не часть значения Object.

статические поля не будут проверены. Будут включены поля суперкласса.

таким образом, это должно охватывать ваш случай использования. Очевидный отказ от ответственности: он использует отражение;)

EDIT: это, конечно, предполагает, что поля имеют одинаковые имена, а не типы. В последнем случае можно проверить исходный код и настройка это для их использования.

комбинация двух существующих ответов: общая версия класса-оболочки, предложенная Kayaman (просто список). Использование класса ArrayList::равно как предикат для Пшемек подход Gumula.

я добавил СТРОИТЕЛЬ, чтобы сделать его немного приятнее использовать:

    StructureEqual<ClassA, ClassB> struct = StructureEqual.<ClassA, ClassB>builder()
            .field(ClassA::getIntA, ClassB::getIntB) // Declare what fields should be checked
            .field(ClassA::getStrA, ClassB::getStrB)
            .build();

    System.out.println(struct.isEqual(myList, mySet));

код:

public class StructureEqual<A, B> {
    private List<EqualPoint<A, B>> points;

    public StructureEqual(List<EqualPoint<A, B>> points) {
        this.points = points;
    }

    private List<Object> sampleA(A a) {
        return points.stream().map(p -> p.getAPoint().apply(a)).collect(Collectors.toList());
    }

    private List<Object> sampleB(B b) {
        return points.stream().map(p -> p.getBPoint().apply(b)).collect(Collectors.toList());
    }

    public boolean isEqual(Collection<A> as, Collection<B> bs) {
        Set<List<Object>> aSamples = as.stream().map(this::sampleA).collect(Collectors.toSet());
        Set<List<Object>> bSamples = bs.stream().map(this::sampleB).collect(Collectors.toSet());
        return aSamples.equals(bSamples);
    }

    private static class EqualPoint<PA, PB> {

        private final Function<PA, ?> aPoint;
        private final Function<PB, ?> bPoint;

        public <T> EqualPoint(Function<PA, T> aPoint, Function<PB, T> bPoint) {
            this.aPoint = aPoint;
            this.bPoint = bPoint;
        }

        Function<PA, ?> getAPoint() {
            return aPoint;
        }

        Function<PB, ?> getBPoint() {
            return bPoint;
        }
    }

    public static <BA, BB> Builder<BA, BB> builder() {
        return new Builder<>();
    }

    public static class Builder<BA, BB> {
        private List<EqualPoint<BA, BB>> points = new ArrayList<>();

        public <T> Builder<BA, BB> field(Function<BA, T> a, Function<BB, T> b) {
            points.add(new EqualPoint<>(a, b));
            return this;
        }

        public StructureEqual<BA, BB> build() {
            return new StructureEqual<>(Collections.unmodifiableList(points));
        }
    }

}

каков самый простой способ сказать, являются ли эти два Collections равны ли в терминах указанного подмножества полей?

основываясь на вашем описании, ваши требования равенства:

• коллекции имеют равные размеры.
• для каждого item1 на collection1 существует item2 на collection2 такое, что item1.field_x равна item2.field_y, для нескольких определенных field_x-field_y пар.

если мы можем предположить, что в любой коллекции нет повторяющихся элементов, то есть, тогда это "самый простой способ" может быть что-то вроде этого:

    public boolean areEqual(Collection<ClassA> c1, Collection<ClassB> c2) {
        if (c1.size() != c2.size()) {
            return false;
        }
        OUTER:
        for (ClassA a : c1) {
            for (ClassB b : c2) {
                if (a.getIntA() == b.getIntB() && Objects.equals(a.getStringA(), b.getStringB())) {
                    continue OUTER;
                }
            }
            return false;
        }
        return true;
    }

это простая реализация требований. Но поскольку он может сравнивать каждый элемент с каждым другим элементом в другой коллекции, он имеет очень плохую производительность, O(n^2) здесь n - размер коллекции.

это также может не работать, если равные элементы могут появляться несколько раз в коллекция:

    List<ClassA> list = new ArrayList<>(Arrays.asList(
        new ClassA(1, "A", true),
        new ClassA(1, "A", false),
        new ClassA(2, "B", true)
    ));
    Set<ClassB> set = new HashSet<>(Arrays.asList(
        new ClassB(1, "A", false),
        new ClassB(2, "B", false),
        new ClassB(2, "B", true)
    ));

здесь ClassA(1, "A", true) и ClassA(1, "A", false) считаются эквивалентными в первом списке, и new ClassB(2, "B", false) и new ClassB(2, "B", true) считаются эквивалентными во втором списке. Вышеприведенный алгоритм найдет эти две коллекции равными, что неверно.

можно обрабатывать случай дубликатов, и в то же время улучшать временную сложность за счет использования дополнительного пространства:

• выполните итерацию над первой коллекцией для построения карты графы (int, String) ОК
• итерация по второй коллекции при проверке карты подсчетов:
  • если количество карт не содержит соответствующего (int, String) кортежа, return false, а это означает, что элемент не имеет пары
  • если соответствующий кортеж существует, уменьшите его количество
  • если количество достигает 0, из кортежа с карты
• если достигнут конец цикла, то должно означать, что все элементы были сопоставлены (карта должна быть пустой), поэтому вы можете просто return true.

реализация:

class FieldExtractingEqual {

    public boolean areEqual(Collection<ClassA> c1, Collection<ClassB> c2) {
        if (c1.size() != c2.size()) {
            return false;
        }

        Map<Tuple, Integer> counts = new HashMap<>();
        for (ClassA a : c1) {
            Tuple tuple = new Tuple(a.getIntA(), a.getStringA());
            Integer count = counts.get(tuple);
            if (count == null) {
                count = 0;
            }
            counts.put(tuple, count + 1);
        }

        for (ClassB b : c2) {
            Tuple tuple = new Tuple(b.getIntB(), b.getStringB());
            Integer count = counts.get(tuple);
            if (count == null) {
                return false;
            }
            if (count == 1) {
                counts.remove(tuple);
            } else {
                counts.put(tuple, count - 1);
            }
        }

        return true;
    }

    private static class Tuple {
        private final Object[] values;

        public Tuple(Object... values) {
            this.values = values;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Tuple tuple = (Tuple) o;

            return Arrays.equals(values, tuple.values);
        }

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

некоторые тесты assertj для проверки реализации:

List<ClassA> myList = new ArrayList<>(Arrays.asList(
    new ClassA(1, "A", true),
    new ClassA(1, "A", true),
    new ClassA(2, "B", true)
));
Set<ClassB> mySet = new HashSet<>(Arrays.asList(
    new ClassB(1, "A", false),
    new ClassB(1, "A", true),
    new ClassB(2, "B", false)
));

FieldExtractingEqual comp = new FieldExtractingEqual();
assertThat(comp.areEqual(myList, mySet)).isTrue();

myList.add(new ClassA(3, "X", true));
mySet.add(new ClassB(3, "Y", true));
assertThat(comp.areEqual(myList, mySet)).isFalse();

как дальнейшее улучшение, можно сделать реализацию FieldExtractingEqual generic, так что это может занять произвольное Collection<A> и Collection<B> параметры, и пары соковыжималки для создания кортежей из A и B. Вот один из способов реализовать это:

interface FieldExtractor<T, V> {
    V apply(T arg);
}

class GenericFieldExtractingEqual<T, U> {
    private final List<FieldExtractor<T, ?>> extractors1;
    private final List<FieldExtractor<U, ?>> extractors2;

    private GenericFieldExtractingEqual(List<FieldExtractor<T, ?>> extractors1, List<FieldExtractor<U, ?>> extractors2) {
        this.extractors1 = extractors1;
        this.extractors2 = extractors2;
    }

    public boolean areEqual(Collection<T> c1, Collection<U> c2) {
        if (c1.size() != c2.size()) {
            return false;
        }

        Map<Tuple, Integer> counts = new HashMap<>();
        for (T a : c1) {
            Tuple tuple = newTuple1(a);
            Integer count = counts.get(tuple);
            if (count == null) {
                count = 0;
            }
            counts.put(tuple, count + 1);
        }

        for (U b : c2) {
            Tuple tuple = newTuple2(b);
            Integer count = counts.get(tuple);
            if (count == null) {
                return false;
            }
            if (count == 1) {
                counts.remove(tuple);
            } else {
                counts.put(tuple, count - 1);
            }
        }

        return true;
    }

    private Tuple newTuple1(T a) {
        return new Tuple(extractors1.stream().map(x -> x.apply(a)).toArray());
    }

    private Tuple newTuple2(U b) {
        return new Tuple(extractors2.stream().map(x -> x.apply(b)).toArray());
    }

    private static class Tuple {
        private final Object[] values;

        public Tuple(Object... values) {
            this.values = values;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Tuple tuple = (Tuple) o;

            return Arrays.equals(values, tuple.values);
        }

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

    public static class Builder<T, U> {
        List<FieldExtractor<T, ?>> extractors1 = new ArrayList<>();
        List<FieldExtractor<U, ?>> extractors2 = new ArrayList<>();

        <V> Builder<T, U> addExtractors(FieldExtractor<T, V> extractor1, FieldExtractor<U, V> extractor2) {
            extractors1.add(extractor1);
            extractors2.add(extractor2);
            return this;
        }

        GenericFieldExtractingEqual<T, U> build() {
            return new GenericFieldExtractingEqual<>(new ArrayList<>(extractors1), new ArrayList<>(extractors2));
        }
    }
}

пример использования и некоторые тесты assertj:

GenericFieldExtractingEqual<ClassA, ClassB> comp2 = new GenericFieldExtractingEqual.Builder<ClassA, ClassB>()
    .addExtractors(ClassA::getIntA, ClassB::getIntB)
    .addExtractors(ClassA::getStringA, ClassB::getStringB)
    .build();
assertThat(comp2.areEqual(myList, mySet)).isTrue();

myList.add(new ClassA(3, "X", true));
mySet.add(new ClassB(3, "Y", true));
assertThat(comp2.areEqual(myList, mySet)).isFalse();

то есть, вы строите GenericFieldExtractingEqual экземпляр из пар экстракторов, например:

    .addExtractors(ClassA::getIntA, ClassB::getIntB)

первый параметр-это объект, который извлекает поле в первый класс, и второй параметр-это объект, который извлекает соответствующее поле во втором классе. Вы добавляете столько пар экстрактора, сколько хотите сравнить для равенства состояние.

хотя я использовал стиль написания Java8 ClassA::getIntA для компактности, легко (но долго) конвертировать в FieldExtractor реализация:

    .addExtractors(
        new FieldExtractor<ClassA, Integer>() {
            @Override
            public Integer apply(ClassA arg) {
                return arg.getIntA();
            }
        },
        new FieldExtractor<ClassB, Integer>() {
            @Override
            public Integer apply(ClassB arg) {
                return arg.getIntB();
            }
        }
    )

то же самое newTuple* служебные методы.

вот запускаемая версия на RexTester.

вот мой ответ:

 public class StackOverFlow {

static class Testy {

    int id;
    String name;

    public Testy(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public int hashCode() {
        int hash = 3;
        hash = 89 * hash + this.id;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Testy other = (Testy) obj;
        if (this.id != other.id || !this.name.equals(other.name)) {
            return false;
        }
        return true;
    }

}

static class AnotherTesty {

    int id;
    String name;

    public AnotherTesty(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 41 * hash + this.id;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final AnotherTesty other = (AnotherTesty) obj;
        if (this.id != other.id || !this.name.equals(other.name)) {
            return false;
        }
        return true;
    }

}

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {

    List<Object> list = Arrays.asList(new Testy(5, "test"), new AnotherTesty(5, "test"));
    Set<Object> set = new HashSet<>(Arrays.asList(new Testy(5, "test"), new AnotherTesty(5, "test")));

    System.out.println(compareCollections(list, set, Testy.class, AnotherTesty.class));
}

private static boolean compareCollections(Collection<?> c1, Collection<?> c2, Class cls, Class cls2) {

    List<Object> listOfCls = c1.stream().filter(p -> cls.isInstance(p)).map(o -> cls.cast(o)).collect(Collectors.toList());
    List<Object> listOfCls2 = c1.stream().filter(p -> cls2.isInstance(p)).map(o -> cls2.cast(o)).collect(Collectors.toList());

    List<Object> list2OfCls = c2.stream().filter(p -> cls.isInstance(p)).map(o -> cls.cast(o)).collect(Collectors.toList());
    List<Object> list2OfCls2 = c2.stream().filter(p -> cls2.isInstance(p)).map(o -> cls2.cast(o)).collect(Collectors.toList());

    if (listOfCls.size() != list2OfCls.size()||listOfCls2.size() != list2OfCls2.size()) {
        return false;
    }

    boolean clsFlag = true, cls2Flag = true;
    for (int i = 0; i < listOfCls.size(); i++) {

        if (!listOfCls.get(i).equals(list2OfCls.get(i))) {
            clsFlag = false;
            break;
        }
    }
    for (int i = 0; i < list2OfCls2.size(); i++) {
        if (!listOfCls2.get(i).equals(list2OfCls2.get(i))) {
            cls2Flag = false;
            break;
        }
    }

    return clsFlag && cls2Flag;
}

}

быстрый прототип:

package stackoverflow;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiFunction;

import org.junit.Test;

public class CompareTwoList {
    static class ClassA {
        int intA;
        String strA;
        boolean boolA;

        // Constructor
        public ClassA(int intA, String strA, boolean boolA) {
            this.intA = intA;
            this.strA = strA;
            this.boolA = boolA;
        } // Getters and setters etc. below...


    }

    static class ClassB {
        int intB;
        String strB;
        boolean boolB;

        // Constructor
        public ClassB(int intB, String strB, boolean boolB) {
            this.intB = intB;
            this.strB = strB;
            this.boolB = boolB;
        } // Getters and setters etc. below...

    }

    @FunctionalInterface
    private interface IncopatibeEqualsOperator<A, B> extends BiFunction<A, B, Boolean> {
    }

    @Test
    public void CompareListOfClassAAndclassBObjects() throws Exception {
        List<ClassA> myList = Arrays.asList(
                new ClassA(1, "A", true),
                new ClassA(2, "B", true));

        Set<ClassB> mySet = new HashSet<ClassB>(Arrays.asList(
                new ClassB(1, "A", false),
                new ClassB(2, "B", false)));

        // can be extract to separate file
        IncopatibeEqualsOperator<ClassA, ClassB> equalsOperatorFlavor1 = (ClassA o1, ClassB o2) -> {
            // custom logic here
            return o1.intA == o2.intB &&
                    java.util.Objects.equals(o1.strA, o2.strB);
        };

        boolean areEquals = areEquals(myList, mySet, equalsOperatorFlavor1);

        assertThat(areEquals, is(true));
    }

    // Add in utility class
    private <A, B> boolean areEquals(Collection<A> o1, Collection<B> o2, IncopatibeEqualsOperator<A, B> comparator) {
        if (o1.size() == o2.size()) { // if size different; they are not equals
            for (A obj1 : o1) {
                boolean found = false; // search item of o1 into o2; algorithm
                                       // can be improve
                for (B obj2 : o2) {
                    if (comparator.apply(obj1, obj2)) { // call custom code of
                                                        // comparision
                        found = true;
                        break;
                    }
                }

                if (!found) {// if current element of o1 is not equals with any
                             // one return false
                    return false;
                }
            }
            return true;// all are matched
        }
        return false;
    }
}

убедитесь, что классы A и B имеют методы toString ().

ClassA

public class ClassA {
    private int intA;
    private String strA;
    private boolean boolA;
    // Constructor
    public ClassA (int intA, String strA, boolean boolA) {
        this.intA = intA; this.strA = strA; this.boolA = boolA;
    } //

    @Override
    public String toString()
    {
        return intA + " " + strA + " " + boolA;
    }
}

ClassB

public class ClassB {
    private int intB;
    private String strB;
    private boolean boolB;
    // Constructor
    public ClassB (int intB, String strB, boolean boolB) {
        this.intB = intB; this.strB = strB; this.boolB = boolB;
    } // Gett

    @Override
    public String toString()
    {
        return intB + " " + strB + " " + boolB;
    }
}

Main / Test

public class JavaApplication11 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        List<Object> myList = Arrays.asList(new ClassA(1, "A", true),
                                            new ClassA(2, "B", true));
        Set<Object> mySet = new HashSet<Object>(
                      Arrays.asList(new ClassB(1, "A", false),
                                    new ClassB(2, "B", false)));
        System.out.println("is equal: " + isEqual(myList, mySet));
    }

    static boolean isEqual(Object list, Object set)
    {
        System.out.println(list.toString());
        System.out.println(set.toString());
        String tempStringA = list.toString();
        tempStringA = tempStringA.replaceAll("true", "");
        tempStringA = tempStringA.replaceAll("false", "");

        String tempStringB = set.toString();
        tempStringB = tempStringB.replaceAll("true", "");
        tempStringB = tempStringB.replaceAll("false", "");


        return tempStringA.equals(tempStringB);
    }

}

вы должны взять основную идею EqualsBuilder но изменено для ваших нужд: создайте какой-то список с членами (или лучшими геттерами) для сравнения, например. хеш-карта. Теперь повторите эту карту, найдите функции в классе A с ключевой записью карты. Затем выполните поиск функции класса B с записью Значения карты. Вызывать (вызвать) и сравните результат.

HashMap<String,String> mymap=new HashMap<>();
mymap.put("intA","intB");
mymap.put("boolA","boolB");

for(Map.Entry<String,String> e:mymap.entrySet()) { 
  // names not ok, maybe take a bean helper class
  Method m1=a.getClass().getMethod("get"+e.getKey()); // or look for fields if you dont have getters
  Method m2=b.getClass().getMethod("get"+e.getValue());
  Object r1=m1.invoke(a);
  Object r2=m2.invoke(b);
  if (!r1.equals(r2)) 
     return false;
}

извините за отсутствие реального кода. Проверки Null должны быть добавлены!

        public class Compare {

    public static void main(String[] args) {

        // TODO Auto-generated method stub
        Compare compare= new Compare();
        List<ClassA> myList = Arrays.asList(new ClassA(1, "A", false), new ClassA(2, "B", false));
        Set<ClassB> mySet = new HashSet<ClassB>(Arrays.asList(new ClassB(1, "A", false), new ClassB(2, "B", false)));

       System.out.println( compare.areEqual(myList,mySet));

    }
    public  boolean areEqual(Collection<ClassA> colA,Collection<ClassB> colB){
        boolean equal =false;
        if(colA.size()!=colB.size()){
            return equal;
        }
        Set<Integer> setA=new HashSet<Integer>();
        Set<Integer> setB= new HashSet<Integer>();
        for(ClassA obj : colA){
            setA.add(obj.hashCode());
        }
        for(ClassB obj : colB){
            setB.add(obj.hashCode());
        }
        if(setA.equals(setB)){
            equal=true;
        }
        return equal;
    }
}

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



    private String strA;
    private boolean boolA;

    // Constructor
    public ClassA(int intA, String strA, boolean boolA) {
        this.intA = intA;
        this.strA = strA;
        this.boolA = boolA;
    } // Getters and setters etc. below...


}

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



    private int intB;
    private String strB;
    private boolean boolB;

    // Constructor
       public ClassB(int intB, String strB, boolean boolB) {
        this.intB = intB;
        this.strB = strB;
        this.boolB = boolB;
    } // Getters and setters etc. below...
}

Ну, я переопределяю метод хэш-кода обоих классов для создания хэш-кода на основе int и str и метод для создания наборов Интергеров, целое число является хэш-кодом каждого класса, если вы не хотите, чтобы даже хэш-код был переопределен, дайте мне знать, обновится для этого также

может это поможет..

class ClassA {

        private int intA;
        private String strA;
        private boolean boolA;

        // Constructor
        public ClassA(int intA, String strA, boolean boolA) {
            this.intA = intA;
            this.strA = strA;
            this.boolA = boolA;
        } // Getters and setters etc. below...

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof ClassA) {
                ClassA obj2 = (ClassA) obj;
                return (this.intA == obj2.intA && this.strA.equals(obj2.strA) && this.boolA == obj2.boolA);
            } else {
                ClassB obj2 = (ClassB) obj;
                return (this.intA == obj2.intB && this.strA.equals(obj2.strB) && this.boolA == obj2.boolB);
            }

        }

        @Override
        public int hashCode() {
            int hash = 3;
            hash = 71 * hash + this.intA;
            hash = 71 * hash + Objects.hashCode(this.strA);
            hash = 71 * hash + (this.boolA ? 1 : 0);
            return hash;
        }
    }

    class ClassB {

        private int intB;
        private String strB;
        private boolean boolB;

        // Constructor
        public ClassB(int intB, String strB, boolean boolB) {
            this.intB = intB;
            this.strB = strB;
            this.boolB = boolB;
        } // Getters and setters etc. below...

        @Override
        public boolean equals(Object obj) {
            if (obj instanceof ClassB) {
                ClassB obj2 = (ClassB) obj;
                return (this.intB == obj2.intB && this.strB.equals(obj2.strB) && this.boolB == obj2.boolB);

            } else {
                ClassA obj2 = (ClassA) obj;
                return (this.intB == obj2.intA && this.strB.equals(obj2.strA) && this.boolB == obj2.boolA);
            }

        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 79 * hash + this.intB;
            hash = 79 * hash + Objects.hashCode(this.strB);
            hash = 79 * hash + (this.boolB ? 1 : 0);
            return hash;
        }
    }

    public void test() {
        List<Object> myList = Arrays.asList(new ClassA(1, "A", true),
                new ClassA(1, "A", true));

        System.out.println(myList.get(0).equals(myList.get(1)));

    }

в то время как для двух отдельных элементов эквивалентное сравнение однозначно определено, для коллекций возможны несколько вариантов эквивалентного сравнения. Один из аспектов заключается в том, следует ли рассматривать упорядочение элементов. Далее, когда порядок не является значительным, то мощность эквивалентных элементов (количество совпадений) может быть или не быть значительной.

поэтому предложение использования EquivalenceComparisonBuilder, на котором вместе с двумя коллекциями и EquivalenceComparator также ComparisonType настраивается - ComparisonType.ORDERING для строгой упорядоченности, ComparisonType.DUPLICATES для строгого подсчета матчей и ComparisonType.SIMPLE для сравнения свободной эквивалентности, где достаточно, чтобы для каждого элемента в одной коллекции был хотя бы один эквивалентный элемент в другой коллекции.

обратите внимание, что выполнение EquivalenceComparator необходимо считать null аргументы, если коллекции могут содержать null элементы.

package equivalence;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Predicate;

public class Equivalence {

    public static interface EquivalenceComparison<S, T> {
        boolean equivalent();
    }

    public static interface EquivalenceComparator<S, T> {
        boolean equivalent(S s, T t);
    }


    static public class EquivalenceComparisonBuilder<S, T> {

        enum ComparisonType {
            ORDERING, DUPLICATES, SIMPLE
        };

        private Collection<S> ss;
        private Collection<T> ts;
        private EquivalenceComparator<S, T> ec;
        private ComparisonType comparisonType;

        public EquivalenceComparisonBuilder<S, T> setCollections(Collection<S> ss, Collection<T> ts) {
            this.ss = ss;
            this.ts = ts;
            return this;
        }

        public EquivalenceComparisonBuilder<S, T> setEquivalenceComparator(EquivalenceComparator<S, T> ec) {
            this.ec = ec;
            return this;
        }

        public EquivalenceComparisonBuilder<S, T> setComparisonType(ComparisonType comparisonType) {
            this.comparisonType = comparisonType;
            return this;
        }

        public EquivalenceComparison<S, T> comparison() {
            if (comparisonType == null || ss == null || ts == null) {
                throw new NullPointerException();
            }
            switch (comparisonType) {
            case ORDERING:
                return new OrderingComparison<S, T>(ss, ts, ec);
            case DUPLICATES:
                return new DuplicatesComparison<S, T>(ss, ts, ec);
            case SIMPLE:
                return new SimpleComparison<S, T>(ss, ts, ec);
            default:
                throw new IllegalArgumentException("Unknown comparison type");
            }
        }

    }


    private static <S, T> EquivalenceComparator<T, S> mirrored(EquivalenceComparator<S, T> ec) {
        return new EquivalenceComparator<T, S>() {
            @Override
            public boolean equivalent(T t, S s) {
                return ec.equivalent(s, t);
            }
        };
    }


    private static class EquivalencePredicate<S, T> implements Predicate<T> {

        private S s;
        private EquivalenceComparator<S, T> equivalenceComparator;

        public EquivalencePredicate(S s, EquivalenceComparator<S, T> equivalenceComparator) {
            this.s = s;
            this.equivalenceComparator = equivalenceComparator;
        }

        @Override
        public boolean evaluate(T t) {
            return equivalenceComparator.equivalent(s, t);
        }
    }

    static private class OrderingComparison<S, T> implements EquivalenceComparison<S, T> {

        private Collection<S> ss;
        private Collection<T> ts;
        private EquivalenceComparator<S, T> ec;

        public OrderingComparison(Collection<S> ss, Collection<T> ts, EquivalenceComparator<S, T> ec) {
            this.ss = ss;
            this.ts = ts;
            this.ec = ec;
        }

        @Override
        public boolean equivalent() {
            if (ss.size() != ts.size()) {
                return false;
            }
            List<S> ssl = new ArrayList<S>(ss);
            List<T> tsl = new ArrayList<T>(ts);

            for (int i = 0; i < ssl.size(); i++) {
                S s = ssl.get(i);
                T t = tsl.get(i);
                if (!ec.equivalent(s, t)) {
                    return false;
                }
            }
            return true;
        }
    }

    static private class DuplicatesComparison<S, T> implements EquivalenceComparison<S, T> {

        private Collection<S> ss;
        private Collection<T> ts;
        private EquivalenceComparator<S, T> ec;

        public DuplicatesComparison(Collection<S> ss, Collection<T> ts, EquivalenceComparator<S, T> ec) {
            this.ss = ss;
            this.ts = ts;
            this.ec = ec;
        }

        @Override
        public boolean equivalent() {
            if (ss.size() != ts.size()) {
                return false;
            }

            for (S s : ss) {
                Collection<T> matchingTs = CollectionUtils.select(ts, new EquivalencePredicate(s, ec));
                if (matchingTs.size() == 0) {
                    return false;
                }

                T t = matchingTs.iterator().next();
                Collection<S> matchingSs = CollectionUtils.select(ss, new EquivalencePredicate(t, mirrored(ec)));

                if (matchingTs.size() != matchingSs.size()) {
                    return false;
                }
            }
            return true;
        }
    }

    static private class SimpleComparison<S, T> implements EquivalenceComparison<S, T> {

        private Collection<S> ss;
        private Collection<T> ts;
        private EquivalenceComparator<S, T> ec;

        public SimpleComparison(Collection<S> ss, Collection<T> ts, EquivalenceComparator<S, T> ec) {
            this.ss = ss;
            this.ts = ts;
            this.ec = ec;
        }

        @Override
        public boolean equivalent() {           
            for (S s : ss) {
                if (!CollectionUtils.exists(ts, new EquivalencePredicate(s, ec))) {
                    return false;
                }
            }
            for(T t :ts) {
                if (!CollectionUtils.exists(ss, new EquivalencePredicate(t, mirrored(ec)))) {
                    return false;
                }
            }
            return true;
        }

    }
}

вот несколько тестов:

package equivalence;

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.junit.Assert;
import org.junit.Test;

import equivalence.Equivalence.EquivalenceComparator;
import equivalence.Equivalence.EquivalenceComparisonBuilder;
import equivalence.Equivalence.EquivalenceComparisonBuilder.ComparisonType;

public class EquivalenceExample {

    static class A {

        private int ia;

        private String is;

        private long a;

        public A(int ia, String is, long a) {
            this.ia = ia;
            this.is = is;
            this.a = a;
        }

        public int getIa() {
            return ia;
        }

        public String getIs() {
            return is;
        }

        public long getA() {
            return a;
        }

    }

    static class B {

        private int ib;

        private String is;

        private long b;

        public B(int ib, String is, long b) {
            this.ib = ib;
            this.is = is;
            this.b = b;
        }

        public int getIb() {
            return ib;
        }

        public String getIs() {
            return is;
        }

        public long getB() {
            return b;
        }

    }

    static class ABEquivalenceComparator implements EquivalenceComparator<A, B> {

        static public ABEquivalenceComparator INSTANCE = new ABEquivalenceComparator();

        @Override
        public boolean equivalent(A a, B b) {
            return new EqualsBuilder().append(a.getIa(), b.getIb()).append(a.getIs(), b.getIs()).isEquals();
        }
    }

    @Test
    public void thatOrderingEquivalenceMatchesEquivalentElementsWhenInSameOrder() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(Arrays.asList(new B(1, "1", 99l), new B(2, "2", 99l)));

        Assert.assertTrue(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.ORDERING)
                .comparison().equivalent());
    }

    @Test
    public void thatOrderingEquivalenceDoesNotMatchEquivalentElementsWhenNotSameOrdering() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(Arrays.asList(new B(2, "2", 99l), new B(1, "1", 99l)));

        Assert.assertFalse(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.ORDERING)
                .comparison().equivalent());
    }

    @Test
    public void thatOrderingEquivalenceDoesNotMatchNonEquivalentElements() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(Arrays.asList(new B(1, "1", 99l), new B(1, "1", 99l)));

        Assert.assertFalse(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.ORDERING)
                .comparison().equivalent());
    }

    @Test
    public void thatDuplicatesEquivalenceMatchesEquivalentElementsRegardlessOrder() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(Arrays.asList(new B(2, "2", 99l), new B(1, "1", 99l)));

        Assert.assertTrue(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.DUPLICATES)
                .comparison().equivalent());
    }

    @Test
    public void thatDuplicatesEquivalenceDoesNotMatchesWhenElementsCardinlityDoNotMatch() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l), new A(1, "1", 99l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(
                Arrays.asList(new B(2, "2", 99l), new B(1, "1", 99l), new B(2, "2", 99l)));

        Assert.assertFalse(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.DUPLICATES)
                .comparison().equivalent());
    }

    @Test
    public void thatSimpleEquivalenceMatchesRegardlessEquivalentElementCardinality() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l), new A(1, "1", 99l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(
                Arrays.asList(new B(2, "2", 99l), new B(1, "1", 99l), new B(2, "2", 99l)));

        Assert.assertTrue(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.SIMPLE)
                .comparison().equivalent());
    }

    @Test
    public void thatSimpleEquivalenceMatchesRegardlessElementsCount() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(
                Arrays.asList(new B(2, "2", 99l), new B(1, "1", 99l), new B(2, "2", 99l)));

        Assert.assertTrue(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.SIMPLE)
                .comparison().equivalent());
    }

    @Test
    public void thatSimpleEquivalenceDoesMatchesWhenElementsDoNotMatch() {
        List<A> as = Arrays.asList(new A(1, "1", 99l), new A(2, "2", 98l));
        LinkedHashSet<B> bs = new LinkedHashSet<B>(Arrays.asList(new B(2, "2", 99l), new B(3, "3", 99l)));

        Assert.assertFalse(new EquivalenceComparisonBuilder<A, B>().setCollections(as, bs)
                .setEquivalenceComparator(ABEquivalenceComparator.INSTANCE).setComparisonType(ComparisonType.SIMPLE)
                .comparison().equivalent());
    }

    }