Сортировка порядка объектов по дате

Question

У меня есть следующее определение бина, как показано ниже,

Class A{ 
    int id 
    Date date; 

} 

Class B{ 
    int id 
    Date date; 

} 

У меня есть список массива следующим образом

List<A> l1 = new ArrayList<A>() 
l1.add(new A(1, 2014-12-12)); 
l1.add(new A(2, 2014-12-14)); 

List<B> l2 = new ArrayList<B>() 
l2.add(new B(1, 2014-12-13)); 
l2.add(new B(2, 2014-12-15)); 

Другой список следующим образом

List<Object> finalList = new ArrayList<Object>(); 

сейчас я все равно могу поставить объект l1 и l2 в finalList в соответствии с датой

, например. Окончательный список должен быть следующим:

A(1, 2014-12-12); 
B(1, 2014-12-13); 
A(2, 2014-12-14); 
B(2, 2014-12-15); 

как я могу это сделать ??

Answer 1

Я предполагаю, что у вас есть два разных класса и оба имеют объекты Date.Вместо того чтобы держать список объектов, я хотел бы предложить вам создать базовый интерфейс, как, например:

interface Dated { 
    Date getDate(); 
} 

Сделайте ваши два класса реализует этот интерфейс:

class A implements Dated { 
int id; 
Date date; 

@Override 
public Date getDate() { 
    return date; 
} 
} 

class B implements Dated { 
    int id; 
    Date date; 

    @Override 
    public Date getDate() { 
    return date; 
    } 
} 

Создать компаратор как:

class DatedComparator implements Comparator<Dated> { 
    @Override 
    public int compare(Dated o1, Dated o2) { 
    return o1.getDate().compareTo(o2.getDate()); 
    } 
} 

Затем вы можете хранить список Датированных объектов:

List<Dated> finalList = new ArrayList<Dated>(); 

, которые могут быть легко отсортированы с помощью вашей компаратор:

Collections.sort(finalList, new DatedComparator()); 

Answer 2

Скажем, у меня есть класс, как

class MyClass 
{ 
    Date date; 
} 

Вы можете легко отсортировать список экземпляров «MyClass» путем внедрения Сопоставимые интерфейса:

class MyClass implements Comparable<MyClass> 
{ 
    Date date; 

    @Override 
    public int compareTo(MyClass o) 
    { 
    if (o.date.getTime() > this.date.getTime()) 
    return -1; 
    else 
    return 1; 
    } 
} 

таким образом, если у вас есть список, состоящий из MyClass вы можете сортировать его, как

Collection.sort(mylist); 

Больше информации здесь http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html

EDIT:

Обратите внимание, что вы можете реализуете несколько Сопоставимого интерфейс с различным типом, так что вы класс может быть по сравнению с другими классами.

Answer 3

Supose У меня есть этот компонент:

class Item implements Comparable<Item> { 
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd"); 

    int id; 
    Date date; 

    public Item(int id, String date) throws ParseException { 
     this.id = id; 
     this.date = formatter.parse(date); 
    } 

    @Override 
    public int compareTo(Item o) { 
     return this.date.compareTo(o.date); 
    } 
} 

Смотри, что я реализовал java.lang.Comparable интерфейс. После этого я просто добавить все элементы в finalList и сортировка списка с помощью метода сортировки класса java.util.Collections так:

List<Item> l1 = new ArrayList<Item>(); 
    l1.add(new Item(1, "2014-12-12")); 
    l1.add(new Item(2, "2014-12-14")); 

    List<Item> l2 = new ArrayList<Item>(); 
    l2.add(new Item(1, "2014-12-13")); 
    l2.add(new Item(2, "2014-12-15")); 

    List<Item> finalList = new ArrayList<Item>(); 
    finalList.addAll(l1); 
    finalList.addAll(l2); 

    Collections.sort(finalList); 

Вы можете не выполнять Complarable интерфейса в вашей фасоли и использовании этот другой метод:

Collections.sort(finalList, new Comparator<Item>() { 

     @Override 
     public int compare(Item o1, Item o2) { 
      return o1.date.compareTo(o2.date); 
     } 
    }); 

Answer 4

Я предполагаю, что это не вариант для вас, чтобы сделать различные типы в списке совместимы. Но если odering действительно ваша единственная проблема здесь вы могли бы пользователь адаптивный компаратора для сортировки:

class DateOrder implements Comparator<Object> { 
    @Override 
    public int compare(Objecto1, Objecto2) { 
     return toDate(o1).compareTo(toDate(o2)); 
    } 

    private Date toDate(Object x) { 
     if (x instanceof A) { 
     return ((A)x).date; 
     } 
     return ((B)x).date; 
    } 
} 

Однако наличие несколько различных типов в одной коллекции, как правило, не является хорошей идеей. Поэтому, возможно, лучше использовать адаптер экземпляра (т. Е. Для обертки для обеспечения уникального интерфейса для логики, работающей с этими типами). В большинстве случаев этот подход более ценен в долгосрочной перспективе, поскольку нет необходимости снова и снова перебрасывать чтобы получить еще одну часть данных. Но я не знаю достаточно о вашей проблеме, чтобы дать четкий совет.