ArrayList nasıl sıralanır?

Java çiftler listesi var ve azalan sırada ArrayList sıralamak istiyorum.

ArrayList girişi aşağıdaki gibidir:

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

Çıkışı böyle olmalı

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

İstediğini yapacak. CollectionsYine de almayı unutmayın !

İşte belgeleriCollections .

Azalan:

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 sınıfının util yöntemini kullanın , yani

Collections.sort(list)

Aslında, özel nesneyi sıralamak istiyorsanız,

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

koleksiyonları görmek api

Örneğin, bu Java 8'de sihri yapacak

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

Ancak, sıraladığınız nesnenin bazı alanlarına göre sıralamak istiyorsanız, bunu kolayca yapabilirsiniz:

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

veya

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

veya

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

Kaynaklar: https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

Lambda'ları (Java8) kullanarak ve sözdiziminin en barizine kadar soyun (JVM bu durumda bolca çıkarım yapar ):

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

Daha ayrıntılı bir sürüm:

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

Collections.sort(testList, comp);

Bir lambda kullanımı mümkündür, çünkü Karşılaştırıcı arabiriminin uygulamak için tek bir yöntemi vardır, bu nedenle VM hangi yöntemin uygulandığını çıkarabilir. Paramların türleri çıkartılabileceğinden, bunların belirtilmesine gerek yoktur (yani (a, b)bunun yerine (Double a, Double b). Ve lambda gövdesinin sadece tek bir satırı olduğundan ve yöntemin bir değer döndürmesi beklendiği için return, çıkarım ve parantezler gerekli değil.

Java8 ile Liste arabiriminde, Karşılaştırıcı sağlarsanız koleksiyonu sıralamanıza izin veren varsayılan bir sıralama yöntemi vardır. Sorudaki örneği kolayca aşağıdaki gibi sıralayabilirsiniz:

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

Not: lambda'daki args, Double'e geçtiğinde değiştirilir. Sıralamanın azalacağından emin olmak için karşılaştırın.

Sen kullanabilirsiniz Collections.sort(list)sıralamak için listsenin eğer listiçeriyor Comparableelemanları. Aksi takdirde bu arayüzü şu şekilde uygulamanızı tavsiye ederim:

public class Circle implements Comparable<Circle> {}

ve tabii ki compareToburada olduğu gibi kendi yönteminizi gerçekleştirin :

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

Ve sonra tekrar kullanabilirsiniz Colection.sort(list)gibi Liste karşılaştırılabilir tip nesneler içerir ve sıralanabilir. Sipariş compareToyönteme bağlıdır . Daha ayrıntılı bilgi için bu https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html adresini ziyaret edin .

Collections.sortComparatorsıralama mantığını tanımlayan bir örneğini iletmenize olanak tanır . Yerine doğal sırayla liste sıralama ve sonra ters Yani, biri sadece geçebilir Collections.reverseOrder()için sortters sırada sıralamak için:

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

@ Marco13 tarafından belirtildiği gibi, daha deyimsel (ve muhtemelen daha verimli) olmanın yanı sıra, ters sıra karşılaştırıcısının kullanılması, sıralamanın kararlı olmasını sağlar (yani, karşılaştırıcıya göre eşit olduğunda elemanların sırasının değişmeyeceğini, oysa tersine çevirme düzeni değiştirir)

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

    }
}

İşte tipik durumları kapsayan kısa bir hile sayfası:

// 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 kullanıyorsanız, bu yardımcı olabilir.

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

| * | Bir Listeyi Sıralama:

import java.util.Collections;

| => Artan Sıralamayı Sırala:

Collections.sort(NamAryVar);

| => Dsc Sırasını Sırala:

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

| * | Listenin sırasını ters çevirin:

Collections.reverse(NamAryVar);

Bunu şöyle yapabilirsiniz:

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

Koleksiyonda bu konuda size yardımcı olabilecek varsayılan bir Karşılaştırıcı vardır.

Ayrıca, bazı Java 8 yeni özelliklerini kullanmak istiyorsanız, bunu yapabilirsiniz:

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

Örneğin bir sınıf var Kişi: Dize adı, int age ==> Oluşturucu yeni Kişi (ad, yaş)

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'de artık çok kolay.

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]

- Tersine kullanım için

.sorted(Comparator.reverseOrder())

Böyle kullanabilirsiniz

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

Eclipse Collections ile ilkel bir çift liste oluşturabilir, sıralayabilir ve azalan düzende sıralamak için tersine çevirebilirsiniz. Bu yaklaşım iki katına boks yapmaktan kaçınır.

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

Eğer istiyorsanız List<Double>, o zaman aşağıdakiler işe yarayacaktır.

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

Türü olduğu gibi tutmak istiyorsanız ArrayList<Double>, ArrayListIterateyardımcı programı sınıfını kullanarak listeyi başlatabilir ve sıralayabilirsiniz :

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

Not: Eclipse Collections için bir komisyoncuyum .

Aşağıdaki satır kalın yapmalı

testList.sort(Collections.reverseOrder());