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

Ответ 1

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

Это будет делать то, что вы хотите. Не забудьте импортировать Collections хотя!

Вот документация для Collections.

Ответ 2

По убыванию:

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

Ответ 3

Использовать метод java.util.Collections class, i.e

Collections.sort(list)

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

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

см. коллекции api

Ответ 4

Для вашего примера, это сделает волшебство в 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.

Ответ 5

Используя 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);

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

Ответ 6

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

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

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

Ответ 7

Вы можете использовать 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), так как теперь список содержит объекты типа Comparable и может быть отсортирован. Порядок зависит от метода compareTo. Подробнее см. https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html.

Ответ 8

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

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

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

Ответ 9

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

    }
}

Ответ 10

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

Ответ 11

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

import java.util.Collections;

| = > Порядок сортировки Asc:

Collections.sort(NamAryVar);

| = > Сортировка Dsc Order:

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

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

Collections.reverse(NamAryVar);

Ответ 12

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

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

Ответ 13

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

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

Ответ 14

Например, у меня есть класс Person: String name, int age == > Constructor 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]]

}

Ответ 15

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

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

Ответ 16

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

Ответ 17

С 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.

Ответ 18

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

testList.sort(Collections.reverseOrder());

Ответ 19

Просто используйте функцию сортировки по умолчанию или по умолчанию.

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