Question

可以说我有一个包含对象的列表，可以将其称为listA，它是无序的，并且具有类型为A的对象。类型A有一个名为name的字段。现在，我还有另一个列表，已排序。我们称之为listB，它是有序的。该列表中的对象的类型为B，并且它们还具有字段name。

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

最有效的方法是什么？

Answer 1

希望我能理解您的问题。

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

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

使用getCompareFields（）方法创建接口返回String []; （例如）
对象A和B中点1的实现接口
实施一种排序算法，该算法使用此接口的getCompareFields（）方法进行排序。

而且，甚至还有另一种方式，您可以执行此操作，但是我认为这会更复杂，它是使用反射来获取两个对象的字段“名称”，它们之间没有任何联系。

希望对您有帮助。

EDIT 反射示例：

Class 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 + ")";
}

}

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

}

结果：

ListA： [（（Yves Larock，f40cb523-58e8-4ee2-aa4f-991ce7e7cdd5），（我很好，5a66b9d9-7a27-4529-ab64-c893291bd9b0），（Aaah，4842fd55-47e5-48ac-b7b6-ebc7acfh3c， 8dc89675-bc28-4374-aff2-0c5d0ae6dd9d）]

列表B： [（Aaah，[1,2,3]），（我很好，1），（Noooh，[34，3]），（Yves Larock，[4，5，3，9]） ]

===排序后==== ListA： [（Aaah，4842fd55-47e5-48ac-b7b6-ebc7acf7023c），（我可以，5a66b9d9-7a27-4529-ab64-c893291bd9b0），（Noooh，8dc89675-bc28-4374-aff2-0c5d0ae6dd9d），（ f40cb523-58e8-4ee2-aa4f-991ce7e7cdd5）]

列表B： [（Aaah，[1,2,3]），（我很好，1），（Noooh，[34，3]），（Yves Larock，[4，5，3，9]） ]

用Java最好的方式来对具有不同对象的另一个列表进行排序

1 个答案: