ArrayLists'i bir Karşılaştırıcı kullanarak sıralama hakkında okudum, ancak compareTobazı örneklerde insanların bazı araştırmalara göre Dizeler için bir yöntem olduğu kullanılan tüm örneklerde okudum .

Bir ArrayList özel nesnelerin özelliklerinden birine göre sıralamak istedim: bir Date nesnesi ( getStartDay()). Normalde onları karşılaştırmak, item1.getStartDate().before(item2.getStartDate())bu yüzden şöyle bir şey yazıp yazamayacağımı merak ediyordum:

public class CustomComparator {
    public boolean compare(Object object1, Object object2) {
        return object1.getStartDate().before(object2.getStartDate());
    }
}

public class RandomName {
    ...
    Collections.sort(Database.arrayList, new CustomComparator);
    ...
}

Yana Dateuygular Comparable, bir var compareTogibi yöntemini Stringyapar.

Böylece özeliniz Comparatorşöyle görünebilir:

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

compare()Yöntemi bir dönmeli intdoğrudan bir dönüş olamazdı bu yüzden, booleanyine planladıklarını gibi.

Sıralama kodunuz yazdığınız gibi olacaktır:

Collections.sort(Database.arrayList, new CustomComparator());

Tüm bunları yazmanın biraz daha kısa bir yolu, karşılaştırıcınızı yeniden kullanmanız gerekmiyorsa, satır içi anonim bir sınıf olarak yazmaktır:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Dan beri Java-8

Artık bir kullanarak daha kısa formda son örneği yazabilir lambda ifade için Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Ve Listbir sort(Comparator)yöntemi var, böylece bunu daha da kısaltabilirsiniz:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Bu, yaygın bir deyimdir ve anahtarlı bir sınıf için bir oluşturmak için yerleşik bir yöntem vardır :ComparatorComparable

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

Bunların hepsi eşdeğer formlardır.

Doğal sıralama düzenine sahip sınıflara (örnek olarak bir sınıf Numarası) Karşılaştırılabilir arabirimi uygulamalı, doğal sıralama düzenine sahip olmayan sınıflara (örnek olarak bir sınıf Başkanı) bir Karşılaştırıcı (veya anonim bir Karşılaştırıcı) sağlanmalıdır. sınıf).

İki örnek:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Kullanımı:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});

Bir sıralamak ArrayListiçin aşağıdaki kod snippet'ini kullanabilirsiniz:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

Evet yapabilirsin. Öğeleri karşılaştırma ile iki seçenek vardır: Karşılaştırılabilir arabirim ve Karşılaştırıcı arabirimi.

Bu arabirimlerin her ikisi de farklı davranışlara izin verir. Karşılaştırılabilir, nesneyi az önce tanımladığınız gibi hareket ettirmenizi sağlar (aslında, String Karşılaştırılabilir'i uygular). İkincisi, Karşılaştırıcı, ne yapmak istediğinizi yapmanızı sağlar. Bunu şu şekilde yaparsınız:

Collections.sort(myArrayList, new MyComparator());

Bu, Collections.sort yönteminin sıralama mekanizması için karşılaştırıcınızı kullanmasına neden olur. ArrayList'teki nesneler karşılaştırılabilir uygulama yaparsa, bunun gibi bir şey yapabilirsiniz:

Collections.sort(myArrayList);

Koleksiyonları sınıf bu kullanışlı, ortak bir dizi araç içerir.

JAVA 8 lambda ifadesi

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

VEYA

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)

Java 8 ile karşılaştırıcınız için bir yöntem referansı kullanabilirsiniz:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));

Teknolojiler her gün göründüğünden, cevap zamanla değişecektir. LambdaJ'a bir göz attım ve çok ilginç görünüyor.

Bu görevleri LambdaJ ile çözmeyi deneyebilirsiniz . Burada bulabilirsiniz: http://code.google.com/p/lambdaj/

Burada bir örnek var:

Sıralı Yinelemeli

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

Lambda ile sırala

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

Tabii ki, bu tür bir güzellik performansa etki ediyor (ortalama 2 kez), ancak daha okunabilir bir kod bulabilir misiniz?

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList<Person> people;
    people = new ArrayList<Person>();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}

JAVA 8 ile en kolay yol İngilizce Alfabetik sıralama için

Sınıf Uygulaması

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

Çeşit

  Collections.sort(Your List);

İngilizce olmayan karakterler içeren alfabe için sıralamak isterseniz Yerel Ayar'ı kullanabilirsiniz ... Kodun altında Türkçe karakter sıralaması kullanın ...

Sınıf Uygulaması

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

Çeşit

Collections.sort(your array list,new NewspaperClass());

İşlev ve yöntem referansı

Collections.sortYöntem sıralayabilir Listbir kullanarak Comparatorgeçmek. Bu Comparatorkullanılarak uygulanabilir Comparator.comparingbir geçebilir yöntem yöntemi referans gerektiğinde Function. Neyse ki, gerçek kod bu açıklamadan çok daha basit ve kısadır.

Java 8 için:

Collections.sort(list, comparing(ClassName::getName));

veya

Collections.sort(list, comparing(ClassName::getName).reversed());

Başka bir yol

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));

Bundan Java 8sonra Collections.sort()doğrudan kullanmak zorunda değiliz . Listarayüzün varsayılan bir sort()yöntemi vardır:

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());}); 

Bkz. Http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html .

Java 8 Lambda sıralamayı kısaltır.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

Özel sınıfınızdaki herhangi bir özelliği sıralamak için Fasulye Karşılaştırıcısını kullanabilirsiniz .

Evet, bu örneğin mümkündür Bu yanıt özelliğiyle Bir çeşit vsınıfınIndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

Burada fark ederseniz, anonim bir iç sınıf (kapanışlar için Java) oluşturur ve doğrudan sortsınıfın yöntemine geçiririmArrays

Nesneniz de uygulayabilir Comparable(Java'da String ve çekirdek kitaplıkların çoğu bunu yapar), ancak bu kendi kendine sınıfın "doğal sıralama düzenini" tanımlar ve yenilerini eklemenize izin vermez.

Bu cevapların tümü karşılaştırılabilir uygulamak veya yardımcı karşılaştırılabilir bir arayüze sahip olmak için altta yatan sınıfa (Object) bağlı değilse en çok buldum.

Benim çözümümle değil! Aşağıdaki kod, dize adlarını bilerek nesnenin alanını karşılaştırmanıza olanak tanır. Adı kullanmamak için kolayca değiştirebilirsiniz, ancak daha sonra açığa çıkarmanız veya karşılaştırmak istediğiniz Nesneler'den birini oluşturmanız gerekir.

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}

Sen Guava Sipariş deneyebilirsiniz :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);

Java 8 kullanarak sıralayabilirsiniz

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));

Bu kod parçacıkları yararlı olabilir. Benim durumumda bir Nesne sıralamak istiyorsanız, VolumeName göre sıralamak istiyorum:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

Bu çalışıyor. Ben benim jsp kullanın.

Bu kütüphane ile burada birden fazla sütunlar üzerinde özel nesnelerin listesini sıralayabilirsiniz. Kitaplık sürüm 8.0 özelliklerini kullanır. Orada da örnek mevcuttur. İşte yapılacak bir örnek

SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
            .addField("age", true); // This (true) will sort the age descending

// Other ways to specify a property to the sorter are
//      .addField("lastName", String.class);
//      .addField("dob", Date.class, true);

// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();

// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);

2016 yılında Stuttgart Almanya'daki Java Forumunda bu sunum tutucusuna göz atabilirsiniz .

Sadece birkaç slayt Almanca kullanıyor, içeriğin% 99'u "İngilizce tabanlı" Java kaynak kodudur; sevmek

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

Burada OurCustomComparatorvarsayılan yöntemler (ve diğer ilginç fikirler) kullanılmaktadır. Gösterildiği gibi, sıralama için bazı getter yöntemini seçmek için çok özlü kodlara yol açar; ve sıralama ölçütlerinin süper basit zincirlenmesi (veya ters çevrilmesi)

Eğer java8 iseniz, başlamak için orada çok malzeme bulabilirsiniz.

1.8'den beri yeni olan, Collection.sort () yerine bir List.sort () yöntemidir, böylece mylistcontainer.sort () öğesini doğrudan çağırırsınız

List.sort () özelliğini gösteren bir kod snippet'i aşağıdadır:

List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));

// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]

// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));  
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]

Meyve sınıfı:

public class Fruit implements Comparable<Fruit>
{
    private String name;
    private String color;
    private int quantity;

    public Fruit(String name,String color,int quantity)
    { this.name = name; this.color = color; this.quantity = quantity; }

    public String getFruitName() { return name; }        
    public String getColor() { return color; }  
    public int getQuantity() { return quantity; }

    @Override public final int compareTo(Fruit f) // sorting the color
    {
        return this.color.compareTo(f.color);
    }     
    @Override public String toString()
    {   
        return (name + " is: " + color);
    }
} // end of Fruit class   

customComparator sınıfınızın kullanılabilmesi için java.util.Comparator öğesini uygulaması gerekir. ayrıca Compare () AND eşittir ()

Compare () soruyu cevaplamalıdır: Nesne 1, nesne 2'den küçük, eşit ya da büyük mü?

tam dokümanlar: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

Bu işlemi tercih ederim:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

Nesnelerin listesi adlı bir özelliğe sahipse startDate, bunu tekrar tekrar kullanın. Onları bile zincirleyebilirsiniz startDate.time.

Bunun için nesnenizin olması Comparablegerekir compareTo, yani equals, ve hashCodeuygulamasına ihtiyacınız vardır .

Evet, daha hızlı olabilir ... Ama şimdi her tür tür için yeni bir Karşılaştırıcı yapmak zorunda değilsiniz. Geliştirme zamanından tasarruf edip çalışma zamanında vazgeçebilirseniz, bununla gidebilirsiniz.

Java 8 kullanımı, Comparatorkullanarak bir satırdaComparator.comparing()

Aşağıdaki yollardan birini kullanın:

Seçenek 1:

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

Seçenek 2:

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));

Özel sınıfınız, CompareTo yönteminin uygulanmasını gerektiren "Karşılaştırılabilir" arabirimi uygulayabilir. CompareTo yönteminde, bir nesnenin diğer nesneden daha az veya daha fazla olmasının ne anlama geldiğini tanımlayabilirsiniz . Örneğin, örneğinizde şöyle görünebilir:

public class MyCustomClass implements Comparable<MyCustomClass>{

..........

 @Override
public int compareTo(MyCustomClass a) {
    if(this.getStartDate().before(a.getStartDate())){
        return -1;
    }else if(a.getStartDate().before(this.getStartDate())){
        return 1;
    }else {
        return 0;
    }
}

Negatif bir sayı gösterir , bu göre nesnenin daha küçüktür. Pozitif bir sayı gösterir , bu nesneye göre ve nesneleri eşit olduğu bir sıfır vasıtasıyla daha büyüktür.

Daha sonra bir karşılaştırıcıya beslemek zorunda kalmadan listenizi sıralamak için collections.sort (myList) kullanabilirsiniz. Bu yöntem, bir TreeSet veya TreeMap gibi sıralı toplama veri yapıları kullanırsanız, öğelerin otomatik olarak sıralanması avantajına da sahiptir.

Karşılaştırılabilir arayüz hakkında daha fazla bilgi edinmek istiyorsanız bu makaleyi kontrol edebilirsiniz (açıklama: Ben yazarım;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

Sıralamak istediğiniz (iç içe) özelliğin yalnızca String özelliği yolunuz varsa Springs PropertyComparator'ı da kullanabilirsiniz :

List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
    "property.nested.myProperty", false, true);
list.sort(propertyComparator);

Dezavantajı, bu karşılaştırıcının var olmayan veya erişilemeyen özellikleri sessizce yok sayması ve bunu karşılaştırma için null değer olarak ele almasıdır . Bu, böyle bir karşılaştırıcıyı dikkatle test etmeniz veya özellik yolunun varlığını bir şekilde doğrulamanız gerektiği anlamına gelir.

java-8 stream api'yi kullanarak aşağıdakileri sıralayabilirsiniz ArrayList:

 Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
 List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());

İnternette birçok farklı çözüm denedim, ancak benim için çalışan çözüm aşağıdaki bağlantıdan edinilebilir.

https://www.java67.com/2017/07/how-to-sort-arraylist-of-objects-using.html