http://stackoverflow.com/questions/40717638#40830950, Java

Language: Layout:

//Compiler version 1.8.0_72

import java.util.*;
import java.lang.*;
import java.util.function.Function;

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;
    }

int getIntA() {
        return intA;
    }

String getStringA() {
        return strA;
    }
}

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;
    }

int getIntB() {
        return intB;
    }

String getStringB() {
        return strB;
    }
}

interface FieldExtractor<T, V> extends Function<T, V> {
}

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));
        }
    }
}

class Rextester {
    public static void main(String args[]) {
        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)
        ));

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

myList.add(new ClassA(3, "X", true));
        mySet.add(new ClassB(3, "Y", true));
        System.out.println(comp2.areEqual(myList, mySet));
    }
}

[ + ] Show input
Compilation time: 0.72 sec, absolute running time: 0.24 sec, cpu time: 0.17 sec, memory peak: 25 Mb, absolute service time: 0,96 sec