Java通过具有不同对象的另一个列表对列表进行排序的最佳方法

Question

假设我有一个包含对象的列表，我们将其称为 listA，它是无序的，并且它具有 A 类型的对象。类型 A 有一个名为 name 的字段。 现在，我有另一个列表，已排序。我们将其命名为 listB 并且它是有序的。此列表中的对象属于 B 类型，并且它们还有一个字段 name。

现在，我希望将 listA 排序为 listB，这两个列表中唯一相同的是字段 name > 这在两个对象中是相同的。

最有效的方法是什么？

Answer 1

我希望我能理解您的问题。

“名称”字段是两种类型的对象(A 和 B)共享的公共(public)字段吗？ 换句话说，这两种类型(A 和 B)是否扩展了包含字段“name”的同一个 C 类？如果是这样，您可以实现 Comparable在C类然后Collections.sort()会为你解决问题的。在实现比较时，您所要做的就是“教”它如何比较字段“名称”，以便它以相同的方式对您指定的类型 B 对象列表进行排序。

执行此操作的另一种方法，如果您的类没有任何共同点，因此没有父类(super class) C 的意义，则创建一个 Comparator 接口(interface)，您可以在其中指定可用于比较两个不同对象的字段，然后使用这些字段进行排序，换句话说:

1. 使用方法 getCompareFields() 返回 String[] 创建一个接口(interface)； (例如)
2. 在对象 A 和 B 中实现第 1 点的接口(interface)
3. 实现使用此接口(interface)的 getCompareFields() 方法进行排序的排序算法。

而且，甚至还有另一种方法，但是，在我看来，会更复杂，就是使用反射来获取两个对象的字段“名称”，如果它们没有任何关系。

希望这对您有帮助。

编辑 反射示例:

类 TypeA(示例)

public class TypeA {
private String name;
private String id;

public TypeA() {
    this(null, null);
}

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

public String getName() {
    return this.name;
}

public String getId() {
    return this.id;
}

@Override
public String toString() {
    return "(" + name + ", " + id + ")";
}

}

B 类(示例)

public class TypeB {
private String name;
private List<Integer> numbers;

public TypeB() {
    this(null);
}

public TypeB(String name, int ... numbers) {
    this.name = name;

    this.numbers = new LinkedList<Integer>();
    if (numbers != null) {
        for (int i : numbers) {
            this.numbers.add(i);
        }
    }
}

public String getName() {
    return this.name;
}

public List<Integer> getANumber() {
    return this.numbers;
}

@Override
public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append("(").append(name).append(", [");

    Iterator<Integer> i = this.numbers.iterator();

    if (i.hasNext()) {
        builder.append(i.next());

        while (i.hasNext()) {
            builder.append(", ").append(i.next());
        }
    }

    builder.append("])");
    return builder.toString();
}

}

反射名称比较器:

public class NameReflectionComparator implements Comparator<Object> {

@Override
public int compare(Object o1, Object o2) {
    if (o1 != null && o2 != null) {
        try {
            Method obj1_getNameMethod = o1.getClass().getMethod("getName");
            Method obj2_getNameMethod = o2.getClass().getMethod("getName");

            String obj1_name = (String) obj1_getNameMethod.invoke(o1);
            String obj2_name = (String) obj2_getNameMethod.invoke(o2);

            if (obj1_name != null) {
                return obj1_name.compareTo(obj2_name);
            } else if (obj2_name != null) {
                return obj2_name.compareTo(obj1_name);
            }
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }

    } else if (o1 != null && o2 == null) {
        return 1;
    } else if (o1 == null && o2 != null) {
        return -1;
    }

    return 0;
}

}

主要:

public class Main {
public static void main(String[] args) {

    // both TypeA and TypeB have field name and method getName()
    // unsorted list
    List<TypeA> typeAList = new LinkedList<TypeA>();
    typeAList.add(new TypeA("Yves Larock", UUID.randomUUID().toString()));
    typeAList.add(new TypeA("I'm ok", UUID.randomUUID().toString()));
    typeAList.add(new TypeA("Aaah", UUID.randomUUID().toString()));
    typeAList.add(new TypeA("Noooh", UUID.randomUUID().toString()));

    // sorted list
    List<TypeB> typeBList = new LinkedList<TypeB>();
    typeBList.add(new TypeB("Aaah", 1, 2, 3));
    typeBList.add(new TypeB("I'm ok", 1));
    typeBList.add(new TypeB("Noooh", 34, 3));
    typeBList.add(new TypeB("Yves Larock", 4, 5, 3, 9));

    System.out.println("ListA:\n" + typeAList);
    System.out.println("ListB:\n" + typeBList);

    NameReflectionComparator comparator = new NameReflectionComparator();
    Collections.sort(typeAList, comparator);


    System.out.println("=== AFTER SORT ====\nListA:\n" + typeAList);
    System.out.println("ListB:\n" + typeBList);
}

}

结果:

列表A: [(伊夫·拉洛克，f40cb523-58e8-4ee2-aa4f-991ce7e7cdd5)，(我很好，5a66b9d9-7a27-4529-ab64-c893291bd9b0)，(啊啊，4842fd55-47e5-48ac-b7b6-ebc7acf 7023c),(不， 8dc89675-bc28-4374-aff2-0c5d0ae6dd9d)]

列表B: [(啊啊, [1, 2, 3]), (我很好, 1 ), (不, [34, 3]), (伊夫·拉洛克, [4, 5, 3, 9])]

=== 排序后 ==== list A: [(啊啊，4842fd55-47e5-48ac-b7b6-ebc7acf7023c)，(我很好，5a66b9d9-7a27-4529-ab64-c893291bd9b0)，(Noooh，8dc89675-bc28-4374-aff2-0c5d0ae6dd9 d), (伊夫·拉洛克, f40cb523-58e8-4ee2-aa4f-991ce7e7cdd5)]

列表B: [(啊啊, [1, 2, 3]), (我很好, 1 ), (不, [34, 3]), (伊夫·拉洛克, [4, 5, 3, 9])]