1

自動生成された JAXB クラス

public class Employee {
   private int id;
   private String name;
   private String department;

   /* Getters and Setters */

}

Employee emp1 = new Employee();
emp1.setId(1);
emp1.setName("A");
emp1.setDepartment("D1");


Employee emp2 = new Employee();
emp2.setId(2);
emp2.setName("B");
emp2.setDepartment("D1");

List<Employee> empList1 = new ArrayList<Employee>();
empList1.add(emp1);
empList2.add(emp2);

Employee emp3 = new Employee();
emp2.setId(3);
emp2.setName("A");
emp2.setDepartment("D1");

List<Employee> empList2 = new ArrayList<Employee>();
empList2.add(emp3);

リスト empList1 と empList2 の両方を比較して、Employee オブジェクトの名前と部門のフィールドに一致する結果リストを取得したいと考えています。

基本的に、2 つのオブジェクトのフィールドのカスタム比較に基づいて、2 つのリストの交差が必要です。

Google Guava と lambdaJ を見ていましたが、カスタム比較ロジックによる交差を行うためのソリューション/サンプルを見つけることができませんでした。

どんなアイデアでも役に立ちます。

4

3 に答える 3

2

比較には、Guava Ordering または Java Comparator を使用できます。また、フィルタリングには述語を使用できます。

一般的なものが必要な場合は、1 つのコンパレーターを使用できます (DEP と NAME の両方に対して)。

    class MyComparator implements Comparator<Employee> {

        @Override
        public int compare(final Employee left, final Employee right) {
            return ComparisonChain.start().compare(left.getName(), right.getName())
                                  .compare(left.getDepartment(), right.getDepartment()).result();
        }

    }

    class MyPredicate implements Predicate<Employee> {

        final List<Employee> employees;
        final Comparator<Employee> comparator;

        public MyPredicate(final List<Employee> employees, final Comparator<Employee> comparator) {
            this.employees = employees;
            this.comparator = comparator;
        }

        @Override
        public boolean apply(@Nullable final Employee input) {
            for (final Employee e : employees) {
                if (comparator.compare(e, input) == 0) {
                    return true;
                }

            }

            return false;
        }

    }

次に、次のように使用できます。

    final MyComparator comparator = new MyComparator();
    final MyPredicate predicate1 = new MyPredicate(empList1, comparator);
    final MyPredicate predicate2 = new MyPredicate(empList2, comparator);
    System.out.println("####");
    System.out.println(Collections2.filter(empList2, predicate1));
    System.out.println(Collections2.filter(empList1, predicate2));
于 2013-08-08T15:42:01.383 に答える
0 
public List<Employee> findIntersections(List<Employee> listA, List<Employee> listB)
{

    List<Employee> returnList = new List<Employee>();
    Employee empA, empB;

    for(int i = 0; i<listA.size; i++)
    {
        for(int j = 0; j<listB.size; j++)
        {
            empA = listA.get(i);
            empB = listB.get(j);

            if(empA.getID == empB.getID() && empA.getName().equals(empB.getName()) && empA.getDepartment().equals(empB.getDepartment()))
            {
                returnList.add(empA);//or add empB...since theyre the same
            }
        }
    }

    return returnList;
}

一般的な実装が必要です。フィールドに基づく等価チェックが必要な JAXB オブジェクトが多数あります。ブール値を返すメソッドを持つ Comparator に似たものはありますか?

これが私が見つけたものです（プラグインが必要な場合があります）：

残念ながら、jaxb はこれを標準で提供していません。このプラグインを使用するか、よりカスタマイズ可能な動作のために独自のプラグインを作成できます。

ソース：

https://stackoverflow.com/a/7771776/2498729

于 2013-08-07T15:49:17.680 に答える
0

2 つのリストが交差するようにメソッドを手動でハッキングするのが、最も速い方法です。しかし、より一般的なアプローチが必要な場合はEmployee、たとえば guavasEquivalenceクラスを使用できます。これにより、リスト内のエントリを にマップし、それらのラッパー セットでEquivalence.Wrapper使用できます。Sets.intersect

public static <T> Set<T> intersect(Iterable<? extends T> a, Iterable<? extends T> b, Equivalence<? super T> eq) {
    Function<T, Wrapper<T>> f = wrappingFunction(eq);

    Set<Wrapper<T>> as = ImmutableSet.copyOf(Iterables.transform(a, f));
    Set<Wrapper<T>> bs = ImmutableSet.copyOf(Iterables.transform(b, f));

    SetView<Wrapper<T>> intersection = Sets.intersection(as, bs);

    return ImmutableSet.copyOf(Iterables.transform(intersection,
            Test.<T> unwrappingFunction()));
}

wherewrappingFunction()とunwrappingFunction()are 2 つのユーティリティ関数があります。

    public static <T> Function<T, Wrapper<T>> wrappingFunction(
        final Equivalence<? super T> eq) {
    return new Function<T, Wrapper<T>>() {
        public Wrapper<T> apply(T input) {
            return eq.wrap(input);
        }
    };
}

private static final Function<Wrapper<Object>, Object>  UNWRAPPING_FUNCTION = new Function<Wrapper<Object>, Object>() {

    public Object apply(Wrapper<Object> input) {
        return checkNotNull(input).get();
    }
};

@SuppressWarnings("unchecked")
public static <T> Function<Wrapper<T>, T> unwrappingFunction() {
    return ((Function<Wrapper<T>, T>) ((Function<?, ?>) UNWRAPPING_FUNCTION));
}

これが整ったら、実装EquivalenceしEmployeeて適用する必要がありますintersect

Set<Employee> x = intersect(a, b, new Equivalence<Employee>() {

        @Override
        protected boolean doEquivalent(Employee a, Employee b) {
            checkNotNull(a);
            checkNotNull(b);
            return Objects.equals(a.getId(), b.getId())
                && Objects.equals(a.getDepartment(), b.getDepartment())
                && Objects.equals(a.getName(), b.getName());
        }

        @Override
        protected int doHash(Employee t) {
            return t.getId();
        }
    });

この例では、返さSetれる には duplicate が含まれませんEmployees。

于 2013-09-29T13:20:18.460 に答える