Android-java- Cara mengurutkan daftar objek dengan nilai tertentu di dalam objek


112

Saya mencoba memilah-milah daftar larik objek dengan nilai tertentu di dalam objek. Pendekatan apa yang terbaik untuk melakukan hal seperti itu. Haruskah saya menggunakan Collections.sort () dengan semacam pembanding?

Saya mencoba mengurutkan daftar objek dengan nilai float yang mereka pegang di salah satu variabel.

EDIT: Inilah yang saya miliki sejauh ini:

public class CustomComparator implements Comparator<Marker> {
    @Override
    public int compare(Mark o1, Mark o2) {
        return o1.getDistance().compareTo(o2.getDistance());
    }
}

status kesalahan: Tidak dapat memanggil bandingkanTo (double) pada tipe primitif ganda.

Apakah karena pembanding tidak bisa mengembalikan apapun selain tipe tertentu?


2
"Haruskah saya menggunakan Collections.sort () dengan semacam pembanding?" Ya, sepertinya ide yang bagus
Kennet

Saya tidak tahu apakah itu penting tetapi jumlah objek dalam daftar akan setinggi 80. Itulah mengapa saya agak bingung menggunakan pembanding jika itu cara yang harus dilakukan karena hanya membandingkan dua nilai sekaligus.
James andresakis

Begitulah cara kerja penyortiran. Pertama tambahkan satu item ke daftar. Saat menambahkan berikutnya; haruskah ini pergi sebelum atau sesudah saat ini dalam daftar. Saat menambahkan item ketiga bandingkan dengan item pertama dalam daftar, jika setelah kemudian bandingkan dengan item berikutnya. Dan seterusnya.
Kennet

Jawaban:


98

Anda harus menggunakan Comparable dan bukan Comparator jika pengurutan default adalah yang Anda cari.

Lihat di sini, ini mungkin bisa membantu - Kapan kelas harus Sebanding dan / atau Pembanding?

Coba ini -

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TestSort {

    public static void main(String args[]){

        ToSort toSort1 = new ToSort(new Float(3), "3");
        ToSort toSort2 = new ToSort(new Float(6), "6");
        ToSort toSort3 = new ToSort(new Float(9), "9");
        ToSort toSort4 = new ToSort(new Float(1), "1");
        ToSort toSort5 = new ToSort(new Float(5), "5");
        ToSort toSort6 = new ToSort(new Float(0), "0");
        ToSort toSort7 = new ToSort(new Float(3), "3");
        ToSort toSort8 = new ToSort(new Float(-3), "-3");

        List<ToSort> sortList = new ArrayList<ToSort>();
        sortList.add(toSort1);
        sortList.add(toSort2);
        sortList.add(toSort3);
        sortList.add(toSort4);
        sortList.add(toSort5);
        sortList.add(toSort6);
        sortList.add(toSort7);
        sortList.add(toSort8);

        Collections.sort(sortList);

        for(ToSort toSort : sortList){
            System.out.println(toSort.toString());
        }
    }

}

public class ToSort implements Comparable<ToSort> {

    private Float val;
    private String id;

    public ToSort(Float val, String id){
        this.val = val;
        this.id = id;
    }

    @Override
    public int compareTo(ToSort f) {

        if (val.floatValue() > f.val.floatValue()) {
            return 1;
        }
        else if (val.floatValue() <  f.val.floatValue()) {
            return -1;
        }
        else {
            return 0;
        }

    }

    @Override
    public String toString(){
        return this.id;
    }
}

Hei terima kasih untuk tautannya :) Saya bolak-balik dari satu bahasa ke bahasa berikutnya jadi saya selalu melewatkan sesuatu: p Anda tahu bagaimana kelanjutannya ...... jack of all trade but a master of none lol
James andresakis

365

Ikuti kode ini untuk mengurutkan ArrayList apa pun

Collections.sort(myList, new Comparator<EmployeeClass>(){
    public int compare(EmployeeClass obj1, EmployeeClass obj2) {
        // ## Ascending order
        return obj1.firstName.compareToIgnoreCase(obj2.firstName); // To compare string values
        // return Integer.valueOf(obj1.empId).compareTo(Integer.valueOf(obj2.empId)); // To compare integer values

        // ## Descending order
        // return obj2.firstName.compareToIgnoreCase(obj1.firstName); // To compare string values
        // return Integer.valueOf(obj2.empId).compareTo(Integer.valueOf(obj1.empId)); // To compare integer values
        }
    });

16
Ini harus menjadi jawaban teratas!
John Smith

3
jawaban sederhana & hebat, pujian bro :)
Sadashiv

1
Sederhana dan kecil .. Terima kasih!
Temui Vora

1
Ini sepertinya sangat bersih. Terima kasih. Dan Satu plus untuk tip yang diberikan.
Anurag

2
Bekerja hanya untuk API 24 ke atas
Themelis

42

Saya pikir ini akan membantu Anda lebih baik

Person p = new Person("Bruce", "Willis");
Person p1  = new Person("Tom", "Hanks");
Person p2 = new Person("Nicolas", "Cage");
Person p3 = new Person("John", "Travolta");

ArrayList<Person> list = new ArrayList<Person>();
list.add(p);
list.add(p1);
list.add(p2);
list.add(p3);

Collections.sort(list, new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        Person p1 = (Person) o1;
        Person p2 = (Person) o2;
        return p1.getFirstName().compareToIgnoreCase(p2.getFirstName());
    }
});

24

Sekarang tidak perlu Tinju (yaitu tidak perlu Membuat OBJECTmenggunakan operator baru, gunakan valueOf insted with CompareTo of Collections.Sort ..)

1) Untuk urutan naik

Collections.sort(temp, new Comparator<XYZBean>() 
{
     @Override
     public int compare(XYZBean lhs, XYZBean rhs) {

       return Integer.valueOf(lhs.getDistance()).compareTo(rhs.getDistance());
      }
 });

1) Untuk pesanan Menurun

Collections.sort(temp, new Comparator<XYZBean>() 
{
     @Override
     public int compare(XYZBean lhs, XYZBean rhs) {

       return Integer.valueOf(rhs.getDistance()).compareTo(lhs.getDistance());
      }
 });

2

"Android-java" di sini sama sekali tidak berbeda dari "java normal", jadi ya Collections.sort()akan menjadi pendekatan yang baik.


1
Tapi bagaimana cara membuatnya mengurutkan berdasarkan nilai di dalam objek. Itulah yang membuatku terjebak.
James andresakis

2
public class DateComparator implements Comparator<Marker> {
    @Override
    public int compare(Mark lhs, Mark rhs) {
        Double distance = Double.valueOf(lhs.getDistance());
        Double distance1 = Double.valueOf(rhs.getDistance());
        if (distance.compareTo(distance1) < 0) {
            return -1;
        } else if (distance.compareTo(distance1) > 0) {
            return 1;
        } else {
            return 0;
        }
    }
}

ArrayList(Marker) arraylist;

Cara Penggunaan:

Collections.sort(arraylist, new DateComparator());

2

Anda dapat membandingkan dua String dengan menggunakan ini.

Collections.sort(contactsList, new Comparator<ContactsData>() {

                    @Override
                    public int compare(ContactsData lhs, ContactsData rhs) {

                        char l = Character.toUpperCase(lhs.name.charAt(0));

                        if (l < 'A' || l > 'Z')

                            l += 'Z';

                        char r = Character.toUpperCase(rhs.name.charAt(0));

                        if (r < 'A' || r > 'Z')

                            r += 'Z';

                        String s1 = l + lhs.name.substring(1);

                        String s2 = r + rhs.name.substring(1);

                        return s1.compareTo(s2);

                    }

                });

Dan Sekarang buat Kelas ContactData.

public class ContactsData {

public String name;
public String id;
public String email;
public String avatar; 
public String connection_type;
public String thumb;
public String small;
public String first_name;
public String last_name;
public String no_of_user;
public int grpIndex;

public ContactsData(String name, String id, String email, String avatar, String connection_type)
{
    this.name = name;
    this.id = id;
    this.email = email;
    this.avatar = avatar;
    this.connection_type = connection_type;

}
}

Berikut contactsList:

public static ArrayList<ContactsData> contactsList = new ArrayList<ContactsData>();

1

Baik make a Comparatoryang dapat membandingkan objek Anda, atau jika semuanya adalah instance dari kelas yang sama, Anda dapat membuat kelas tersebut diimplementasikan Comparable. Anda kemudian dapat menggunakan Collections.sort () untuk melakukan penyortiran sebenarnya.


Saya melanjutkan dan mengimplementasikan Comparable di kelas saya tetapi dan membuat metode untuk memanggil sort pada daftar ketika saya perlu memilahnya tetapi bagaimana cara mengurutkan berdasarkan nilai dengan objek?
James andresakis

Metode- compareTo()adalah tempat Anda melakukan perbandingan. Sedikit googling memberikan beberapa contoh mendetail tentang cara menggunakannya, berikut ini salah satunya: javadeveloper.co.in/java-example/java-comparable-example.html
Jave

Saya menyiapkan metode yang mirip dengan contoh namun saya mendapatkan kesalahan yang menyatakan saya tidak dapat menggunakan bandingkanTo pada pemeran ganda. Sepertinya untuk alasan apa pun, apa yang saya lakukan tidak disukai. Tidak dapat memanggil bandingkanTo (double) pada tipe primitif ganda. Saya akan menambahkan kode saya di atas untuk menunjukkan apa yang saya maksud
James andresakis

1

Kelas Model:

public class ToDoModel implements Comparable<ToDoModel> {
    private String id;
    private Date taskDate;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Date getTaskDate() {
        return taskDate;
    }

    public void setTaskDate(Date taskDate) {
        this.taskDate = taskDate;
    }

    @Override
    public int compareTo(ToDoModel another) {
        return getTaskDate().compareTo(another.getTaskDate());  
    }
}

Sekarang atur data di ArrayList

for (int i = 0; i < your_array_length; i++) {
    ToDoModel tm = new ToDoModel();
    tm.setId(your_id);
    tm.setTaskDate(your_date);
    mArrayList.add(tm);
}

Sekarang Sortir ArrayList

Collections.sort(toDoList);

Ringkasan: Ini akan mengurutkan data Anda juga


1

Untuk Kotlin , Anda dapat menggunakan fungsi ini

fun sortList(list: List<YourCustomPOJOClass?>) {

    //descending
    Collections.sort(
        list
    ) { o1, o2 -> Integer.valueOf(o1!!.intValueXYZ!!).compareTo(o2!!.intValueXYZ!!) }

//    //ascending
//    Collections.sort(
//        list
//    ) { o1, o2 -> Integer.valueOf(o2!!.intValueXYZ!!).compareTo(o1!!.intValueXYZ!!) }
}

dan sebut saja di Anda activityatau fragmentoleh

sortList(list)

0

Saya memiliki listview yang menunjukkan Informasi tentang semua klien. Saya mengurutkan nama klien menggunakan kelas pembanding kustom ini. Mereka memiliki beberapa rahasia ekstra selain huruf Inggris yang saya kelola dengan setStrength (Collator.SECONDARY)

 public class CustomNameComparator implements Comparator<ClientInfo> {
        @Override

    public int compare(ClientInfo o1, ClientInfo o2) { 

        Locale locale=Locale.getDefault();
        Collator collator = Collator.getInstance(locale);
        collator.setStrength(Collator.SECONDARY);
        return collator.compare(o1.title, o2.title);

    }
}


PRIMARY strength: Typically, this is used to denote differences between base characters (for example, "a" < "b"). It is the strongest difference. For example, dictionaries are divided into different sections by base character. 
SECONDARY strength: Accents in the characters are considered secondary differences (for example, "as" < "às" < "at"). Other differences between letters can also be considered secondary differences, depending on the language. A secondary difference is ignored when there is a primary difference anywhere in the strings. 
TERTIARY strength: Upper and lower case differences in characters are distinguished at tertiary strength (for example, "ao" < "Ao" < "aò"). In addition, a variant of a letter differs from the base form on the tertiary strength (such as "A" and "Ⓐ"). Another example is the difference between large and small Kana. A tertiary difference is ignored when there is a primary or secondary difference anywhere in the strings. 
IDENTICAL strength: When all other strengths are equal, the IDENTICAL strength is used as a tiebreaker. The Unicode code point values of the NFD form of each string are compared, just in case there is no difference. For example, Hebrew cantellation marks are only distinguished at this strength. This strength should be used sparingly, as only code point value differences between two strings are an extremely rare occurrence. Using this strength substantially decreases the performance for both comparison and collation key generation APIs. This strength also increases the size of the collation key. 

**Here is a another way to make a rule base sorting if u need it just sharing**

/*      String rules="< å,Å< ä,Ä< a,A< b,B< c,C< d,D< é< e,E< f,F< g,G< h,H< ï< i,I"+"< j,J< k,K< l,L< m,M< n,N< ö,Ö< o,O< p,P< q,Q< r,R"+"< s,S< t,T< ü< u,U< v,V< w,W< x,X< y,Y< z,Z";
        RuleBasedCollator rbc = null;
        try {
            rbc = new RuleBasedCollator(rules);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String myTitles[]={o1.title,o2.title};
        Collections.sort(Arrays.asList(myTitles), rbc);*/

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.