Як сортувати ArrayList?

У мене є список пар в java, і я хочу сортувати ArrayList у порядку зменшення.

Введення ArrayList наведено нижче:

List<Double> testList = new ArrayList();

testList.add(0.5);
testList.add(0.2);
testList.add(0.9);
testList.add(0.1);
testList.add(0.1);
testList.add(0.1);
testList.add(0.54);
testList.add(0.71);
testList.add(0.71);
testList.add(0.71);
testList.add(0.92);
testList.add(0.12);
testList.add(0.65);
testList.add(0.34);
testList.add(0.62);

Позиція повинна бути такою

0.92
0.9
0.71
0.71
0.71
0.65
0.62
0.54
0.5
0.34
0.2
0.12
0.1
0.1
0.1

Collections.sort(testList);
Collections.reverse(testList);

Це зробить те, що ти хочеш. Не забудьте імпортувати, Collectionsхоча!

Ось документація наCollections .

Низхідний:

Collections.sort(mArrayList, new Comparator<CustomData>() {
    @Override
    public int compare(CustomData lhs, CustomData rhs) {
        // -1 - less than, 1 - greater than, 0 - equal, all inversed for descending
        return lhs.customInt > rhs.customInt ? -1 : (lhs.customInt < rhs.customInt) ? 1 : 0;
    }
});

Використовуйте утильовий метод класу java.util.Collections , тобто

Collections.sort(list)

Насправді, якщо ви хочете сортувати спеціальний об’єкт, який ви можете використовувати

Collections.sort(List<T> list, Comparator<? super T> c) 

дивіться колекції api

Для вашого прикладу, це зробить магію в Java 8

List<Double> testList = new ArrayList();
testList.sort(Comparator.naturalOrder());

Але якщо ви хочете сортувати за деякими з полів об'єкта, який ви сортуєте, ви можете це легко зробити:

testList.sort(Comparator.comparing(ClassName::getFieldName));

або

 testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());

або

 testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());

Джерела: https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

Використовуючи лямбдаси (Java8) та знімаючи їх до найсильнішого синтаксису (JVM в цьому випадку може зробити багато ), ви отримуєте:

Collections.sort(testList, (a, b) -> b.compareTo(a));

Більш докладна версія:

// Implement a reverse-order Comparator by lambda function
Comparator<Double> comp = (Double a, Double b) -> {
    return b.compareTo(a);
};

Collections.sort(testList, comp);

Використання лямбда можливе тому, що в інтерфейсі компаратора є лише один метод реалізації, і VM може зробити висновок, який метод реалізований. Оскільки типи парам можуть бути зроблені для висновку, їх не потрібно зазначати (тобто (a, b)замість (Double a, Double b). А оскільки тіло лямбда має лише один рядок, і метод, як очікується, поверне значення, returnслід зробити висновок і дужки не потрібні.

Для Java8 в інтерфейсі List існує метод сортування за замовчуванням, який дозволить вам сортувати колекцію, якщо ви надаєте компаратор. Ви можете легко сортувати приклад у питанні наступним чином:

testList.sort((a, b) -> Double.compare(b, a));

Примітка: арг в лямбда заміняються при передачі на Double.compare, щоб переконатися, що сорт спадає

Ви можете використовувати Collections.sort(list)для сортування, listякщо listмістять Comparableелементи. В іншому випадку я рекомендую вам реалізувати цей інтерфейс, як тут:

public class Circle implements Comparable<Circle> {}

і, звичайно, забезпечити власну реалізацію compareToметоду, як тут:

@Override
    public int compareTo(Circle another) {
        if (this.getD()<another.getD()){
            return -1;
        }else{
            return 1;
        }
    }

І тоді ви знову можете використовувати, Colection.sort(list)оскільки тепер список містить об'єкти Порівняного типу і їх можна сортувати. Замовлення залежить від compareToспособу. Перевірте це на https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html для отримання більш детальної інформації.

Collections.sortдозволяє передавати екземпляр a, Comparatorякий визначає логіку сортування. Тож замість сортування списку у природному порядку та реверсування його можна просто перейти Collections.reverseOrder()до sortтого, щоб сортувати список у зворотному порядку:

// import java.util.Collections;
Collections.sort(testList, Collections.reverseOrder());

Як зазначає @ Marco13, окрім того, що є більш ідіоматичним (і, можливо, більш ефективним), використання порівняльного зворотного порядку гарантує стабільність сортування (це означає, що порядок елементів не буде змінено, коли вони будуть рівними відповідно до порівняльника, тоді як зміна порядку змінить порядок)

//Here is sorted List alphabetically with syncronized

package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;

/**
 * @author manoj.kumar
 */
public class SynchronizedArrayList {
    static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
        synchronizedList.add(new Employee("Aditya"));
        synchronizedList.add(new Employee("Siddharth"));
        synchronizedList.add(new Employee("Manoj"));
        Collections.sort(synchronizedList, new Comparator() {
            public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((Employee) synchronizedListOne).name
                        .compareTo(((Employee) synchronizedListTwo).name);
            }
        }); 
    /*for( Employee sd : synchronizedList) {
    log.info("Sorted Synchronized Array List..."+sd.name);
    }*/

        // when iterating over a synchronized list, we need to synchronize access to the synchronized list
        synchronized (synchronizedList) {
            Iterator<Employee> iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
            }
        }

    }
}

class Employee {
    String name;

    Employee(String name) {
        this.name = name;

    }
}

Ось коротка шпаргалка, яка охоплює типові випадки:

// sort
list.sort(naturalOrder())

// sort (reversed)
list.sort(reverseOrder())

// sort by field
list.sort(comparing(Type::getField))

// sort by field (reversed)
list.sort(comparing(Type::getField).reversed())

// sort by int field
list.sort(comparingInt(Type::getIntField))

// sort by double field (reversed)
list.sort(comparingDouble(Type::getDoubleField).reversed())

// sort by nullable field (nulls last)
list.sort(comparing(Type::getNullableField, nullsLast(naturalOrder())))

// two-level sort
list.sort(comparing(Type::getField1).thenComparing(Type::getField2))

якщо ви використовуєте Java SE 8, то це може допомогти.

//create a comparator object using a Lambda expression
Comparator<Double> compareDouble = (d1, d2) -> d1.compareTo(d2);

//Sort the Collection in this case 'testList' in reverse order
Collections.sort(testList, Collections.reverseOrder(compareDouble));

//print the sorted list using method reference only applicable in SE 8
testList.forEach(System.out::println);

| * | Сортування списку:

import java.util.Collections;

| => Сортувати порядок вибору:

Collections.sort(NamAryVar);

| => Сортувати Dsc Порядок:

Collections.sort(NamAryVar, Collections.reverseOrder());

| * | Зворотній порядок списку:

Collections.reverse(NamAryVar);

Ви можете зробити так:

List<String> yourList = new ArrayList<String>();
Collections.sort(yourList, Collections.reverseOrder());

Колекція має компаратор за замовчуванням, який може вам у цьому допомогти.

Крім того, якщо ви хочете використовувати деякі нові функції Java 8, ви можете зробити це так:

List<String> yourList = new ArrayList<String>();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());

Наприклад, у мене є клас Person: ім'я струни, int age ==> конструктор new Person (ім'я, вік)

import java.util.Collections;
import java.util.ArrayList;
import java.util.Arrays;


public void main(String[] args){
    Person ibrahima=new Person("Timera",40);
    Person toto=new Person("Toto",35);
    Person alex=new Person("Alex",50);
    ArrayList<Person> myList=new ArrayList<Person>
    Collections.sort(myList, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            // return p1.age+"".compareTo(p2.age+""); //sort by age
            return p1.name.compareTo(p2.name); // if you want to short by name
        }
    });
    System.out.println(myList.toString());
    //[Person [name=Alex, age=50], Person [name=Timera, age=40], Person [name=Toto, age=35]]
    Collections.reverse(myList);
    System.out.println(myList.toString());
    //[Person [name=Toto, age=35], Person [name=Timera, age=40], Person [name=Alex, age=50]]

}

У JAVA 8 зараз значно легше.

List<String> alphaNumbers = Arrays.asList("one", "two", "three", "four");
List<String> alphaNumbersUpperCase = alphaNumbers.stream()
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]

- Для зворотного використання це

.sorted(Comparator.reverseOrder())

Ви можете використовувати так

ArrayList<Group> groupList = new ArrayList<>();
Collections.sort(groupList, Collections.reverseOrder());
Collections.reverse(groupList);

За допомогою Eclipse Collections ви можете створити примітивний подвійний список, сортувати його та повернути назад, щоб привести його у порядку зменшення. Такий підхід дозволить уникнути боксу для пар.

MutableDoubleList doubleList =
    DoubleLists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis().reverseThis();
doubleList.each(System.out::println);

Якщо ви хочете List<Double>, тоді працює наступне.

List<Double> objectList =
    Lists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis(Collections.reverseOrder());
objectList.forEach(System.out::println);

Якщо ви хочете зберегти тип як ArrayList<Double>, ви можете ініціалізувати і сортувати список за допомогою ArrayListIterateкласу утиліти наступним чином:

ArrayList<Double> arrayList =
    ArrayListIterate.sortThis(
            new ArrayList<>(objectList), Collections.reverseOrder());
arrayList.forEach(System.out::println);

Примітка. Я є членом колекції Eclipse .

Наступний рядок повинен робити товстий

testList.sort(Collections.reverseOrder());