Java 如何对列表进行排序<；对象>；按字母顺序使用对象名称字段

我有一个对象列表，如

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

if（list.size（）>0）{
Collections.sort（list，newcomparator（）{
@凌驾
公共整数比较（最终对象object1，最终对象object2）{
返回String.compare（object1.getName（），object2.getName（））；
}
} );
}

---

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

看看

Collections.sort（）

和

Comparator

接口

字符串比较可以使用

object1.getName（）.compareTo（object2.getName（））

或

object2.getName（）.compareTo（object1.getName（））

（取决于所需的排序方向）

---

如果您希望排序不区分大小写，请执行

object1.getName（）.toUpperCase（）.compareTo（object2.getName（）.toUpperCase（））

如果您的对象有一些共同的祖先[让它成为

T

]，您应该使用

List

而不是

List

，并使用name字段为这个T实现一个

如果您没有共同的祖先，可以实现Comperator，并使用来提取名称，注意使用反射是不安全的、未被挖掘的，并且性能很差，但是它允许您访问字段名，而不知道对象的实际类型[除了它有一个具有相关名称的字段之外]

---

在这两种情况下，您都应该使用来排序。

这是假设一个

YourClass

列表，而不是

Object

，正如amit所解释的那样

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

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

Collections.sort（list，Ordering.natural（）
.onResultOf（新函数（）{
公共字符串调用（YourClass o）{
返回o.getName（）；
}))
.nullsLast（）；

提到

比较器

的其他答案并不错误，因为

排序

实现了

比较器

。在我看来，这个解决方案稍微容易一些，但如果您是初学者，不习惯使用库和/或“函数式编程”，可能会更难

不知羞耻地从类似

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

列出列表=；
Collections.sort（列表，
新比较器（）
{int比较（最终FancyObject a，最终FancyObject d）
{return（a.getName（）.compareTo（d.getName（））；}}）；

使用选择排序

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;

}

for（int i=list.size（）-1；i>0；i--）{
int max=i
对于（int j=0；j0）{
max=j；
}
}
//交换
对象温度=列表获取（i）；
list.get（i）=list.get（max）；
获取（最大）=温度；
}

从您的代码来看，您的

比较器似乎已经用
活动
参数化了。这只适用于
列表
。此外，您正在寻找的方法是
比较到

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

最后一条注释——检查列表大小没有意义。排序将在空列表上工作。
如果使用
列表
保存具有名称字段的子类型的对象（让我们调用子类型
名称对象
），您需要向下转换列表元素才能访问该名称。您有3个选项，其中最好的是第一个选项：

如果可以，首先不要使用
列表
——将命名对象保存在
列表中
将
列表
元素复制到
列表
中，在此过程中向下转换，进行排序，然后将它们复制回来
在比较器中进行向下投射
选项3如下所示：

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

Collections.sort（p，新的比较器（）{
int比较（最终对象a、最终对象b）{
返回（（NamedObject）a.getName（）.compareTo（（NamedObject b.getName（））；
}
}
由于国际化，按字母顺序排列字符串的最正确方法是使用
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());
        }
       });
   }

下面是Robert B的答案的一个版本，它适用于
List
，并使用反射和无第三方库按对象的指定字符串属性进行排序

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

/**
*按对象的指定字符串属性名称对列表进行排序。
* 
*@param列表
*@param propertyName
*/
publicstaticvoidsortlist（列表，最终字符串propertyName）{
如果（list.size（）>0）{
Collections.sort（list，newcomparator（）{
@凌驾
公共整数比较（最终T对象1，最终T对象2）{
字符串property1=（字符串）ReflectionUtils.getSpecifiedFieldValue（propertyName，object1）；
String property2=（String）ReflectionUtils.getSpecifiedFieldValue（propertyName，object2）；
返回属性1.compareToIgnoreCase（属性2）；
}
});
}
}
公共静态对象getSpecifiedFieldValue（字符串属性，对象obj）{
对象结果=空；
试一试{
类objectClass=obj.getClass（）；
Field objectField=getDeclaredField（属性，objectClass）；
if（objectField！=null）{
objectField.setAccessible（true）；
结果=objectField.get（obj）；
}
}捕获（例外e）{
}
返回结果；
}
公共静态字段getDeclaredField（字符串字段名，类类型）{
字段结果=空；
试一试{
结果=类型.getDeclaredField（fieldName）；
}捕获（例外e）{
}       
如果（结果==null）{
Class superclass=type.getSuperclass（）；
如果（superclass！=null&&！superclass.getName（）.equals（“java.lang.Object”）{
返回getDeclaredField（fieldName，type.getSuperclass（））；
}
}
返回结果；
}
Collections.sort(p, new Comparator<Object> () {
        int compare (final Object a, final Object b) {
                return ((NamedObject) a).getName().compareTo((NamedObject b).getName());
        }
}

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

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

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

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

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

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

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

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

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

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

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