Как отсортировать список 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
Mahozad
Редактировал вопрос 24-го июля 2018 в 7:23
Программирование
sorting java collections arraylist
27-го апреля 2013 в 12:48
78 просмотров
Решение
Collections.sort(testList);
Collections.reverse(testList);

Это сделает то, что вы хотите. Однако не забудьте импортировать Collections!

Здесь документация по коллекциям.

Carl Walsh
Редактировал ответ 26-го ноября 2018 в 11:59
Комментарии (10)

По убыванию:

Collections.sort(mArrayList, new Comparator() {
    @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;
    }
});
Комментарии (3)

Используйте метод util класса java.util.Collections, т.е.

Collections.sort(list)

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

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

см. collections api

Комментарии (0)

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

List 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

Jonathan Benn
Редактировал ответ 5-го ноября 2018 в 11:55
Комментарии (11)

Используя лямбда-выражения (Java8), и обнажая его вниз, чтобы чуть-чуть синтаксис (JVM будет вывести много в этом случае), вы получаете:

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

Более подробная версия:

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

Collections.sort(testList, comp);

Использование лямбда-возможно потому, что интерфейс Comparator имеет только один метод для осуществления, так что ВМ может определить, какой метод реализации. Поскольку типы параметров могут быть выведены, они не'т должны быть указаны (т. е.(А, B)вместо(двойной, двойной б)`. И поскольку тела лямбда имеет только одну линию, и метод должен вернуть значение, "возврат" выводится и брекеты не'т необходимости.

Комментарии (2)

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

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

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

Комментарии (1)

Вы можете использовать коллекции.сортировать(список)сортироватьсписокеслисписоксодержитсопоставимых` элементов. В противном случае я бы рекомендовал вам реализовать этот интерфейс, как здесь:

public class Circle implements Comparable {}

и конечно же предоставлять свои собственные реализации `метод compareto метод, как здесь:


@Override
    public int compareTo(Circle another) {
        if (this.getD()
Комментарии (0)

Коллекции.сортпозволяет передать экземпляркомпаратор, который определяет логику сортировки. Поэтому вместо того, чтобы сортировать список в алфавитном порядке, а затем перевернуть ее, можно просто пройти коллекций.reverseOrder (), чтобысортировка` для того, чтобы отсортировать список в обратном порядке:

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

Как упомянул @Marco13, помимо того, что более идиоматические (и, возможно, более эффективным), используя обратный порядок компаратора гарантирует, что вроде как стабильно (это означает, что порядок элементов не изменяются, когда они равны по компаратору, а вспять изменит порядок)

Комментарии (0)
 
//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 synchronizedList = Collections.synchronizedList(new ArrayList());
        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 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;

    }
}
Hits sapra
Редактировал ответ 3-го января 2019 в 10:57
Комментарии (1)

если вы используете Java 8 ЮВ, то это может помочь.

//create a comparator object using a Lambda expression
Comparator 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);
Комментарии (1)

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

import java.util.Collections;

|=> порядок сортировки возрастанию :

Collections.sort(NamAryVar);

|=> порядок сортировки ДСК :

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

|*| Изменить порядок списка :

Collections.reverse(NamAryVar);
Комментарии (0)

Вы можете сделать как этот:

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

Коллекция имеет компаратор по умолчанию, которые могут помочь вам с этим.

Также, если вы хотите использовать некоторые Java 8 новые функции, вы можете сделать так:

List yourList = new ArrayList();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());
svarog
Редактировал ответ 30-го июля 2019 в 8:08
Комментарии (0)

Вот небольшая шпаргалка, которая охватывает типичные случаи:

// 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))
Комментарии (0)

Вы можете использовать подобное 

ArrayList groupList = new ArrayList();
Collections.sort(groupList, Collections.reverseOrder());
Collections.reverse(groupList);
svarog
Редактировал ответ 30-го июля 2019 в 8:08
Комментарии (0)

В Java 8 теперь его очень легко.

List alphaNumbers = Arrays.asList("one", "two", "three", "four");
List alphaNumbersUpperCase = alphaNumbers.stream()
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]
  • Для реверсного использования этого
.sorted(Comparator.reverseOrder())
IntelliJ Amiya
Редактировал ответ 17-го января 2019 в 1:36
Комментарии (0)

Например у меня есть класс Person: имя string, int и возраст ==>конструктор нового человека(имя,возраст) 

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 myList=new ArrayList
    Collections.sort(myList, new Comparator() {
        @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]]

}
Комментарии (1)

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

testList.sort(Collections.reverseOrder());
Комментарии (0)

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

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 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 и Л;двойной>, вы можете инициализировать и отсортировать список, используяArrayListIterate` служебный класс следующим образом:

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

Примечание: Я являюсь активным участником коллекциях затмение.

Комментарии (0)