Question

我有以下问题，我不太确定如何解决它。我从几个不同的服务器请求数据，每个服务器返回一个不同类型的对象列表（每个服务器都有它自己特定的POJO对象类型） - 但所有这些对象列表的共同点是所有对象有一个日期参数。然后，我需要将所有列表中的对象显示为用户的一个巨大混合列表，所有各种对象按日期排序。

我制作了一个扩展baseadapter的适配器，并且我已将所有对象的arraylists传递给该适配器 - 但是如何按日期对所有这些对象列表进行排序并将它们全部显示在一起？我可以创建一个超级对象＆＃34;具有所有其他对象的属性，然后使这个超级对象的一个排序数组传递给适配器，但这似乎是一个混乱和粗糙的解决方案。是否有一种或多或少的优雅方式来做到这一点？

public class someAdapter extends BaseAdapter
{
...

public someAdapter(ArrayList<ObjectOne> objectOneArray, ArrayList<ObjectTwo> objectTwoArray) {
        if (objectOneArray != null) {
            this.localObjectOneList.addAll(objectOneArray);
        }
        ...
}
}

对象类型示例：

public class ObjectOne implements Serializable {
private String date;
private String someFieldOne;
private String someFieldTwo;

...
//getters and setters
...
}

重申 - 最终列表必须按日期顺序混合所有不同的对象类型。

Answer 1

如果没有相关的巨大管道，那么你最初期望拥有超级课程的方式会很好。更好的方法可以如下：假设所有POJO都有getDate（）方法。

声明方法getDate（）以从任何POJO中检索日期对象。
声明Comparator以比较日期

对象排序

如果POJO没有getter，即getDate()方法，请将getDateFromMethod()替换为getDateFromProperty()中的comparator。

public class Sorter{ public void sortList()
{
    Collections.sort(objList, comparator);

    // Now consume / print your objList to get sorted by date
}

ArrayList<Object>   objList     = new ArrayList<Object>();

Comparator<Object>  comparator  = new Comparator<Object>()
                                {



                                @Override
                                public int compare(Object object1, Object o2)
                                    {
                                        Date o1Date = getDateFromMethod(object1);
                                        Date o2Date = getDateFromMethod(o2);
                                        if (o1Date != null && o2Date != null)
                                        {
                                            if (o1Date.before(o2Date))
                                                return -1;
                                            else if (o1Date.after(o2Date))
                                                return 1;

                                            else
                                                return 0;
                                        }
                                        else
                                            return -1;
                                    }
                                };

public Date getDateFromMethod(Object obj)
{

    Date date = null;
    String getDate = "getDate";
    try
    {
        Method method = obj.getClass().getMethod(getDate, (Class<?>[]) null);
        if (method != null)
            date = (Date) method.invoke(obj, (Object[]) null);
    }
    catch (NoSuchMethodException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (SecurityException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (IllegalAccessException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (IllegalArgumentException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    catch (InvocationTargetException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return date;
}public Date getDateFromProperty(Object obj)
                            {
                                Date date=null;
                                try
                                {
                                Field dateField=    obj.getClass().getField("date");
                                if(dateField!=null)
                                    date=(Date) dateField.get(obj);
                                }
                                catch (NoSuchFieldException e)
                                {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                                }
                                catch (SecurityException e)
                                {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                                }
                                catch (IllegalArgumentException e)
                                {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                                }
                                catch (IllegalAccessException e)
                                {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                                }

                                return date;

                            }

}

现在比如说你有如下的Obj1，Obj2和Obj3，使用这些POJOS创建对象并填充objList并测试解决方案。

类Obj1 { int id; int name; 日期;

public Date getDate()

{ 归期; } public int getId（） { 返回id; }

public void setId(int id)
{
    this.id = id;
}

public int getName()
{
    return name;
}

public void setName(int name)
{
    this.name = name;
}

}

类Obj2 { int序列; int位置; 日期;

public Date getDate()

{ 归期; } public int getSequence（） { 返回序列; }

public void setSequence(int sequence)
{
    this.sequence = sequence;
}

public int getLocation()
{
    return location;
}

public void setLocation(int location)
{
    this.location = location;
}

}

类Obj3 { int类型; int origin; 日期;

public Date getDate()

{ 归期; }

public void setDate（Date date） { this.date = date; }

public int getType()
{
    return type;
}

public void setType(int type)
{
    this.type = type;
}

public int getOrigin()
{
    return origin;
}

public void setOrigin(int origin)
{
    this.origin = origin;
}

}

Answer 2

只需使用对象类型列表来保存任何引用类型

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

Answer 3

如果你能够改变对象的类定义，我建议你让它们实现Comparable，然后覆盖compareTo()方法，最后使用Arrays.sort（）对列表进行排序

Answer 4

您可以使用方法getDate()

创建自己的界面

interface PojoInterface {
    ...
    Date getDate();
}

每个POJO都应实现此接口

然后你应该创建自定义Comparator类

class CustomComparator implements Comparator<PojoInterface> {

    @Override
    public int compare(PojoInterface a, PojoInterface t1) {
        return a.getDate().compareTo(t1.getDate());
    }

    ...
}

然后对一个通用列表进行排序

public someAdapter(ArrayList<A> objectOneArray, ArrayList<A> objectTwoArray) {
    this.localObjectsList.addAll(objectOneArray);
    this.localObjectsList.addAll(objectTwoArray);
    Collections.sort(this.localObjectsList, new CustomComparator());
    ...
}

将不同类型的对象排序到一个列表中

4 个答案: