날짜별로 ArrayList의 객체를 정렬 하시겠습니까?

내가 찾은 모든 예는 알파벳순 으로이 작업을 수행하는 반면 날짜별로 정렬 된 요소가 필요합니다.

내 ArrayList에는 데이터 멤버 중 하나가 DateTime 개체 인 개체가 포함되어 있습니다. DateTime에서 함수를 호출 할 수 있습니다.

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이 아닌 경우에만 작동합니다. NullPointerException을 피하기 위해 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 메소드를 사용할 수 있습니다. 정적 방법입니다. 리스트와 비교기를 전달합니다. 목록에 대해 수정 된 병합 정렬 알고리즘을 사용합니다. 그렇기 때문에 쌍 비교를 수행하려면 비교기를 전달해야합니다.

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 인터페이스를 구현하는 유형) (예 : 날짜, 정수 또는 문자열) 인 경우 비교기를 생략하면 자연 순서가 사용됩니다.

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

Java 8 람다를 사용하는 Tunaki의 가장 좋은 답변 IMHO

감안할 때 MyObject가 그 DateTime로모그래퍼 회원을 getDateTime()방법, 당신은 정렬 할 수 있습니다 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()));

그것이 당신을 돕기를 바랍니다.

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

여기에있는 모든 대답은 간단한 문제 (적어도 경험이없는 Java 개발자에게는 필요하지 않음)에 대해 불필요하게 복잡하다는 것을 알았습니다. 나는 비슷한 문제가 있었고이 (및 다른) 솔루션에 대해 기회를 얻었으며 포인터를 제공했지만 초보자에게 위에서 언급 한 것처럼 발견했습니다. 내 솔루션은 날짜가 객체의 어디에 있는지에 따라 다릅니다.이 경우 날짜는 Object []의 첫 번째 요소입니다. 여기서 dataVector 는 객체를 포함하는 ArrayList입니다.

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

이 오래된 응답 할 수 있지만, 나는 정렬 할 것 비교기 만들려면이 게시물에서 몇 가지 예를 사용하는 ArrayList의를 HashMap<String, String>타임 스탬프 인 것을, 목록에서 하나의 객체로한다.

나는이 물건들을 가지고있다 :

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 문을 고려하십시오. 3 가지 유형의 결과가 있습니다. 동일한 경우 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);

        }
    });
}

아래 방법을 사용하여 날짜가 정렬되어 있는지 확인하십시오.

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

Date 클래스는 이미 Comparator 인터페이스를 구현합니다. 아래 수업이 있다고 가정합니다.

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

미래의 시청자들에게는 이것이 가장 간단한 해결책이라고 생각합니다. 모델에 문자열 유형 날짜 (예 : "2020-01-01 10:00:00")가 포함 된 경우 다음 줄을 작성하여 데이터를 다음 날짜부터 내림차순으로 정렬하십시오 가장 오래된 것에서 가장 새로운 것 :

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