Сортировка списка объектов по типам объектов в Java

Question

У меня есть 2 объекта:

public class GroupObject
{
  String name;
  ...
}

public class AddressObject
{
  String name;
  ...
}

У меня есть коллекция из них обоих:

List<Object> _listValues;

Прежде чем я начну работать над _listValues ​​ Мне нужно отсортировать объекты:

1. Все объекты GroupObject должны быть в начале списка, а объекты AddressObject должны следовать после объектов GroupObject
2. Внутри этого порядка объекты GroupObject должны быть отсортированы по name свойство, а также AddressObjects.

Теперь это выглядит так:

_listValues ​​[0] -> AddressObject "c -address"

_listValues ​​[1] -> AddressObject "b-address"

_listValues ​​[2] -> GroupObject "b-group"

_listValues ​​[3] - > AddressObject "a-address"

_listValues ​​[4] -> GroupObject "a-group"

_listValues ​​[5] -> AddressObject "d-address"

Это должно выглядеть так:

_listValues ​​[0] -> GroupObject "a-group"

_listValues ​​[1] -> GroupObject "b-group "

_listValues ​​[2] -> AddressObj ect "a-address"

_listValues ​​[3] -> AddressObject "b-address"

_listValues ​​[4] -> AddressObject "c -адрес"

_listValues ​​[5] -> AddressObject "d-address"

Как мне отсортировать _listValues ​​ для достижения этого?

Answer 1

Вы можете использовать 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());
        }
    });

Answer 2

Более надежное решение может позволить классам реализовать какой-то общий интерфейс, назовем его Sortable:

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

Учитывая, что _listValues имеет тип List<Sortable>.

Answer 3

Я решил это, разделив на более мелкие списки, снова отсортировав и конкатентировав. Это может помочь и для более сложных коллекций.

Также вы можете выбрать, какой объект должен быть в верхней части списка.

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