Как сортировать 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 коллекций

для вашего примера, это wil do the magic в 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

использование lambdas (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 существует метод сортировки по умолчанию в интерфейсе списка, который позволит вам сортировать коллекцию, если вы предоставите компаратор. Вы можете легко отсортировать пример в вопросе следующим образом:

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 позволяет передать экземпляр Comparator, который определяет логику сортировки. Поэтому вместо сортировки списка в естественном порядке, а затем его изменения, можно просто передать Collections.reverseOrder() to 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