Сортування ArrayList об'єктів за допомогою спеціального порядку сортування

Я хочу реалізувати функцію сортування для програми моєї адресної книги.

Я хочу сортувати ArrayList<Contact> contactArray. Contact- клас, який містить чотири поля: ім'я, домашній номер, номер мобільного телефону та адресу. Я хочу сортувати name.

Як я можу написати спеціальну функцію сортування для цього?

Ось підручник із впорядкування об’єктів:

• Навчальні програми Java - Колекції - Впорядкування об'єктів

Хоча я наведу кілька прикладів, рекомендую все-таки прочитати.

Існують різні способи сортування ArrayList. Якщо ви хочете , щоб визначити природну ( по замовчуванню) впорядкованість , то вам потрібно , щоб Contactреалізувати Comparable. Припустимо, що ви хочете сортувати за замовчуванням увімкнено name, тоді зробіть (нульові перевірки пропущено для простоти):

public class Contact implements Comparable<Contact> {

    private String name;
    private String phone;
    private Address address;

    public int compareTo(Contact other) {
        return name.compareTo(other.name);
    }

    // Add/generate getters/setters and other boilerplate.
}

щоб ви могли просто зробити

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

Collections.sort(contacts);

Якщо ви хочете визначити зовнішнє кероване впорядкування (яке перекриває природне впорядкування), тоді вам потрібно створити Comparator:

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

// Now sort by address instead of name (default).
Collections.sort(contacts, new Comparator<Contact>() {
    public int compare(Contact one, Contact other) {
        return one.getAddress().compareTo(other.getAddress());
    }
}); 

Ви навіть можете визначити Comparators в Contactсобі, щоб ви могли повторно використовувати їх, а не створювати їх щоразу:

public class Contact {

    private String name;
    private String phone;
    private Address address;

    // ...

    public static Comparator<Contact> COMPARE_BY_PHONE = new Comparator<Contact>() {
        public int compare(Contact one, Contact other) {
            return one.phone.compareTo(other.phone);
        }
    };

    public static Comparator<Contact> COMPARE_BY_ADDRESS = new Comparator<Contact>() {
        public int compare(Contact one, Contact other) {
            return one.address.compareTo(other.address);
        }
    };

}

які можна використовувати наступним чином:

List<Contact> contacts = new ArrayList<Contact>();
// Fill it.

// Sort by address.
Collections.sort(contacts, Contact.COMPARE_BY_ADDRESS);

// Sort later by phone.
Collections.sort(contacts, Contact.COMPARE_BY_PHONE);

А щоб скрепити верхівку, можна подумати про використання загального компактного javabean :

public class BeanComparator implements Comparator<Object> {

    private String getter;

    public BeanComparator(String field) {
        this.getter = "get" + field.substring(0, 1).toUpperCase() + field.substring(1);
    }

    public int compare(Object o1, Object o2) {
        try {
            if (o1 != null && o2 != null) {
                o1 = o1.getClass().getMethod(getter, new Class[0]).invoke(o1, new Object[0]);
                o2 = o2.getClass().getMethod(getter, new Class[0]).invoke(o2, new Object[0]);
            }
        } catch (Exception e) {
            // If this exception occurs, then it is usually a fault of the developer.
            throw new RuntimeException("Cannot compare " + o1 + " with " + o2 + " on " + getter, e);
        }

        return (o1 == null) ? -1 : ((o2 == null) ? 1 : ((Comparable<Object>) o1).compareTo(o2));
    }

}

який ви можете використовувати наступним чином:

// Sort on "phone" field of the Contact bean.
Collections.sort(contacts, new BeanComparator("phone"));

(як ви бачите в коді, можливо, нульові поля вже охоплені, щоб уникнути NPE під час сортування)

Крім того, що вже було розміщено, ви повинні знати, що з Java 8 ми можемо скоротити наш код і записати його так:

Collection.sort(yourList, Comparator.comparing(YourClass::getFieldToSortOn));

або оскільки тепер у списку є sortметод

yourList.sort(Comparator.comparing(YourClass::getFieldToSortOn));

Пояснення:

Оскільки Java 8, функціональні інтерфейси (інтерфейси лише з одним абстрактним методом - у них може бути більше стандартних або статичних методів) можуть бути легко реалізовані за допомогою:

• лямбда arguments -> body
• або посилання на метод source::method .

Оскільки Comparator<T>має лише один абстрактний метод, int compare(T o1, T o2)це функціональний інтерфейс.

Тож замість (приклад з відповіді @BalusC )

Collections.sort(contacts, new Comparator<Contact>() {
    public int compare(Contact one, Contact other) {
        return one.getAddress().compareTo(other.getAddress());
    }
}); 

ми можемо зменшити цей код до:

Collections.sort(contacts, (Contact one, Contact other) -> {
     return one.getAddress().compareTo(other.getAddress());
});

Ми можемо спростити цю (або будь-яку) лямбда, пропустивши

• типи аргументів (Java виводить їх на основі підпису методу)
• або {return...}

Тож замість

(Contact one, Contact other) -> {
     return one.getAddress().compareTo(other.getAddress();
}

ми можемо писати

(one, other) -> one.getAddress().compareTo(other.getAddress())

Також тепер Comparatorє статичні методи, такі як comparing(FunctionToComparableValue)або comparing(FunctionToValue, ValueComparator)які ми могли б використовувати для легкого створення компараторів, які повинні порівнювати певні значення з об'єктів.

Іншими словами, ми можемо переписати вище код як

Collections.sort(contacts, Comparator.comparing(Contact::getAddress)); 
//assuming that Address implements Comparable (provides default order).

На цій сторінці ви знайдете все, що вам потрібно знати про сортування колекцій, наприклад, ArrayList.

В основному це потрібно

• змусити ваш Contactклас реалізувати Comparableінтерфейс
  • створення методу public int compareTo(Contact anotherContact)всередині нього.
• Після цього ви можете просто зателефонувати Collections.sort(myContactList);,
  • де myContactListзнаходиться ArrayList<Contact>(або будь-яка інша колекція Contact).

Також є інший спосіб, який полягає у створенні класу компаратора, і про це ви можете прочитати також на пов'язаній сторінці.

Приклад:

public class Contact implements Comparable<Contact> {

    ....

    //return -1 for less than, 0 for equals, and 1 for more than
    public compareTo(Contact anotherContact) {
        int result = 0;
        result = getName().compareTo(anotherContact.getName());
        if (result != 0)
        {
            return result;
        }
        result = getNunmber().compareTo(anotherContact.getNumber());
        if (result != 0)
        {
            return result;
        }
        ...
    }
}

BalusC і bguiz вже дали дуже повні відповіді, як використовувати вбудовані компаратори Java.

Я просто хочу додати, що в колекціях google є клас замовлення, який є «потужнішим», ніж у стандартних компараторів. Можливо, варто перевірити. Ви можете робити цікаві речі, такі як складання замовлень, їх скасування, упорядкування залежно від результату функції для ваших об'єктів ...

Ось допис у блозі, де згадуються деякі її переваги.

Потрібно зробити так, щоб ваші контактні класи реалізовували Порівняння , а потім реалізовували compareTo(Contact)метод. Таким чином, Collections.sort зможе сортувати їх для вас. На сторінці, до якої я пов’язаний, сравнениеTo 'повертає від'ємне ціле число, нуль або додатне ціле число, оскільки цей об'єкт менший, рівний або більший за вказаний об'єкт. "

Наприклад, якщо ви хочете сортувати за назвою (від A до Z), ваш клас виглядатиме так:

public class Contact implements Comparable<Contact> {

    private String name;

    // all the other attributes and methods

    public compareTo(Contact other) {
        return this.name.compareTo(other.name);
    }
}

Використовуючи lambdaj, ви можете сортувати колекцію ваших контактів (наприклад, за їх іменем) наступним чином

sort(contacts, on(Contact.class).getName());

або за їх адресою:

sort(contacts, on(Contacts.class).getAddress());

і так далі. Загалом, він пропонує DSL для доступу та маніпулювання колекціями різними способами, як фільтрування чи групування контактів на основі деяких умов, агрегування деяких їх властивостей тощо.

Колекція.sort є гарною реалізацією. Якщо у вас немає подібного впровадженого для Contact, вам потрібно буде перейти до реалізації Comparator

Зверніть увагу:

Алгоритм сортування - це модифікований об'єднаний елемент (у якому злиття опущено, якщо найвищий елемент у нижньому списку менше, ніж найнижчий елемент у високому підсписі). Цей алгоритм пропонує гарантовану продуктивність n log (n). Зазначений список повинен бути модифікованим, але його не потрібно змінювати. Ця реалізація скидає вказаний список у масив, сортує масив та повторює список, скидаючи кожен елемент із відповідної позиції в масиві. Це дозволяє уникнути продуктивності n2 log (n), яка б була результатом спроби сортування пов'язаного списку на місці.

Сортування злиття, мабуть, краще, ніж більшість алгоритмів пошуку, які ви можете зробити.

Я зробив це наступним чином. номер і ім’я - два масиви. Я повинен сортувати ім'я. Якщо будь-які зміни трапляються з назвою arralist order, то число arraylist також змінює його порядок.

public void sortval(){

        String tempname="",tempnum="";

         if (name.size()>1) // check if the number of orders is larger than 1
            {
                for (int x=0; x<name.size(); x++) // bubble sort outer loop
                {
                    for (int i=0; i < name.size()-x-1; i++) {
                        if (name.get(i).compareTo(name.get(i+1)) > 0)
                        {

                            tempname = name.get(i);

                            tempnum=number.get(i);


                           name.set(i,name.get(i+1) );
                           name.set(i+1, tempname);

                            number.set(i,number.get(i+1) );
                            number.set(i+1, tempnum);


                        }
                    }
                }
            }



}

використовувати цей метод:

private ArrayList<myClass> sortList(ArrayList<myClass> list) {
    if (list != null && list.size() > 1) {
        Collections.sort(list, new Comparator<myClass>() {
            public int compare(myClass o1, myClass o2) {
                if (o1.getsortnumber() == o2.getsortnumber()) return 0;
                return o1.getsortnumber() < o2.getsortnumber() ? 1 : -1;
            }
        });
    }
    return list;
}

`

та використання: mySortedlist = sortList(myList); Не потрібно впроваджувати компаратор у своєму класі. Якщо ви хочете обернути замовлення свопом 1і-1

Гаразд, я знаю, що на це відповіли давно ... але, ось нова інформація:

Скажіть, що у відповідного класу контактів вже є визначене природне впорядкування за допомогою впровадження Comparable, але ви хочете перекрити це замовлення, скажімо, по імені. Ось сучасний спосіб зробити це:

List<Contact> contacts = ...;

contacts.sort(Comparator.comparing(Contact::getName).reversed().thenComparing(Comparator.naturalOrder());

Таким чином він спочатку буде сортувати за назвою (у зворотному порядку), а потім для зіткнень з іменами повернеться до "природного" впорядкування, реалізованого самим класом Contact.

Ви повинні використовувати функцію Arrays.sort. Класи, що містять вміст, повинні реалізувати порівняно