У меня есть список двоичных чисел в 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.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.util.Collections, т.е.
Collections.sort(list)
На самом деле, если вы хотите отсортировать пользовательский объект, вы можете использовать
Collections.sort(List<T> list, Comparator<? super T> c)
см. collections 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);
Использование лямбда-возможно потому, что интерфейс Comparator имеет только один метод для осуществления, так что ВМ может определить, какой метод реализации. Поскольку типы параметров могут быть выведены, они не'т должны быть указаны (т. е.(А, B)вместо
(двойной, двойной б)`. И поскольку тела лямбда имеет только одну линию, и метод должен вернуть значение, "возврат" выводится и брекеты не'т необходимости.
С Java8 есть способ сортировки по умолчанию на интерфейс список, который позволит вам упорядочить коллекцию, если вы предоставляете компаратор. Вы можете легко сортировать пример в вопрос следующим образом:
testList.sort((a, b) -> Double.compare(b, a));
Примечание: аргументы в лямбде меняются местами, когда перешел в дубль.сравнить, чтобы убедиться в сортировке по убыванию
Вы можете использовать коллекции.сортировать(список)сортировать
списокесли
списоксодержит
сопоставимых` элементов. В противном случае я бы рекомендовал вам реализовать этот интерфейс, как здесь:
public class Circle implements Comparable<Circle> {}
и конечно же предоставлять свои собственные реализации `метод compareto метод, как здесь:
@Override
public int compareTo(Circle another) {
if (this.getD()<another.getD()){
return -1;
}else{
return 1;
}
}
И тогда вы можете снова использовать акварель.сортировать(список) теперь список содержит объекты сопоставимого вида и могут быть отсортированы. Порядок зависит от `метод compareto метод. Проверить это https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html для более подробной информации.
Коллекции.сортпозволяет передать экземпляр
компаратор, который определяет логику сортировки. Поэтому вместо того, чтобы сортировать список в алфавитном порядке, а затем перевернуть ее, можно просто пройти коллекций.reverseOrder (), чтобы
сортировка` для того, чтобы отсортировать список в обратном порядке:
// 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 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);
|=> порядок сортировки ДСК :
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());
Вот небольшая шпаргалка, которая охватывает типичные случаи:
// 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))
Вы можете использовать подобное
ArrayList<Group> groupList = new ArrayList<>();
Collections.sort(groupList, Collections.reverseOrder());
Collections.reverse(groupList);
В 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())
Например у меня есть класс 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<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]]
}
Следующие строки должны сделать гуще
testList.sort(Collections.reverseOrder());
С коллекциях затмение можно создать примитивный двойной список, отсортировать его, а затем повернуть его вспять, чтобы положить ее в порядке убывания. Этот подход позволит избежать бокс в парном разряде.
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> 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<Double> arrayList =
ArrayListIterate.sortThis(
new ArrayList<>(objectList), Collections.reverseOrder());
arrayList.forEach(System.out::println);
Примечание: Я являюсь активным участником коллекциях затмение.