如何使用对象名称字段按字母顺序对 List<Object> 进行排序

Question

我有一个对象列表，例如List<Object> p。我想使用对象名称字段按字母顺序对这个列表进行排序。对象包含 10 个字段，名称字段是其中之一。

if (list.size() > 0) {
    Collections.sort(list, new Comparator<Campaign>() {
        @Override
        public int compare(final Object object1, final Object object2) {
        return String.compare(object1.getName(), object2.getName());
        }
    } );
}

但是没有什么像 String.compare..？

Answer 1

从您的代码来看，您的 Comparator 似乎已经使用 Campaign 进行了参数化。这仅适用于List<Campaign>。此外，您正在寻找的方法是compareTo。

if (list.size() > 0) {
  Collections.sort(list, new Comparator<Campaign>() {
      @Override
      public int compare(final Campaign object1, final Campaign object2) {
          return object1.getName().compareTo(object2.getName());
      }
  });
}

或者如果您使用的是 Java 1.8

list
  .stream()
  .sorted((object1, object2) -> object1.getName().compareTo(object2.getName()));

最后一条评论——检查列表大小是没有意义的。排序将适用于空列表。

Answer 2

由于国际化，按字母顺序排序字符串的最正确方法是使用Collator。由于多余的字符等原因，某些语言的顺序不同。

   Collator collator = Collator.getInstance(Locale.US);
   if (!list.isEmpty()) {
    Collections.sort(list, new Comparator<Campaign>() {
        @Override
        public int compare(Campaign c1, Campaign c2) {
            //You should ensure that list doesn't contain null values!
            return collator.compare(c1.getName(), c2.getName());
        }
       });
   }

如果您不关心国际化，请使用string.compare(otherString)。

   if (!list.isEmpty()) {
    Collections.sort(list, new Comparator<Campaign>() {
        @Override
        public int compare(Campaign c1, Campaign c2) {
            //You should ensure that list doesn't contain null values!
            return c1.getName().compare(c2.getName());
        }
       });
   }

Answer 3

使用 Java 8 Comparator.comparing：

list.sort(Comparator.comparing(Campaign::getName));

Answer 4

看看Collections.sort() 和Comparator 接口。

可以使用object1.getName().compareTo(object2.getName()) 或object2.getName().compareTo(object1.getName()) 进行字符串比较（取决于您想要的排序方向）。

如果您希望排序不区分大小写，请执行object1.getName().toUpperCase().compareTo(object2.getName().toUpperCase())。

Answer 5

public class ObjectComparator implements Comparator<Object> {

    public int compare(Object obj1, Object obj2) {
        return obj1.getName().compareTo(obj2.getName());
    }

}

请将 Object 替换为您的类包含名称字段

用法：

ObjectComparator comparator = new ObjectComparator();
Collections.sort(list, comparator);

Answer 6

这是 Robert B 的答案的一个版本，适用于 List<T>，并使用反射按对象的指定字符串属性进行排序，不使用第 3 方库

/**
 * Sorts a List by the specified String property name of the object.
 * 
 * @param list
 * @param propertyName
 */
public static <T> void sortList(List<T> list, final String propertyName) {

    if (list.size() > 0) {
        Collections.sort(list, new Comparator<T>() {
            @Override
            public int compare(final T object1, final T object2) {
                String property1 = (String)ReflectionUtils.getSpecifiedFieldValue (propertyName, object1);
                String property2 = (String)ReflectionUtils.getSpecifiedFieldValue (propertyName, object2);
                return property1.compareToIgnoreCase (property2);
            }
        });
    }
}


public static Object getSpecifiedFieldValue (String property, Object obj) {

    Object result = null;

    try {
        Class<?> objectClass = obj.getClass();
        Field objectField = getDeclaredField(property, objectClass);
        if (objectField!=null) {
            objectField.setAccessible(true);
            result = objectField.get(obj);
        }
    } catch (Exception e) {         
    }
    return result;
}

public static Field getDeclaredField(String fieldName, Class<?> type) {

    Field result = null;
    try {
        result = type.getDeclaredField(fieldName);
    } catch (Exception e) {
    }       

    if (result == null) {
        Class<?> superclass = type.getSuperclass();     
        if (superclass != null && !superclass.getName().equals("java.lang.Object")) {       
            return getDeclaredField(fieldName, type.getSuperclass());
        }
    }
    return result;
}

Answer 7

类似

  List<FancyObject> theList = … ;
  Collections.sort (theList,
                    new Comparator<FancyObject> ()
                    { int compare (final FancyObject a, final FancyObject d)
                          { return (a.getName().compareTo(d.getName())); }});

Answer 8

你可以从Eclipse Collections使用sortThisBy()：

MutableList<Campaign> list = Lists.mutable.empty();
list.sortThisBy(Campaign::getName);

如果您无法从List 更改列表类型：

List<Campaign> list = new ArrayList<>();
ListAdapter.adapt(list).sortThisBy(Campaign::getName);

注意：我是 Eclipse Collections 的贡献者。

Answer 9

试试这个：

List< Object> myList = x.getName;
myList.sort(Comparator.comparing(Object::getName));

Answer 10

如果你的对象有一些共同的祖先[让它成为T]，你应该使用List<T>而不是List<Object>，并为此T实现一个Comparator，使用名称字段。

如果你没有共同的祖先，你可以实现一个 Comperator，并使用reflection 来提取名称，注意使用反射是不安全的，不建议使用，并且性能不好，但它允许你在不了解对象的实际类型的情况下访问字段名称[除了它具有具有相关名称的字段这一事实]

在这两种情况下，您都应该使用Collections.sort() 进行排序。

Answer 11

我找到了另一种类型的方法。

if(listAxu.size() > 0){
    Collections.sort(listAxu, Comparator.comparing(IdentityNamed::getDescricao));
}

Answer 12

这是假设YourClass 的列表而不是Object，如amit 所述。

您可以使用 Google Guava 库中的这个位：

Collections.sort(list, Ordering.natural()
  .onResultOf(new Function<String,YourClass>() {
  public String call(YourClass o) {
     return o.getName();
  }))
  .nullsLast();

提到Comparator 的其他答案并非不正确，因为Ordering 实现了Comparator。在我看来，这个解决方案更容易一些，但如果您是初学者并且不习惯使用库和/或“函数式编程”，则可能会更难。

无耻地抄自this answer on my own question.

Answer 13

使用选择排序

for(int i = list.size() - 1; i > 0; i--){

  int max = i

  for(int j = 0; j < i; j++){
      if(list.get(j).getName().compareTo(list.get(j).getName()) > 0){
            max= j;
      }
  }

  //make the swap
  Object temp = list.get(i);
  list.get(i) = list.get(max);
  list.get(max) = temp;

}

Answer 14

如果您使用List<Object> 来保存具有名称字段的子类型的对象（让我们调用子类型NamedObject），则需要向下转换列表元素才能访问名称。您有 3 个选项，其中最好的是第一个：

1. 如果可以的话，首先不要使用List<Object> - 将命名对象保存在List<NamedObject>
2. 将您的 List<Object> 元素复制到 List<NamedObject>，在此过程中向下转换，进行排序，然后将它们复制回来
3. 在 Comparator 中进行向下转换

选项 3 如下所示：

Collections.sort(p, new Comparator<Object> () {
        int compare (final Object a, final Object b) {
                return ((NamedObject) a).getName().compareTo((NamedObject b).getName());
        }
}

Answer 15

if(listAxu.size() > 0){
     Collections.sort(listAxu, new Comparator<Situacao>(){
        @Override
        public int compare(Situacao lhs, Situacao rhs) {            
            return lhs.getDescricao().compareTo(rhs.getDescricao());
        }
    });
 }

Answer 16

@Victor 的回答对我有用，并在 Kotlin 中重新发布，以防其他人使用 Android。

if (list!!.isNotEmpty()) {
   Collections.sort(
     list,
     Comparator { c1, c2 -> //You should ensure that list doesn't contain null values!
     c1.name!!.compareTo(c2.name!!)
   })
}

Answer 17

你可以用这个：

List<Campaign> list = new ArrayList<>(); 
list.sort(Comparator.comparing(Campaign::getName));