Java中按对象类型排序的对象列表

我有两个目标：

public class GroupObject
{
  String name;
  ...
}

public class AddressObject
{
  String name;
  ...
}

我收集了它们两个：

List<Object> _listValues;

List\u列表值；

在开始处理listValues之前，我需要对对象进行排序：

所有GroupObjects应位于列表的顶部，AddressObjects应位于GroupObjects之后

在此顺序内，GroupObjects必须按name属性以及AddressObjects进行排序

现在看起来是这样的：

_listValues[0]-->AddressObject“c-address”

_listValues[1]-->AddressObject“b地址”

_listValues[2]-->GroupObject“b组”

_listValues[3]-->AddressObject“a-address”

_listValues[4]-->GroupObject“a组”

_listValues[5]-->AddressObject“d-address”

应该是这样的：

public class GroupObject implements Sortable {
  String name;

  @Override
  public String getName() {
    return name;
  }

  @Override
  public int getSortOrder() {
    return 1;
  }
}

_listValues[0]-->GroupObject“a组”

_listValues[1]-->GroupObject“b组”

_listValues[2]-->AddressObject“a-address”

_listValues[3]-->AddressObject“b地址”

_listValues[4]-->AddressObject“c-address”

_listValues[5]-->AddressObject“d-address”

如何对列表值进行排序以实现此目的？

您可以使用

List\sort

：

     _listValues.sort((o1, o2) -> {
        if (o1 instanceof GroupObject && o2 instanceof AddressObject) {
            return 1;
        } else if (o1 instanceof AddressObject && o2 instanceof GroupObject) {
            return -1;
        } else if (o1 instanceof GroupObject && o2 instanceof GroupObject) {
            GroupObject g1 = (GroupObject) o1;
            GroupObject g2 = (GroupObject) o2;
            return g1.getName().compareTo(g2.getName());
        } else {
            AddressObject a1 = (AddressObject) o1;
            AddressObject a2 = (AddressObject) o2;
            return a1.getName().compareTo(a2.getName());
        }
    });

---

我通过将其拆分成更小的列表，再进行排序和浓缩来解决这个问题。这也有助于更复杂的集合

您还可以选择哪个对象应该位于列表的顶部

    private List<Object> sortValuesList(List<Object> listValues)
    {
        List<Object> listObject = new ArrayList<>();
        List<GroupObject> listGroups = new ArrayList<>();
        List<AddressObject> listAddress = new ArrayList<>();

        for (Object obj : listValues)
        {
            if (obj instanceof GroupObject)
            {
               listGroups.add((GroupObject) obj);
            }
            else if (obj instanceof AddressObject)
            {
                listAddress.add((AddressObject) obj);
            }
        }

        listGroups.sort((o1, o2) -> o1.name.compareTo(o2.name));
        listAddress.sort((o1, o2) -> o1.name.compareTo(o2.name));

        listObject = Stream.concat(listGroups.stream(), listAddress.stream())
                .collect(Collectors.toList());

        return listObject;
    }

私有列表sortValuesList（列表值）
{
List listObject=new ArrayList（）；
List listGroups=new ArrayList（）；
List listAddress=new ArrayList（）；
用于（对象对象对象：列表值）
{
if（组对象的obj实例）
{
添加（（GroupObject）obj）；
}
else if（地址对象的obj实例）
{
添加（（AddressObject）obj）；
}
}
排序（（o1，o2）->o1.name.compareTo（o2.name））；
排序（（o1，o2）->o1.name.compareTo（o2.name））；
listObject=Stream.concat（listGroups.Stream（），listAddress.Stream（））
.collect（Collectors.toList（））；
返回listObject；
}
一个更健壮的解决方案是让类实现一些公共接口，我们称之为可排序的
：

public interface Sortable {
  String getName();
  int getSortOrder();
}

然后，您的类将如下所示：

public class GroupObject implements Sortable {
  String name;

  @Override
  public String getName() {
    return name;
  }

  @Override
  public int getSortOrder() {
    return 1;
  }
}

排序将非常简单，如下所示：

_listValues.sort(Comparator.comparing(Sortable::getSortOrder).thenComparing(Sortable::getName));

假设
\u listValues
属于
List
类型，请创建自定义比较器并使用内置排序方法。或者，您也可以编写自己的排序方法。谢谢。它在某种程度上有所帮助，但如果未排序列表的第一个对象不是GroupObject，则不一定将GroupObject放在列表的顶部。我已经发布了一个“更重”的答案。