Как сортировать ArrayList?

в порядке убывания:

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

использовать util метод java.утиль.Коллекции класс, т. е.

Collections.sort(list)

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

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

посмотреть API коллекций

для вашего примера, это будет делать магию в Java 8

testList.sort();

но если вы хотите сортировать по некоторым полям объекта, который вы сортируете, вы можете сделать это легко:

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

или

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

или

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

источники: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);

использование лямбда возможно, потому что интерфейс компаратора имеет только один метод для реализации, поэтому виртуальная машина может определить, какой метод реализуется. Поскольку типы параметров могут быть выведены, их не нужно указывать (т. е. (a, b) вместо (Double a, Double b). И поскольку лямбда-тело имеет только одну строку, и ожидается, что метод вернет значение,return выводится и фигурные скобки не нужны.

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

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

Примечание: args в лямбда меняются местами при передаче в Double.сравните, чтобы убедиться, что сортировка идет по убыванию

можно использовать 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;

}
}

Если вы используете 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);

можно сделать так:

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

|*| сортировка списка :

import java.util.Collections;

/ => Порядок Сортировки Asc:

Collections.sort(NamAryVar);

/ => Порядок Сортировки Dsc:

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

---

|* / обратный порядок списка:

Collections.reverse(NamAryVar);

вы можете использовать вот так

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

например у меня есть класс Person: String name, int age == > конструктор new Person (name,age)

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]]

}

С Коллекции Eclipse вы можете создать примитивный двойной список, отсортировать его, а затем отменить его, чтобы поместить его в порядке убывания. Такой подход позволит избежать бокса в парном разряде.

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.

в 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]

-- для обратного использования это

.сортировка(компаратор.reverseOrder())

следующая строка должна делать толстые

testList.sort(Collections.reverseOrder());

просто используйте функцию loop или sort() по умолчанию.

for(int n = 0; n<= arrList[i]; n++){
   i