개체 이름 필드를 사용하여 List <Object>를 알파벳순으로 정렬하는 방법

같은 객체 목록 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와 같은 것은 없습니다 ..?

코드에서 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()));

마지막으로, 목록 크기를 확인할 필요가 없습니다. 빈 목록에서 정렬이 작동합니다.

알파벳순으로 문자열을 정렬하는 가장 올바른 방법 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());
        }
       });
   }

Collections.sort()및 Comparator인터페이스를 살펴보십시오 .

object1.getName().compareTo(object2.getName())또는 object2.getName().compareTo(object1.getName())(원하는 정렬 방향에 따라)를 사용하여 문자열 비교를 수행 할 수 있습니다 .

대소 문자를 구분하지 않는 정렬을 원하면 object1.getName().toUpperCase().compareTo(object2.getName().toUpperCase()).

Java 8 Comparator.comparing 사용 :

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

public class ObjectComparator implements Comparator<Object> {

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

}

개체를 이름 필드가 포함 된 클래스로 바꾸십시오.

용법:

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

같은 것

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

다음은 List<T>Reflection을 사용하고 타사 라이브러리를 사용하지 않는 객체의 지정된 String 속성에 대해 작동 하고 정렬 하는 Robert B의 답변 버전입니다.

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

Eclipse CollectionssortThisBy() 에서 사용할 수 있습니다 .

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

에서 목록 유형을 변경할 수없는 경우 List:

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

참고 : 저는 Eclipse Collections의 기고자입니다.

이 시도:

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

객체에 공통 조상 T이있는 경우 List<T>대신을 사용하고 이름 필드를 사용하여이 T에 List<Object>대한 비교기 를 구현 해야 합니다.

공통 조상이없는 경우 Comperator를 구현하고 리플렉션 을 사용하여 이름을 추출 할 수 있습니다. 안전하지 않고 권장되지 않으며 리플렉션을 사용하는 데 성능이 좋지 않지만 필드 이름에 액세스 할 수 있습니다. 개체의 실제 유형에 대해 알지 못함 [관련 이름의 필드가 있다는 사실 외에]

두 경우 모두 Collections.sort () 를 사용 하여 정렬 해야합니다 .

유형을 수행하는 다른 방법을 찾았습니다.

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

이것은 amit에 의해 설명 된대로 YourClass대신의 목록을 가정합니다 .Object

Google Guava 라이브러리에서이 비트를 사용할 수 있습니다.

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

물론 다른 대답을 Comparator하기 때문에, 잘못된 없습니다 Ordering구현 Comparator. 이 솔루션은 제 생각에는 좀 더 쉽습니다. 초보자이고 라이브러리 및 / 또는 "기능적 프로그래밍"을 사용하는 데 익숙하지 않은 경우 더 어려울 수 있습니다.

이 답변에서 내 질문에 뻔뻔스럽게 복사했습니다 .

선택 정렬 사용

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;

}

를 사용하여 List<Object>이름 필드가있는 하위 유형의 객체를 보유하는 경우 (subtype을 호출 할 수 있음 NamedObject) 이름에 액세스하려면 목록 요소를 다운 캐스트해야합니다. 세 가지 옵션이 있으며 그중 가장 좋은 것은 첫 번째입니다.

1. List<Object>도움이된다면 처음부터 a 를 사용하지 마십시오 .List<NamedObject>
2. 당신의 복사 List<Object>에 요소를 List<NamedObject>정렬을 수행하는 과정에서 downcasting, 다시 복사
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());
        }
}

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

@Victor의 답변은 저에게 효과적이며 Android를 수행하는 다른 사람에게 유용한 경우 Kotlin에 다시 게시했습니다.

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