วิธีจัดเรียง ArrayList ได้อย่างไร

ฉันมี List of doubles ใน 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นี่เป็นวิธีการใช้

Descending:

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 class เช่น

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

การใช้ lambdas (Java8) และการลอกมันลงไปจนแทบไม่ได้ใช้ไวยากรณ์ (JVM จะอนุมานมากมายในกรณีนี้) คุณจะได้รับ:

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

รุ่น verbose เพิ่มเติม:

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

Collections.sort(testList, comp);

การใช้แลมบ์ดานั้นเป็นไปได้เนื่องจากอินเตอร์เฟสตัวเปรียบเทียบมีเพียงวิธีเดียวในการนำไปใช้ดังนั้น VM สามารถอนุมานได้ว่าวิธีการใดที่ใช้ เนื่องจากประเภทของ params สามารถอนุมานได้จึงไม่จำเป็นต้องระบุ (เช่น(a, b)แทน(Double a, Double b)และเนื่องจากตัวแลมบ์ดามีเพียงบรรทัดเดียวและวิธีการคาดว่าจะคืนค่าreturnจะถูกอนุมานและวงเล็บ ไม่จำเป็น

ด้วย Java8 จะมีวิธีการเรียงลำดับเริ่มต้นในส่วนติดต่อรายการที่จะช่วยให้คุณเรียงลำดับคอลเลกชันได้หากคุณมีตัวเปรียบเทียบ คุณสามารถจัดเรียงตัวอย่างในคำถามได้ง่าย ๆ ดังนี้:

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

หมายเหตุ: args ในแลมบ์ดาจะถูกสลับเมื่อผ่านไปยัง Double.compare เพื่อให้แน่ใจว่าเรียงลำดับจากมากไปน้อย

คุณสามารถใช้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)ในขณะนี้รายการมีวัตถุประเภทเปรียบเทียบและสามารถเรียงลำดับ สั่งซื้อขึ้นอยู่กับcompareToวิธีการ ตรวจสอบhttps://docs.oracle.com/javase/tutorial/collections/interfaces/order.htmlนี้เพื่อรับข้อมูลรายละเอียดเพิ่มเติม

Collections.sortช่วยให้คุณผ่านตัวอย่างของการComparatorที่กำหนดตรรกะการเรียงลำดับ ดังนั้นแทนที่จะเรียงลำดับรายการตามลำดับธรรมชาติแล้วย้อนกลับรายการเราสามารถผ่าน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;

| => เรียงลำดับ Asc:

Collections.sort(NamAryVar);

| => เรียงลำดับ Dsc:

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

ตัวอย่างเช่นฉันมีคลาส Person: ชื่อ String, 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]]

}

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

ด้วย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);

หากคุณต้องการ a 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);

หมายเหตุ: ผม committer สำหรับEclipse คอลเลกชัน

บรรทัดต่อไปนี้ควรทำหนา

testList.sort(Collections.reverseOrder());