Hoe een ArrayList sorteren?

Ik heb een lijst met doubles in Java en ik wil ArrayList in aflopende volgorde sorteren.

Invoer ArrayList is als volgt:

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

De uitvoer zou zo moeten zijn

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

Antwoord 1, autoriteit 100%

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

Dat zal doen wat je wilt. Vergeet echter niet om Collectionste importeren!

Hier is de documentatie voor Collections.


Antwoord 2, autoriteit 26%

Aflopend:

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

Antwoord 3, autoriteit 20%

Voor jouw voorbeeld zal dit de magie doen in Java 8

List<Double> testList = new ArrayList();
testList.sort(Comparator.naturalOrder());

Maar als u wilt sorteren op een aantal van de velden van het object, kunt u het eenvoudig doen door:

testList.sort(Comparator.comparing(ClassName::getFieldName));

of

testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());

of

testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());

Bronnen: https://docs.Or. com / javase / 8 / docs / api / java / util / comparator.html


Antwoord 4, Autoriteit 16%

Gebruik UTIL-methode van java.util.collections Klasse, dwz

Collections.sort(list)

In feite, als u aangepast object wilt sorteren, kunt u

gebruiken

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

Zie Collecties API


Antwoord 5, Autoriteit 10%

Gebruik Lambdas (Java8) en strip het naar de barest van Syntax (de JVM zal Plenty in dit geval afleiden), krijg je:

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

Een meer uitgebreide versie:

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

Het gebruik van een lambda is mogelijk omdat de Comparator interface slechts één methode uit te voeren, zodat de VM kan afleiden welke werkwijze implementeert. Aangezien de types van de params kan worden afgeleid, hoeven ze niet te worden vermeld (dwz (a, b)in plaats van (Double a, Double b). En aangezien de lambda lichaam slechts een enkele lijn, en wordt verwacht dat de werkwijze op een waarde returnwordt afgeleid terugkeren en de beugels zijn niet nodig.


Antwoord 6, Autoriteit 5%

Met Java8 is er een standaard soort methode op de interface List die u zal toestaan ​​om de collectie te sorteren als u een Comparator. U kunt eenvoudig sorteren het voorbeeld in de vraag als volgt:

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

Opmerking: de argumenten in de lambda worden gewisseld als doorgegeven aan Double.compare om de sorteervolgorde te zorgen dat aflopende


Antwoord 7, Autoriteit 5%

U kunt Collections.sort(list)sort listals je listbevat Comparableelementen. Anders zou ik raden u aan de uitvoering van dat interface zoals hier:

public class Circle implements Comparable<Circle> {}

en natuurlijk voorzien van uw eigen realisatie van compareTomethode zoals hier:

@Override
    public int compareTo(Circle another) {
        if (this.getD()<another.getD()){
            return -1;
        }else{
            return 1;
        }
    }

En dan kun je weer Colection.sort(list)gebruiken, aangezien lijst nu objecten van het vergelijkbare type bevat en kan worden gesorteerd. De volgorde is afhankelijk van de compareTo-methode. Controleer deze https://docs.oracle.com/javase/tutorial/collections/interfaces/order. htmlvoor meer gedetailleerde informatie.


Antwoord 8, autoriteit 2%

Hier is een korte cheatsheet die typische gevallen behandelt:

import static java.util.Comparator.comparing;
// 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));

Antwoord 9, autoriteit 2%

Met

Collections.sortkunt u een instantie van een Comparatordoorgeven die de sorteerlogica definieert. Dus in plaats van de lijst in natuurlijke volgorde te sorteren en vervolgens om te draaien, kunt u eenvoudig Collections.reverseOrder()doorgeven aan sortom de lijst in omgekeerde volgorde te sorteren:

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

Zoals vermeld door @ Marco13, afgezien van het zijn van idiomatisch (en mogelijk efficiënter), zorgt het met behulp van de omgekeerde volgorde-comparator ervoor dat het soort stabiel is (wat betekent dat de volgorde van elementen niet wordt gewijzigd wanneer ze gelijk zijn aan de comparator, terwijl omkeer de volgorde zal veranderen)


Antwoord 10, Autoriteit 2%

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

Antwoord 11

als u Java SE 8 gebruikt, kan dit van pas komen.

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

Antwoord 12

|*| Een lijst sorteren :

import java.util.Collections;

|=> Sorteer oplopende volgorde :

Collections.sort(NamAryVar);

|=> Sorteer Dsc-volgorde:

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

|*| Keer de volgorde van de lijst om:

Collections.reverse(NamAryVar);

Antwoord 13

Je kunt het als volgt doen:

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

Collection heeft een standaard vergelijker die je daarbij kan helpen.

Als u enkele nieuwe Java 8-functies wilt gebruiken, kunt u dat ook als volgt doen:

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

Antwoord 14

Ik heb bijvoorbeeld een klasse 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]]
}

Antwoord 15

In JAVA 8 is het nu veel gemakkelijker.

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]

– Voor omgekeerd gebruik dit

.sorted(Comparator.reverseOrder())

Antwoord 16

U kunt zo gebruiken

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

Antwoord 17

Als u Object moet sorteren op basis van de ID in de Arrayclist, gebruik dan Java8-stream.

List<Person> personList = new ArrayList<>();
    List<Person> personListSorted =
                personList.stream()
                  .sorted(Comparator.comparing(Person::getPersonId))
                  .collect(Collectors.toList());

Antwoord 18

met Eclipse-collecties U kunt een primitieve dubbele lijst maken, het sorteren en vervolgens omdraaien zet het in aflopende volgorde. Deze aanpak zou het verdubbelen vermijden.

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

Als u een List<Double>, dan zou het volgende werken.

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

Als u het type wilt behouden als ArrayList<Double>, kunt u de lijst initialiseren en sorteren met behulp van de ArrayListIterateUtility Class als volgt:

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

Opmerking: ik ben een beiden voor eclipse-collecties .


Antwoord 19

De volgende regel moet de dikke

doen

testList.sort(Collections.reverseOrder());

Antwoord 20

Een alternatieve manier om een ​​lijst te bestellen, gebruikt het Collections Framework;

In dit geval met behulp van de sorteerset (de boon in de lijst moet het vergelijkbaar maken, dus dubbel is OK):

List<Double> testList;
...
SortedSet<Double> sortedSet= new TreeSet<Double>();
for(Double number: testList) {
   sortedSet.add(number);
}
orderedList=new ArrayList(sortedSet);

In het algemeen, om te bestellen door een attribuut van een boon in de lijst, plaatst u alle elementen van de lijst in een SORTEMAP, gebruik als een toets het kenmerk en ontvang vervolgens de waarden () van de SORTEMAP (het attribuut moet implementeren Vergelijkbaar):

List<Bean> testList;
...
SortedMap<AttributeType,Bean> sortedMap= new TreeMap<AttributeType, Bean>();
for(Bean bean : testList) {
   sortedMap.put(bean.getAttribute(),bean);
}
orderedList=new ArrayList(sortedMap.values());

Antwoord 21

 yearList = arrayListOf()
    for (year in 1950 until 2021) {
        yearList.add(year)
    }
   yearList.reverse()
    val list: ArrayList<String> = arrayListOf()
    for (year in yearList) {
        list.add(year.toString())
    }

Other episodes