java - সম্পত্তি দ্বারা কাস্টম অবজেক্টের ArrayList সাজান




sorting date (16)

আমি compareTo সাহায্যে compareTo সাজানোর বিষয়ে পড়ি তবে মানুষের উদাহরণ তুলনামূলকভাবে ব্যবহৃত সমস্ত compareTo যা কিছু গবেষণা অনুসারে স্ট্রিংগুলির জন্য একটি পদ্ধতি।

আমি তাদের বৈশিষ্ট্যের একটি দ্বারা কাস্টম বস্তুর একটি অ্যারেস্টিস্ট সাজানোর চেয়েছিলেন: একটি তারিখ বস্তু ( getStartDay() )। সাধারণত আমি item1.getStartDate().before(item2.getStartDate()) তাদের সাথে তুলনা করি 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);
    ...
}

জাভা 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)

1.8 থেকে নতুন একটি Collection.sort () পদ্ধতিটি হল Collection.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);
}

} // ফল শ্রেণীর শেষ


আপনি আপনার কাস্টম ক্লাসে কোনও সম্পত্তি বাছাই করতে বীন তুলনাকারীর ব্যবহার করতে পারেন।


আপনি গুওয়াকে Ordering চেষ্টা করতে পারেন:

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

আমি এই সব উত্তর তুলনামূলক বাস্তবায়ন বা একটি সহায়ক সহায়ক তুলনা ইন্টারফেস আছে অন্তর্নিহিত বর্গ (বস্তু) উপর নির্ভর করে না, যদি অধিকাংশ পাওয়া যায়।

আমার সমাধান সঙ্গে না! নিম্নলিখিত কোডটি আপনাকে তাদের স্ট্রিং নামটি জেনে বস্তুর ক্ষেত্রের তুলনা করতে দেয়। আপনি সহজেই এটি নামটি ব্যবহার না করে সংশোধন করতে পারেন, তবে তারপরে আপনাকে এটি প্রকাশ করতে বা এমন বস্তুর মধ্যে একটি নির্মাণ করতে হবে যা আপনি তুলনা করতে চান।

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

এই কোড স্নিপেট দরকারী হতে পারে। যদি আপনি আমার ক্ষেত্রে একটি বস্তু বাছাই করতে চান তবে আমি 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 এটি ব্যবহার করুন।


কোনও প্রাকৃতিক সাজানোর ক্রম (উদাহরণস্বরূপ একটি শ্রেণির নম্বর) উদাহরণস্বরূপ তুলনীয় ইন্টারফেস বাস্তবায়ন করতে পারে, তবে ক্লাসগুলির কোন প্রাকৃতিক সাজানোর ক্রম (উদাহরণস্বরূপ একটি ক্লাস চেয়ার) কোনও কম্পারার (অথবা একটি বেনামী সংযোজক) সরবরাহ করা উচিত শ্রেণী)।

দুটি উদাহরণ:

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

জাভা 8 Lambda সাজানোর সংক্ষিপ্ত।

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

জাভা 8 দিয়ে আপনি আপনার তুলনাকারীর জন্য একটি পদ্ধতি রেফারেন্স ব্যবহার করতে পারেন:

import static java.util.Comparator.comparing;

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

জাভা 8 ব্যবহার করে Comparator.comparing() ব্যবহার করে এক লাইনের Comparator সংজ্ঞায়িত করতে পারে

নিচের কোনটি ব্যবহার করুন:

বিকল্প 1:

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

বিকল্প 2:

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

যেহেতু Date Comparable প্রয়োগ করে, এটির compareTo আছে compareTo মতই।

সুতরাং আপনার কাস্টম 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 জন্য Lambda অভিব্যক্তি ব্যবহার করে একটি সংক্ষিপ্ত আকারে শেষ উদাহরণটি লিখতে পারেন:

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

এবং List একটি sort(Comparator) পদ্ধতি রয়েছে, তাই আপনি এটি আরও ছোট করতে পারেন:

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

এটি একটি সাধারণ ধারণা যা একটি Comparable কী সহ একটি শ্রেণির জন্য একটি Comparator তৈরি করতে একটি অন্তর্নির্মিত পদ্ধতি রয়েছে :

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

এই সব সমতুল্য ফর্ম।


যেহেতু প্রযুক্তির দৈনন্দিন প্রদর্শিত হবে, উত্তর সময় পরিবর্তন হবে। আমি LambdaJ একটি চেহারা গ্রহণ এবং খুব আকর্ষণীয় মনে হচ্ছে।

আপনি LambdaJ সঙ্গে এই কাজগুলো সমাধানের চেষ্টা করতে পারেন। আপনি এখানে এটি খুঁজে পেতে পারেন: http://code.google.com/p/lambdaj/

এখানে আপনার একটি উদাহরণ আছে:

বাছাই করুন Iterative

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 সঙ্গে সাজান

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

অবশ্যই, এই ধরনের সৌন্দর্যের পারফরম্যান্সে প্রভাব ফেলে (2 বার গড়), কিন্তু আপনি কি আরও বেশি পাঠযোগ্য কোড খুঁজে পেতে পারেন?


হ্যাঁ, উদাহরণস্বরূপ এই উত্তরটি আমি ক্লাস IndexValue এর সম্পত্তি 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;
        }
    });

যদি আপনি এখানে লক্ষ্য করেন আমি একটি বেনামী ভেতরের বর্গ তৈরি করছি (যা বন্ধ করার জন্য জাভা) এবং এটি শ্রেণির Arrays sort পদ্ধতিতে সরাসরি প্রেরণ করে

আপনার বস্তুটি Comparable (এটি স্ট্রিং এবং Comparable বেশিরভাগ মূল লাইব্রেরিগুলি যা করে) তাও বাস্তবায়ন করতে পারে তবে এটি আপনার নিজের ক্লাসের "প্রাকৃতিক সাজানোর ক্রম" সংজ্ঞায়িত করবে এবং আপনাকে নতুনগুলি প্লাগ করতে দেয় না।


২016 সালে স্টুটগার্ট জার্মানিতে জাভা ফোরামে আপনি এই presentation নজর রাখতে পারেন।

শুধুমাত্র কয়েকটি স্লাইড জার্মান ভাষা ব্যবহার করে, 99% সামগ্রীটি "ইংরেজি ভিত্তিক" জাভা সোর্স কোড; মত

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

যেখানে OurCustomComparator ডিফল্ট পদ্ধতি ব্যবহার করে (এবং অন্যান্য আকর্ষণীয় ধারনা)। দেখানো হিসাবে, বাছাই করার জন্য কিছু গেটার পদ্ধতি বাছাই খুব সংক্ষিপ্ত কোড নেতৃস্থানীয়; এবং সাজানোর মানদণ্ডের সুপার সহজ চেইন (বা বিপরীত)।

যদি আপনি java8 এ যান, আপনি শুরু করতে সেখানে প্রচুর পরিমাণে উপাদান খুঁজে পাবেন।


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 ব্যবহার করে বাছাই করতে পারেন

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

or

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




comparator