Array List의 개체를 날짜별로 정렬하시겠습니까?

Array List의 개체를 날짜별로 정렬하시겠습니까?

검색된 모든 예제는 알파벳 순으로 수행되어야 하지만 요소를 날짜별로 정렬해야 합니다.

My ArrayList에는 datamember 중 하나가 DateTime 개체인 개체가 포함되어 있습니다.Date Time에 함수를 호출할 수 있습니다.

lt() // less-than
lteq() // less-than-or-equal-to

비교를 위해 다음과 같은 작업을 수행할 수 있습니다.

if(myList.get(i).lt(myList.get(j))){
    // ...
}

if 블록 안에서는 어떻게 해야 하나요?

개체를 비교할 수 있습니다.

public static class MyObject implements Comparable<MyObject> {

  private Date dateTime;

  public Date getDateTime() {
    return dateTime;
  }

  public void setDateTime(Date datetime) {
    this.dateTime = datetime;
  }

  @Override
  public int compareTo(MyObject o) {
    return getDateTime().compareTo(o.getDateTime());
  }
}

그런 다음 전화를 걸어 정렬합니다.

Collections.sort(myList);

그러나 여러 가지 다른 속성에서 정렬하려는 경우처럼 모델을 변경하지 않을 수 있습니다.이 경우 비교기를 즉시 만들 수 있습니다.

Collections.sort(myList, new Comparator<MyObject>() {
  public int compare(MyObject o1, MyObject o2) {
      return o1.getDateTime().compareTo(o2.getDateTime());
  }
});

단, 위의 내용은 비교 시 dateTime이 null이 아니라고 확신하는 경우에만 유효합니다.Null Pointer를 피하려면 null도 처리하는 것이 좋습니다.예외:

public static class MyObject implements Comparable<MyObject> {

  private Date dateTime;

  public Date getDateTime() {
    return dateTime;
  }

  public void setDateTime(Date datetime) {
    this.dateTime = datetime;
  }

  @Override
  public int compareTo(MyObject o) {
    if (getDateTime() == null || o.getDateTime() == null)
      return 0;
    return getDateTime().compareTo(o.getDateTime());
  }
}

또는 두 번째 예에서는 다음과 같습니다.

Collections.sort(myList, new Comparator<MyObject>() {
  public int compare(MyObject o1, MyObject o2) {
      if (o1.getDateTime() == null || o2.getDateTime() == null)
        return 0;
      return o1.getDateTime().compareTo(o2.getDateTime());
  }
});

Java 8 이후 List 인터페이스는 정렬 방식을 제공합니다.람다 표현과 결합하면 가장 쉬운 해결책은

// sort DateTime typed list
list.sort((d1,d2) -> d1.compareTo(d2));
// or an object which has an DateTime attribute
list.sort((o1,o2) -> o1.getDateTime().compareTo(o2.getDateTime()));
// or like mentioned by Tunaki
list.sort(Comparator.comparing(o -> o.getDateTime()));

역순서

Java 8은 또한 역 정렬을 위한 몇 가지 편리한 방법을 제공합니다.

//requested by lily
list.sort(Comparator.comparing(o -> o.getDateTime()).reversed());

컬렉션을 사용할 수 있습니다.정렬 방식정적인 방법이에요.목록과 대조군을 건네주세요.리스트상에서 변경된 머지소트 알고리즘을 사용합니다.따라서 쌍 비교를 위해 비교기를 전달해야 합니다.

Collections.sort(myList, new Comparator<MyObject> {
   public int compare(MyObject o1, MyObject o2) {
      DateTime a = o1.getDateTime();
      DateTime b = o2.getDateTime();
      if (a.lt(b)) 
        return -1;
      else if (a.lteq(b)) // it's equals
         return 0;
      else
         return 1;
   }
});

myList가 비교 가능한 유형(Comparable 인터페이스를 구현하는 유형)인 경우(Date, Integer, String 등) 비교기를 생략할 수 있으며 자연스러운 순서가 사용됩니다.

list.sort(Comparator.comparing(o -> o.getDateTime()));

Java 8 lambda를 사용한 Tunaki의 IMHO 베스트 답안

의 「」MyObject가가 a that DateTime의 getDateTime() method 「」를 할 수 .ArrayList★★★★★★★★★★★★★를 포함한MyObject의 DateTime다음과 같이 합니다.

Collections.sort(myList, new Comparator<MyObject>() {
    public int compare(MyObject o1, MyObject o2) {
        return o1.getDateTime().lt(o2.getDateTime()) ? -1 : 1;
    }
});

이렇게 해결했습니다.

Collections.sort(MyList, (o1, o2) -> o1.getLastModified().compareTo(o2.getLastModified()));

도움이 되길 바랍니다.

미래의 시청자는, 이것이 가장 간단한 해결책이라고 생각합니다.모델에 문자열 타입의 날짜(예를 들면, 2020-01 10:00:00")가 포함되어 있는 경우는, 다음의 행을 기입해, 최신에서 가장 오래된 날짜의 순서로 데이터를 정렬합니다.

Collections.sort(messages, (o1, o2) -> o2.getMessageDate().compareTo(o1.getMessageDate()));

여기 있는 모든 답변은 간단한 문제(적어도 경험이 많은 자바 개발자에게)에 대해 지나치게 복잡하다는 것을 알게 되었습니다.저도 비슷한 문제가 있어서 우연히 이 (및 다른) 해결책을 발견했는데, 초보자용 포인터는 제공되었지만, 위에서 설명한 바와 같습니다.이 경우 dataVector는 오브젝트를 포함하는 ArrayList입니다.여기서 dataVector는 오브젝트의 위치에 따라 날짜가 오브젝트 []의 첫 번째 요소가 됩니다.

Collections.sort(dataVector, new Comparator<Object[]>() {
    public int compare(Object[] o1, Object[] o2) {
        return ((Date)o1[0]).compareTo(((Date)o2[0]));
    }
});

Java 1.8의 도입으로 스트림은 다음과 같은 문제를 해결하는 데 매우 유용합니다.

Comparator <DateTime> myComparator = (arg1, arg2) 
                -> {
                    if(arg1.lt(arg2)) 
                       return -1;
                    else if (arg1.lteq(arg2))
                       return 0;
                    else
                       return 1;
                   };

ArrayList<DateTime> sortedList = myList
                   .stream()
                   .sorted(myComparator)
                   .collect(Collectors.toCollection(ArrayList::new));

이를 실현하는 방법에 대한 답변은 다음과 같습니다.

Mylist.sort(Comparator.comparing(myClass::getStarttime));

다음 접근방식을 사용하여 날짜 정렬 여부를 식별합니다.

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy");

boolean  decendingOrder = true;
    for(int index=0;index<date.size() - 1; index++) {
        if(simpleDateFormat.parse(date.get(index)).getTime() < simpleDateFormat.parse(date.get(index+1)).getTime()) {
            decendingOrder = false;
            break;
        }
    }
    if(decendingOrder) {
        System.out.println("Date are in Decending Order");
    }else {
        System.out.println("Date not in Decending Order");
    }       
}   

이것은 오래된 응답일 수 있지만, 저는 이 게시물의 몇 가지 예를 사용하여 비교기를 만들고,ArrayList의HashMap<String, String>타임스탬프가 되는 리스트의 1개의 오브젝트.

다음과 같은 오브젝트가 있습니다.

ArrayList<Map<String, String>> alList = new ArrayList<Map<String, String>>();

맵 오브젝트는 다음과 같습니다.

Map<String, Object> map = new HashMap<>();
        // of course this is the actual formatted date below in the timestamp
        map.put("timestamp", "MM/dd/yyyy HH:mm:ss"); 
        map.put("item1", "my text goes here");
        map.put("item2", "my text goes here");

이 매핑을 사용하여 어레이 목록에 모든 개체를 로드합니다.alList.add(map)루프 내에서 기능합니다.

이제 나만의 비교기를 만들었습니다.

import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

 public class DateSorter implements Comparator {
     public int compare(Object firstObjToCompare, Object secondObjToCompare) {
    String firstDateString = ((HashMap<String, String>) firstObjToCompare).get("timestamp");
    String secondDateString = ((HashMap<String, String>) secondObjToCompare).get("timestamp");

    if (secondDateString == null || firstDateString == null) {
        return 0;
    }

    // Convert to Dates
    DateTimeFormatter dtf = DateTimeFormat.forPattern("MM/dd/yyyy HH:mm:ss");
    DateTime firstDate = dtf.parseDateTime(firstDateString);
    DateTime secondDate = dtf.parseDateTime(secondDateString);

    if (firstDate.isAfter(secondDate)) return -1;
    else if (firstDate.isBefore(secondDate)) return 1;
    else return 0;
    }
}

이제 어레이 상의 언제든지 Comparator를 호출하면 어레이가 정렬되고 위치 0(목록 맨 위)에 최신 타임스탬프가 표시되고 목록 끝에 가장 빠른 타임스탬프가 표시됩니다.신규 직급은 기본적으로 상위 직급에 배치됩니다.

Collections.sort(alList, new DateSorter());

이게 누군가에게 도움이 될 수도 있고, 그래서 제가 올린 거야.compare() 함수 내의 return 문을 고려합니다.세 가지 종류의 결과가 있습니다.값이 같으면 0을 반환하고, 첫 번째 날짜가 두 번째 날짜 이전이면 0을 반환하고, 첫 번째 날짜가 두 번째 날짜 이후이면 0을 반환합니다.목록을 번복하려면 이 두 개의 반환 문구를 바꾸면 됩니다.심플 =]

ArrayList In 인수를 전달합니다.

    private static void order(ArrayList<Object> list) {

    Collections.sort(list, new Comparator() {

        public int compare(Object o2, Object o1) {

            String x1 =  o1.Date;
            String x2 =  o2.Date;

                return  x1.compareTo(x2);

        }
    });
}

날짜 클래스에서 이미 비교기 인터페이스를 구현했습니다.다음과 같은 클래스가 있다고 가정합니다.

public class A {

    private Date dateTime;

    public Date getDateTime() {
        return dateTime;
    }

    .... other variables

}

A 오브젝트의 리스트는 다음과 같습니다.List<A> aListJava 8의 스트림 API(아래의 스니펫)를 사용하여 쉽게 정렬할 수 있습니다.

import java.util.Comparator;
import java.util.stream.Collectors;

...

aList = aList.stream()
        .sorted(Comparator.comparing(A::getDateTime))
        .collect(Collectors.toList())

언급URL : https://stackoverflow.com/questions/5927109/sort-objects-in-arraylist-by-date