සංසන්දකයෙකු භාවිතා කරමින් අරා ලැයිස්තු වර්ග කිරීම ගැන මම කියවූ නමුත් compareToසමහර උදාහරණ වලදී මිනිසුන් භාවිතා කළ සමහර පර්යේෂණ වලට අනුව නූල් සඳහා ක්‍රමයක් වේ.

අභිරුචි වස්තු වල එක් ගුණාංගයක් අනුව පෙළගැස්වීමට මට අවශ්‍ය විය: දිනය වස්තුව ( getStartDay()). සාමාන්‍යයෙන් මම ඒවා සංසන්දනය කරන්නේ item1.getStartDate().before(item2.getStartDate())ඒ නිසා මට කල්පනා කරමින් සිටියේ මට මෙවැනි දෙයක් ලිවිය හැකිද යන්නයි.

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

Dateක්‍රියාත්මක කරන බැවින් Comparable, එයට compareToක්‍රමවේදයක් ඇත String.

එබැවින් ඔබගේ චාරිත්රය Comparatorමේ වගේ විය හැකිය:

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

මෙම compare()ක්රමය සඳහා නැවත යුතුය intඔබ කෙලින්ම ආපසු යා නොහැකි නිසා, booleanඔබ කෙසේ හෝ කිරීමට සැලසුම් විය වගේ.

ඔබේ වර්ග කිරීමේ කේතය ඔබ ලියා ඇති ආකාරයටම වනු ඇත:

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

මේ සියල්ල ලිවීමට තරමක් කෙටි ක්‍රමයක් නම්, ඔබේ සංසන්දකය නැවත භාවිතා කිරීමට ඔබට අවශ්‍ය නොවන්නේ නම්, එය පේළිගත නිර්නාමික පන්තියක් ලෙස ලිවීම:

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

සිට java-8

ඔබ දැන් භාවිතා කරන ලද්දේ කෙටි ස්වරූපයෙන් පසුගිය උදාහරණයක් ලියන්න පුළුවන් ලැම්ඩා ප්රකාශනය සඳහා Comparator:

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

හා Listසතුව sort(Comparator)ඔබ පවා තවදුරටත් මෙම කෙටි කර ගත හැක, ඒ ක්රමය:

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

මෙය එබඳු පොදු මෝඩකමක් වන අතර යතුරක් සහිත පන්තියක් සඳහා ජනනය කිරීම සඳහා සාදන ලද ක්‍රමවේදයක් ඇත :ComparatorComparable

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

මේ සියල්ලම සමාන ආකාර වේ.

ස්වාභාවික වර්ග කිරීමේ අනුපිළිවෙලක් ඇති පංති (උදාහරණයක් ලෙස පන්ති අංකයක්) සංසන්දනාත්මක අතුරුමුහුණත ක්‍රියාත්මක කළ යුතු අතර ස්වාභාවික වර්ග කිරීමේ අනුපිළිවෙලක් නොමැති පන්ති (පන්ති පුටුවක්, උදාහරණයක් ලෙස) සංසන්දකයෙකු (හෝ නිර්නාමික සංසන්දකයෙකු) ලබා දිය යුතුය. පන්තිය).

උදාහරණ දෙකක්:

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

භාවිතය:

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

වර්ග කිරීම සඳහා ArrayListඔබට පහත කේත ස්නිපටය භාවිතා කළ හැකිය:

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

ඔව් ඔබට පුළුවන්. සංසන්දනාත්මක අයිතම සමඟ විකල්ප දෙකක් තිබේ, සංසන්දනාත්මක අතුරුමුහුණත සහ සංසන්දනාත්මක අතුරුමුහුණත.

මෙම අතුරුමුහුණත් දෙකම විවිධ හැසිරීම් වලට ඉඩ දෙයි. සංසන්දනාත්මකව ඔබ නූල් විස්තර කළ ආකාරයටම වස්තුව ක්‍රියා කිරීමට ඉඩ දෙයි (ඇත්ත වශයෙන්ම, නූල් සංසන්දනාත්මකව ක්‍රියාත්මක කරයි). දෙවැන්න, සංසන්දකයා, ඔබ ඉල්ලන දේ කිරීමට ඉඩ දෙයි. ඔබ එය මේ ආකාරයට කරනු ඇත:

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

එමඟින් Collections.sort ක්‍රමය ඔබේ සංසන්දකය වර්ග කිරීමේ යාන්ත්‍රණය සඳහා භාවිතා කිරීමට හේතු වේ. ArrayList හි ඇති වස්තූන් සැසඳිය හැකි ලෙස ක්‍රියාත්මක කරන්නේ නම්, ඒ වෙනුවට ඔබට මේ වගේ දෙයක් කළ හැකිය:

Collections.sort(myArrayList);

මෙම එකතුව පන්තිය, මෙම ප්රයෝජනවත්, පොදු මෙවලම් සංඛ්යාව අඩංගු වේ.

ජාවා 8 ලැම්බඩා ප්‍රකාශනය

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

හෝ

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

ජාවා 8 සමඟ ඔබේ සංසන්දකයාට ක්‍රම යොමු කිරීමක් භාවිතා කළ හැකිය:

import static java.util.Comparator.comparing;

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

තාක්ෂණයන් එදිනෙදා දර්ශනය වන බැවින්, කාලය තුළ පිළිතුර වෙනස් වේ. මම ලැම්බඩා ජේ දෙස බැලූ අතර එය ඉතා සිත්ගන්නා සුළුය.

LambdaJ සමඟ ඔබට මෙම කාර්යයන් විසඳීමට උත්සාහ කළ හැකිය . ඔබට එය මෙතැනින් සොයාගත හැකිය: http://code.google.com/p/lambdaj/

මෙන්න ඔබට උදාහරණයක් තිබේ:

අනුකාරක වර්ග කරන්න

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

ලැම්බඩා සමඟ වර්ග කරන්න

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

ඇත්ත වශයෙන්ම, මේ ආකාරයේ රූපලාවණ්‍ය ක්‍රියාකාරිත්වයේ (සාමාන්‍යයෙන් 2 ගුණයක්) බලපෑම් ඇති නමුත් ඔබට වඩාත් කියවිය හැකි කේතයක් සොයාගත හැකිද?

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 සමඟ ඇති හොඳම පහසුම ක්‍රමය වන්නේ ඉංග්‍රීසි අකාරාදී පිළිවෙලයි

පන්ති ක්‍රියාත්මක කිරීම

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

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

වර්ග කරන්න

  Collections.sort(Your List);

ඔබට ඉංග්‍රීසි නොවන අක්ෂර අඩංගු හෝඩිය වර්ග කිරීමට අවශ්‍ය නම් ඔබට පෙදෙසිය භාවිතා කළ හැකිය ... කේතයට පහළින් තුර්කි අක්ෂර වර්ග කිරීම ...

පන්ති ක්‍රියාත්මක කිරීම

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

වර්ග කරන්න

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

ක්‍රියාකාරීත්වය සහ ක්‍රම යොමුව

ඔබ සමත් වූ Collections.sortක්‍රමයක් Listභාවිතා කර ක්‍රමයට වර්ග කළ හැකිය Comparator. බව Comparatorභාවිතා ක්රියාත්මක කළ හැකි Comparator.comparingඔබ සමත් හැකි ක්රමය ක්රමය සඳහනක් අවශ්ය ලෙස Function. වාසනාවකට මෙන්, සත්‍ය කේතය මෙම විස්තරයට වඩා සරල හා කෙටි ය.

ජාවා 8 සඳහා:

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

හෝ

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

තවත් ක්‍රමයක් නම්

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

එතැන් Java 8සිට අපට Collections.sort()කෙලින්ම භාවිතා කිරීමට අවශ්‍ය නැත . Listඅතුරු මුහුණතට පෙරනිමි sort()ක්‍රමයක් ඇත:

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

Http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html බලන්න .

ජාවා 8 ලැම්බඩා වර්ග කිරීම කෙටි කරයි.

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

ඔබේ අභිරුචි පන්තියේ ඕනෑම දේපලක් වර්ග කිරීම සඳහා ඔබට බීන් සංසන්දකය භාවිතා කළ හැකිය .

ඔව්, උදාහරණයක් ලෙස මෙම පිළිතුරෙන් මම vපන්තියේ දේපල අනුව වර්ග කරමිIndexValue

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

ඔබ මෙහි දැක්කොත් මම නිර්නාමික අභ්‍යන්තර පංතියක් නිර්මාණය කරමි (එය වසා දැමීමේ ජාවා වේ) එය කෙලින්ම sortපන්තියේ ක්‍රමයට යොමු කරමිArrays

ඔබේ වස්තුව ද ක්‍රියාත්මක කළ හැකිය Comparable(එය ජාවාහි සංගීත හා බොහෝ ප්‍රධාන පුස්තකාලවල කරන්නේ එයයි) නමුත් එය පන්තියේ “ස්වාභාවික වර්ග කිරීමේ අනුපිළිවෙල” නිර්වචනය කරනු ඇති අතර නව ඒවා සම්බන්ධ කිරීමට ඔබට ඉඩ නොදේ.

මෙම පිළිතුරු සියල්ලම සංසන්දනාත්මකව ක්‍රියාත්මක කිරීමට හෝ උපකාරක සංසන්දනාත්මක අතුරු මුහුණතක් ලබා ගැනීමට යටින් පවතින පන්තිය (වස්තුව) මත රඳා නොපවතින බව මට පෙනී ගියේය.

මගේ විසඳුම සමඟ නොවේ! පහත දැක්වෙන කේතය මඟින් වස්තුවේ ක්ෂේත්‍රය ඒවායේ නූල් නම දැන ගැනීමෙන් සැසඳිය හැක. නම භාවිතා නොකිරීමට ඔබට එය පහසුවෙන් වෙනස් කළ හැකිය, නමුත් පසුව ඔබට එය නිරාවරණය කිරීමට හෝ ඔබට සංසන්දනය කිරීමට අවශ්‍ය වස්තු වලින් එකක් සෑදිය යුතුය.

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

ඔබට ගුවා ඇණවුම් කිරීම උත්සාහ කළ හැකිය :

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

ඔබට ජාවා 8 භාවිතයෙන් වර්ග කළ හැකිය

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

or

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

මෙම කේත ස්නිපෙට් ප්‍රයෝජනවත් විය හැකිය. ඔබට මගේ නඩුවේ වස්තුවක් වර්ග කිරීමට අවශ්‍ය නම් මට VolumeName අනුව වර්ග කිරීමට අවශ්‍යයි:

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

මෙය ක්‍රියාත්මක වේ. මම එය මගේ jsp හි භාවිතා කරමි.

මෙම පුස්තකාලයේ මෙතන ඔබ සතුව කණු මත අභිරුචි වස්තූන් ලැයිස්තුව හරවා ගත හැකිය. පුස්තකාලය 8.0 අනුවාදය භාවිතා කරයි. නියැදිය ද එහි ඇත. කළ යුතු නියැදියක් මෙන්න

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 දී ජර්මනියේ ස්ටුට්ගාර්ට් හි ජාවා සංසදයේදී මෙම ඉදිරිපත් කිරීමේ පැවැත්වීම පිළිබඳව ඔබට සොයා බැලිය හැකිය .

විනිවිදක කිහිපයක් පමණක් ජර්මානු භාෂාව භාවිතා කරයි, අන්තර්ගතයෙන් 99% ක්ම "ඉංග්‍රීසි පදනම් කරගත්" ජාවා ප්‍රභව කේතය; මෙන්

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

OurCustomComparatorපෙරනිමි ක්‍රම භාවිතා කරන තැන (සහ වෙනත් රසවත් අදහස්). පෙන්වා ඇති පරිදි, වර්ග කිරීම සඳහා යම්කිසි ක්‍රමයක් තෝරා ගැනීම සඳහා ඉතා සංක්ෂිප්ත කේතයකට යොමු කිරීම; සහ වර්ග කිරීමේ නිර්ණායකවල සුපිරි සරල දම්වැල් (හෝ ආපසු හැරවීම).

ඔබ java8 වෙත පිවිසෙන්නේ නම්, ඔබ ආරම්භ කිරීම සඳහා එහි බොහෝ ද්‍රව්‍ය සොයා ගනී.

1.8 සිට අළුත් වන්නේ Collection.sort () භාවිතා කිරීම වෙනුවට List.sort () ක්‍රමයක් වන බැවින් ඔබ කෙලින්ම mylistcontainer.sort () අමතන්න.

List.sort () අංගය නිරූපණය කරන කේත ස්නිපටයක් මෙන්න:

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]

පළතුරු පන්තිය:

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   

ඔබේ අභිරුචි කම්පරේටර් පන්තිය භාවිතා කිරීම සඳහා java.util.Comparator ක්‍රියාත්මක කළ යුතුය. එය () හා සමාන () ට සමාන විය යුතුය

සංසන්දනය කරන්න () ප්‍රශ්නයට පිළිතුරු දිය යුතුය: වස්තුව 1 වස්තුව 2 ට වඩා අඩු ද, සමාන ද?

සම්පූර්ණ ලියකියවිලි: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

මම මෙම ක්‍රියාවලියට කැමතියි:

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

ඔබ වස්තු ලැයිස්තුවක් නම් දේපලක් තිබේ නම් startDate, ඔබ මෙය නැවත නැවතත් භාවිතා කරන්න. ඔබට ඒවා දම්වැල් දැමිය හැකිය startDate.time.

මෙය ඔබේ වස්තුව වීම සඳහා අත්යවශ්ය Comparableඔබට අවශ්ය, ඒ කියන්නේ compareTo, equalsහා hashCodeක්රියාත්මක කිරීම.

ඔව්, එය වේගවත් විය හැකිය ... නමුත් දැන් ඔබ එක් එක් වර්ග කිරීම සඳහා නව සංසන්දකයෙකු සෑදිය යුතු නැත. ඔබට කාලය ඉතිරි කර ගත හැකි අතර ධාවන කාලය අතහැර දැමිය හැකි නම්, ඔබට මෙය සමඟ යා හැකිය.

ජාවා 8 භාවිතය මඟින් Comparatorඑක් පේළියක භාවිතා කිරීම අර්ථ දැක්විය හැකියComparator.comparing()

පහත දැක්වෙන ඕනෑම දෙයක් භාවිතා කරන්න:

විකල්ප 1:

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

විකල්ප 2:

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

ඔබේ අභිරුචි පන්තියට "සංසන්දනාත්මක" අතුරුමුහුණත ක්‍රියාත්මක කළ හැකිය, එයට CompareTo ක්‍රමය ක්‍රියාත්මක කිරීම අවශ්‍ය වේ. CompareTo ක්‍රමයේදී ඔබට වස්තුවක් අනෙක් වස්තුවට වඩා අඩු හෝ වැඩි යැයි අදහස් කරන්නේ කුමක්ද යන්න නිර්වචනය කළ හැකිය . එබැවින් ඔබේ උදාහරණයේ දී, මේ වගේ දෙයක් පෙනිය හැකිය:

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

Negative ණ සංඛ්‍යාවක් පෙන්නුම් කරන්නේ මෙය වස්තුව හා සැසඳීමට වඩා කුඩා බවයි. ධනාත්මක සංඛ්‍යාවක් පෙන්නුම් කරන්නේ මෙය වස්තුවට සාපේක්ෂව විශාල වන අතර ශුන්‍යයක් යනු වස්තූන් සමාන බවයි.

සංසන්දකයකුට පෝෂණය නොවී ඔබේ ලැයිස්තුව වර්ග කිරීමට ඔබට පසුව collection.sort (myList) භාවිතා කළ හැකිය. ඔබ TreeSet හෝ TreeMap වැනි වර්ග කළ එකතු කිරීමේ දත්ත ව්‍යුහයන් භාවිතා කරන්නේ නම් දේවල් ස්වයංක්‍රීයව වර්ග කිරීමේ වාසිය මෙම ක්‍රමයට ඇත.

සැසඳිය හැකි අතුරුමුහුණත ගැන වැඩිදුර කියවීමට ඔබ කැමති නම් ඔබට මෙම ලිපිය පරීක්ෂා කළ හැකිය (අනාවරණය: මම කර්තෘ;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

ඔබට වර්ග කිරීමට අවශ්‍ය (කැදැලි) දේපල වෙත නූල් දේපල මාර්ගයක් තිබේ නම් ඔබට ස්ප්‍රින්ග්ස් ප්‍රොපර්ටි කොම්පරේටර් භාවිතා කළ හැකිය :

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

මෙහි ඇති අවාසිය නම්, මෙම සංසන්දකයා නිහ ly ව නොපවතින හෝ ප්‍රවේශ විය නොහැකි ගුණාංග නොසලකා හැරීම හා සංසන්දනය සඳහා මෙය ශුන්‍ය අගයක් ලෙස හසුරුවයි . මෙයින් අදහස් කරන්නේ, ඔබ එවැනි සංසන්දකයෙකු පරිස්සමින් පරික්ෂා කළ යුතු අතර දේපල මාර්ගයේ පැවැත්ම කෙසේ හෝ වලංගු කළ යුතුය.

java-8 ධාරාව api භාවිතා කර ඔබට පහත පරිදි වර්ග කළ හැකිය ArrayList:

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

මම අන්තර්ජාලයෙන් ලබා ගත හැකි විවිධ විසඳුම් අත්හදා බැලුවද මට ගැලපෙන විසඳුම පහත සබැඳියෙන් ලබා ගත හැකිය.

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

හොඳයි ඔබ ජාවා 8 හෝ ඊට වඩා පැරණි අනුවාදය භාවිතා කරන්නේ නම් මෙන්න හොඳම විසඳුම.

Collections.sort(studentList, Comparator.comparing(Student::getCgpa).reversed().thenComparing(Student:: getFname).thenComparing(Student::getId));

මෙම අවස්ථාවේ දී, එය පළමුව 'getCgpa' සමඟ වර්ග කරන අතර දෙවන කොටස සඳහා එය getFname සහ getId සමඟ වර්ග කරයි. ක්‍ෂේත්‍රය පූජෝ පන්තියට ඇතුළත් වේ.