Sortowanie tablicy obiektów za pomocą niestandardowego porządku sortowania

Oprócz tego, co już zostało opublikowane, powinieneś wiedzieć, że od Javy 8 możemy skrócić nasz kod i napisać go w następujący sposób:

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

Or since List now have sort method

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

Wyjaśnienie:

Od Javy 8 interfejsy funkcjonalne (interfejsy z tylko jedną abstrakcyjną metodą - mogą mieć więcej domyślnych lub statycznych metod) mogą być łatwo zaimplementowane za pomocą:

• lambdas arguments -> body
• lub odniesienia do metody source::method.

Ponieważ Comparator<T> ma tylko jedną abstrakcyjną metodę {[11] } jest interfejsem funkcjonalnym.

Więc zamiast (przykład z @ BalusC odpowiedź )

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

Możemy zredukować ten kod do:

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

Możemy uprościć tę (lub dowolną) lambdę pomijając

W Javie istnieją dwa typy argumentów, które mogą być przypisane do danej metody.]}
• lub {return ... }

Więc zamiast

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

Możemy napisz

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

Również teraz Comparator ma statyczne metody, takie jak comparing(FunctionToComparableValue) lub comparing(FunctionToValue, ValueComparator), których moglibyśmy użyć do łatwego tworzenia komparatorów, które powinny porównywać pewne konkretne wartości z obiektów.

Innymi słowy możemy przepisać powyższy kod jako

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

Ta strona mówi ci wszystko, co musisz wiedzieć o sortowaniu kolekcji, takich jak ArrayList.

W zasadzie musisz

• Niech twoja klasa Contact zaimplementuje Interfejs Comparable poprzez
  • tworzenie metody public int compareTo(Contact anotherContact) wewnątrz niej.
• kiedy to zrobisz, możesz po prostu zadzwonić Collections.sort(myContactList);,
  • gdzie myContactList jest ArrayList<Contact> (lub dowolnym innym zbiorem Contact).

Jest też inny sposób, polegający na stworzeniu komparatora klasy, A o tym możesz przeczytać również na linkowanej stronie.

Przykład:

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 i bguiz udzielili już bardzo wyczerpujących odpowiedzi na temat korzystania z wbudowanych komparatorów Javy.

Chcę tylko dodać, że google-collections ma klasę Ordering , która jest bardziej "potężna" niż standardowe komparatory. Może warto to sprawdzić. Możesz robić fajne rzeczy, takie jak składanie zamówień, odwracanie ich, zamawianie w zależności od wyniku funkcji dla obiektów...

TUTAJ jest post na blogu, który wspomina o niektórych jego zaletach.

Musisz sprawić, aby Twoje klasy kontaktu zaimplementowały porównywalne, a następnie zaimplementowały metodę compareTo(Contact). W ten sposób, Kolekcje.sortowanie będzie w stanie sortować je za Ciebie. CompareTo ' zwraca ujemną liczbę całkowitą, zero lub dodatnią liczbę całkowitą, ponieważ obiekt ten jest mniejszy, równy lub większy od podanego obiektu.'

Na przykład, jeśli chcesz sortować po nazwie (od A do Z), twoja klasa wyglądałaby tak:

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

Używając lambdaj Możesz sortować kolekcję swoich kontaktów (na przykład według ich nazwy) w następujący sposób

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

Lub pod ich adresem:

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

I tak dalej. Ogólnie rzecz biorąc, oferuje DSL do dostępu i manipulowania kolekcjami na wiele sposobów, takich jak filtrowanie lub grupowanie kontaktów w oparciu o pewne warunki, agregowanie niektórych wartości ich właściwości itp.

Zbiory.sortowanie to dobra implementacja sortowania. Jeśli nie masz porównywalnej implementacji dla kontaktu, musisz przejść w implementacji porównawczej

Uwaga:

Algorytm sortowania jest zmodyfikowanym mergesortem (w którym scalanie jest pomijane, jeśli najwyższy element w subliście niskiej jest mniejszy niż najniższy element w subliście wysokiej). Algorytm ten oferuje gwarantowaną wydajność n log(n). Podana lista musi być modyfikowalna, ale nie musi możliwość zmiany rozmiaru. Ta implementacja zrzuca podaną listę do tablicy, sortuje tablicę i iteruje nad listą resetując każdy element z odpowiedniej pozycji w tablicy. Pozwala to uniknąć wydajności dziennika n2 (n), która wynikałaby z próby sortowania połączonej listy w miejscu.

Sortowanie scalające jest prawdopodobnie lepsze niż większość algorytmów wyszukiwania, które możesz zrobić.

Zrobiłem to w następujący sposób. liczba i nazwa to dwie arraylist. Muszę sortować nazwisko .Jeśli jakakolwiek zmiana zdarzy się w nazwie arralist kolejność wtedy liczba arraylist również zmienić swoją kolejność.

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


                        }
                    }
                }
            }



}

Użyj tej metody:

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

`

I użycie: mySortedlist = sortList(myList); Nie musisz wdrażać komparatora w swojej klasie. Jeśli chcesz zamianę zleceń odwrotnych 1 i -1

Wiem, że to było dawno temu... ale oto kilka nowych informacji:

Powiedzmy, że dana klasa kontaktu ma już zdefiniowaną naturalną kolejność poprzez implementację porównywalną, ale chcesz nadpisać tę kolejność, powiedzmy po nazwie. Oto nowoczesny sposób na to:

List<Contact> contacts = ...;

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

W ten sposób najpierw sortuje po nazwie( w odwrotnej kolejności), a następnie dla kolizji nazw wraca do 'naturalnego' porządku zaimplementowanego przez samą klasę Contact.

Powinieneś użyć tablic.funkcja sortowania. Klasy zawierające powinny implementować porównywalne.