ArrayList를 정렬하는 방법?

Java에 Doubles List가 있고 내림차순으로 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 .

내림차순 :

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

java.util.Collections 클래스 의 util 메소드를 사용하십시오.

Collections.sort(list)

사실, 커스텀 객체를 정렬하고 싶다면

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

컬렉션 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 인터페이스에는 구현할 단일 메소드 만 있기 때문에 람다를 사용할 수 있으므로 VM이 구현중인 메소드를 추론 할 수 있습니다. 매개 변수의 유형을 유추 할 수 있으므로 설명 할 필요가 없습니다 (예 : (a, b)대신 (Double a, Double b). 람다 본문에는 한 줄만 있고 메서드는 값을 반환 할 것으로 예상되므로, return유추 및 중괄호 필요하지 않습니다.

Java8에는 List 인터페이스에 기본 정렬 방법이 있는데,이를 통해 Comparator를 제공하는 경우 컬렉션을 정렬 할 수 있습니다. 다음과 같이 질문의 예를 쉽게 정렬 할 수 있습니다.

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

참고 : 람다의 args는 Double로 전달되면 스왑됩니다.

포함 된 요소가 있는지 Collections.sort(list)정렬 하는 데 사용할 수 있습니다 . 그렇지 않으면 다음과 같이 해당 인터페이스를 구현하는 것이 좋습니다.listlistComparable

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.sortComparator정렬 논리를 정의 하는의 인스턴스를 전달할 수 있습니다 . 대신 자연 순서로 목록을 정렬 한 다음 역전의 그래서, 하나는 간단하게 전달할 수 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;

    }
}

다음은 일반적인 경우를 다루는 짧은 치트 시트입니다.

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

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

| * | 리스트 정렬 :

import java.util.Collections;

| => 오름차순 정렬 :

Collections.sort(NamAryVar);

| => 정렬 Dsc 순서 :

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

| * | List의 순서를 반대로 바꿉니다.

Collections.reverse(NamAryVar);

당신은 이렇게 할 수 있습니다 :

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

Collection에는 기본 Comparator가있어 도움을 줄 수 있습니다.

또한 Java 8의 새로운 기능을 사용하려면 다음과 같이하십시오.

List<String> yourList = new ArrayList<String>();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());

예를 들어 Person 클래스가 있습니다 : String name, int age ==> Constructor 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]]

}

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

당신은 그렇게 사용할 수 있습니다

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

함께 이클립스 컬렉션 당신은 원시 더블 목록을 작성을 분류하고 내림차순으로 넣어 그것을 반대 할 수있다. 이 방법은 복식을 피하는 것입니다.

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 Collections 의 커미터입니다 .

다음 줄은 두껍게해야합니다.

testList.sort(Collections.reverseOrder());