জাভাতে দুটি ক্ষেত্র বাছাই কিভাবে?

Question

আমার কাছে বস্তুর অ্যারে রয়েছে person (int age; String name;) ।

নাম এবং তার পরে বয়সের সাহায্যে আমি এই অ্যারেটিকে বর্ণানুক্রমিকভাবে কীভাবে বাছাই করতে পারি?

আপনি এর জন্য কোন অ্যালগরিদম ব্যবহার করবেন?

Answer 1

আপনি Collections.sortনিম্নলিখিত হিসাবে ব্যবহার করতে পারেন :

private static void order(List<Person> persons) {

    Collections.sort(persons, new Comparator() {

        public int compare(Object o1, Object o2) {

            String x1 = ((Person) o1).getName();
            String x2 = ((Person) o2).getName();
            int sComp = x1.compareTo(x2);

            if (sComp != 0) {
               return sComp;
            } 

            Integer x1 = ((Person) o1).getAge();
            Integer x2 = ((Person) o2).getAge();
            return x1.compareTo(x2);
    }});
}

List<Persons> নাম অনুসারে বাছাই করা হয়, তারপর বয়স অনুসারে।

String.compareToথেকে - "দুটি স্ট্রিং lexicographically তুলনা" ডক্স ।

Collections.sortনেটিভ কালেকশন লাইব্রেরিতে স্থির পদ্ধতি। এটি প্রকৃত বাছাই করে, আপনাকে কেবল একটি তুলনামূলক সরবরাহ করতে হবে যা আপনার তালিকার দুটি উপাদানকে কীভাবে তুলনা করা উচিত তা নির্ধারণ করে: এটি compareপদ্ধতিটির নিজস্ব বাস্তবায়ন সরবরাহ করে অর্জন করা হয় ।

Comments

Comparatorইনপুটগুলি কাস্ট না করাতে আপনি একটি ধরণের পরামিতি যুক্ত করতে পারেন।

— বিজিকলপ

@ রাল্ফ: আমি আমার উত্তরটি সংশোধন করেছি এবং একটি সংক্ষিপ্ত বিবরণ যুক্ত করেছি।

— রিচার্ড এইচ

যেহেতু ওপিতে ইতিমধ্যে তাদের নিজস্ব অবজেক্ট শ্রেণি রয়েছে তাই এটি প্রয়োগ করা আরও অর্থবোধ করে Comparable। @ Berry120

— জুলাক্সিয়া

মিনি কোড রিভিউ: অন্যটি ধারাটি রিডান্ট্যান্ট কারণ প্রথম ফেরতটি গার্ড ক্লজ হিসাবে কাজ করে। দুর্দান্ত উত্তর যদিও, আমার জন্য একটি ট্রিট কাজ।

— টম সালেবা

এই প্রশ্ন / উত্তরটি এখনও যুক্ত হওয়ার সাথে সাথে দয়া করে মনে রাখবেন যে জাভা এসই 8 এর সাথে এটি আরও সহজ হয়ে উঠেছে। যদি গেটার থাকে তবে আপনি লিখতে পারেনComparator<Person> comparator = Comparator.comparing(Person::getName).thenComparingInt(Person::getAge);

— পুস

Answer 2

যাঁরা জাভা 8 স্ট্রিমিং এপিআই ব্যবহার করতে সক্ষম হবেন, তাদের কাছে এখানে একটি ন্যাটার অ্যাপ্রোচ রয়েছে যা ভালভাবে নথিভুক্ত রয়েছে: লাম্বডাস এবং বাছাই করা

আমি সি # লিনকিউ এর সমতুল্য সন্ধান করছিলাম:

.ThenBy(...)

আমি তুলনা করতে জাভা 8 এ মেকানিজমটি পেয়েছি:

.thenComparing(...)

সুতরাং এখানে স্নিপেট যা অ্যালগরিদম প্রদর্শন করে।

    Comparator<Person> comparator = Comparator.comparing(person -> person.name);
    comparator = comparator.thenComparing(Comparator.comparing(person -> person.age));

উপরের লিংকটি আরও সুন্দরতর উপায়ের জন্য এবং জাভার ধরণের অনুমিতি কীভাবে এটি লিনিকের তুলনায় সংজ্ঞায়িত করতে আরও কিছুটা ক্লানকি করে তোলে তার একটি ব্যাখ্যা দেখুন।

রেফারেন্সের জন্য এখানে পূর্ণ ইউনিট পরীক্ষা রয়েছে:

@Test
public void testChainedSorting()
{
    // Create the collection of people:
    ArrayList<Person> people = new ArrayList<>();
    people.add(new Person("Dan", 4));
    people.add(new Person("Andi", 2));
    people.add(new Person("Bob", 42));
    people.add(new Person("Debby", 3));
    people.add(new Person("Bob", 72));
    people.add(new Person("Barry", 20));
    people.add(new Person("Cathy", 40));
    people.add(new Person("Bob", 40));
    people.add(new Person("Barry", 50));

    // Define chained comparators:
    // Great article explaining this and how to make it even neater:
    // http://blog.jooq.org/2014/01/31/java-8-friday-goodies-lambdas-and-sorting/
    Comparator<Person> comparator = Comparator.comparing(person -> person.name);
    comparator = comparator.thenComparing(Comparator.comparing(person -> person.age));

    // Sort the stream:
    Stream<Person> personStream = people.stream().sorted(comparator);

    // Make sure that the output is as expected:
    List<Person> sortedPeople = personStream.collect(Collectors.toList());
    Assert.assertEquals("Andi",  sortedPeople.get(0).name); Assert.assertEquals(2,  sortedPeople.get(0).age);
    Assert.assertEquals("Barry", sortedPeople.get(1).name); Assert.assertEquals(20, sortedPeople.get(1).age);
    Assert.assertEquals("Barry", sortedPeople.get(2).name); Assert.assertEquals(50, sortedPeople.get(2).age);
    Assert.assertEquals("Bob",   sortedPeople.get(3).name); Assert.assertEquals(40, sortedPeople.get(3).age);
    Assert.assertEquals("Bob",   sortedPeople.get(4).name); Assert.assertEquals(42, sortedPeople.get(4).age);
    Assert.assertEquals("Bob",   sortedPeople.get(5).name); Assert.assertEquals(72, sortedPeople.get(5).age);
    Assert.assertEquals("Cathy", sortedPeople.get(6).name); Assert.assertEquals(40, sortedPeople.get(6).age);
    Assert.assertEquals("Dan",   sortedPeople.get(7).name); Assert.assertEquals(4,  sortedPeople.get(7).age);
    Assert.assertEquals("Debby", sortedPeople.get(8).name); Assert.assertEquals(3,  sortedPeople.get(8).age);
    // Andi     : 2
    // Barry    : 20
    // Barry    : 50
    // Bob      : 40
    // Bob      : 42
    // Bob      : 72
    // Cathy    : 40
    // Dan      : 4
    // Debby    : 3
}

/**
 * A person in our system.
 */
public static class Person
{
    /**
     * Creates a new person.
     * @param name The name of the person.
     * @param age The age of the person.
     */
    public Person(String name, int age)
    {
        this.age = age;
        this.name = name;
    }

    /**
     * The name of the person.
     */
    public String name;

    /**
     * The age of the person.
     */
    public int age;

    @Override
    public String toString()
    {
        if (name == null) return super.toString();
        else return String.format("%s : %d", this.name, this.age);
    }
}

Comments

তুলনাকারীদের এই ধরণের শৃঙ্খলার জটিলতা কী হবে? আমরা যখন প্রতিযোগীতার সাথে শৃঙ্খল করি তখন কি আমরা মূলত বাছাই করি? সুতরাং আমরা প্রতিটি তুলকের জন্য একটি এনলগএন অপারেশন করি?

— জন বাউম

যদি গেটার থাকে তবে আপনি লিখতে পারেনComparator<Person> comparator = Comparator.comparing(Person::getName).thenComparing(Person::getAge);

— পুস

thenComparingIntবয়সের জন্য ব্যবহার (

— পূর্ববর্তী

ল্যাবদা '->' এর সাথে সিনট্যাক্স আমার পক্ষে কাজ করে না। ব্যক্তি :: getLastName করে।

— নোল্ডি

তুলনাকারী তৈরির পরে, একটি স্ট্রিম তৈরি করার, তুলকের সাথে এটি বাছাই করা এবং তারপরে সংগ্রহ করার দরকার কী? আপনি কেবল Collections.sort(people, comparator);পরিবর্তে ব্যবহার করতে পারেন ?

— আনিস সানা

Answer 3

জাভা 8 স্ট্রিমের পদ্ধতির ব্যবহার করে ...

//Creates and sorts a stream (does not sort the original list)       
persons.stream().sorted(Comparator.comparing(Person::getName).thenComparing(Person::getAge));

এবং জাভা 8 ল্যাম্বদা পদ্ধতির ...

//Sorts the original list Lambda style
persons.sort((p1, p2) -> {
        if (p1.getName().compareTo(p2.getName()) == 0) {
            return p1.getAge().compareTo(p2.getAge());
        } else {
            return p1.getName().compareTo(p2.getName());
        } 
    });

সর্বশেষে ...

//This is similar SYNTAX to the Streams above, but it sorts the original list!!
persons.sort(Comparator.comparing(Person::getName).thenComparing(Person::getAge));

Answer 4

আপনার নিজের প্রয়োগ Comparatorকরতে হবে এবং তারপরে এটি ব্যবহার করুন: উদাহরণস্বরূপ

Arrays.sort(persons, new PersonComparator());

আপনার তুলনাকারীটি দেখতে কিছুটা দেখতে পারা যায়:

public class PersonComparator implements Comparator<? extends Person> {

  public int compare(Person p1, Person p2) {
     int nameCompare = p1.name.compareToIgnoreCase(p2.name);
     if (nameCompare != 0) {
        return nameCompare;
     } else {
       return Integer.valueOf(p1.age).compareTo(Integer.valueOf(p2.age));
     }
  }
}

তুলনাকারী প্রথমে নামগুলির সাথে তুলনা করে, যদি সেগুলি সমান হয় না তবে এটি তুলনা করে ফলাফলটি দেয়, অন্যথায় উভয় ব্যক্তির বয়সের তুলনা করার সময় এটি তুলনামূলক ফলাফলটি দেয়।

এই কোডটি কেবল একটি খসড়া: কারণ শ্রেণিটি অপরিবর্তনীয় আপনি এর পরিবর্তে প্রতিটি বাছাইয়ের জন্য একটি নতুন উদাহরণ তৈরি করার পরিবর্তে এর একটি সিঙ্গলটন তৈরির কথা ভাবতে পারেন।

Answer 5

এটি অর্জনের জন্য আপনি জাভা 8 লাম্বদা পদ্ধতির ব্যবহার করতে পারেন। এটার মত:

persons.sort(Comparator.comparing(Person::getName).thenComparing(Person::getAge));

Answer 6

আপনার ব্যক্তি শ্রেণি প্রয়োগ করুন Comparable<Person>এবং তারপরে তুলনামূলক পদ্ধতি প্রয়োগ করুন, উদাহরণস্বরূপ:

public int compareTo(Person o) {
    int result = name.compareToIgnoreCase(o.name);
    if(result==0) {
        return Integer.valueOf(age).compareTo(o.age);
    }
    else {
        return result;
    }
}

এটি প্রথমে নাম অনুসারে বাছাই করবে (সংবেদনশীলতার ক্ষেত্রে) এবং তারপরে বয়স অনুসারে। এর পরে আপনি চালাতে পারেন Arrays.sort()বা Collections.sort()সংগ্রহ বা ব্যক্তি বস্তুর অ্যারের উপর।

Comments

আমি সাধারণত এটি তুলনামূলক তৈরির চেয়ে বেশি পছন্দ করি, যেহেতু বেরি 21 বলে, আপনি সর্বদা আপনার পছন্দসই তুলকটি ব্যবহার করার প্রয়োজনের পরিবর্তে পদ্ধতিতে অন্তর্নির্মিত অনুসারে বাছাই করতে পারেন।

— জুলাক্সিয়া

Answer 7

পেয়ারা এটি ComparisonChainকরার একটি পরিষ্কার উপায় সরবরাহ করে। এই লিঙ্কটি দেখুন ।

শৃঙ্খলাবদ্ধ তুলনা বিবৃতি সম্পাদনের জন্য একটি ইউটিলিটি। উদাহরণ স্বরূপ:

   public int compareTo(Foo that) {
     return ComparisonChain.start()
         .compare(this.aString, that.aString)
         .compare(this.anInt, that.anInt)
         .compare(this.anEnum, that.anEnum, Ordering.natural().nullsLast())
         .result();
   }

Answer 8

আপনি এটির মতো করতে পারেন:

List<User> users = Lists.newArrayList(
  new User("Pedro", 12), 
  new User("Maria", 10), 
  new User("Rafael",12)
);

users.sort(
  Comparator.comparing(User::getName).thenComparing(User::getAge)
);

Answer 9

ব্যবহারের Comparatorএবং তারপর মধ্যে বস্তু করা Collectionতারপর,Collections.sort();

class Person {

    String fname;
    String lname;
    int age;

    public Person() {
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getFname() {
        return fname;
    }

    public void setFname(String fname) {
        this.fname = fname;
    }

    public String getLname() {
        return lname;
    }

    public void setLname(String lname) {
        this.lname = lname;
    }

    public Person(String fname, String lname, int age) {
        this.fname = fname;
        this.lname = lname;
        this.age = age;
    }

    @Override
    public String toString() {
        return fname + "," + lname + "," + age;
    }
}

public class Main{

    public static void main(String[] args) {
        List<Person> persons = new java.util.ArrayList<Person>();
        persons.add(new Person("abc3", "def3", 10));
        persons.add(new Person("abc2", "def2", 32));
        persons.add(new Person("abc1", "def1", 65));
        persons.add(new Person("abc4", "def4", 10));
        System.out.println(persons);
        Collections.sort(persons, new Comparator<Person>() {

            @Override
            public int compare(Person t, Person t1) {
                return t.getAge() - t1.getAge();
            }
        });
        System.out.println(persons);

    }
}

Answer 10

প্রয়োজনীয় হিসাবে অনেক তুলক তৈরি করুন। এর পরে, প্রতিটি অর্ডার বিভাগের জন্য পদ্ধতিটিকে "তারপরে তুলনা করুন" কল করুন। এটি স্ট্রিম দ্বারা করার একটি উপায়। দেখা:

//Sort by first and last name
System.out.println("\n2.Sort list of person objects by firstName then "
                                        + "by lastName then by age");
Comparator<Person> sortByFirstName 
                            = (p, o) -> p.firstName.compareToIgnoreCase(o.firstName);
Comparator<Person> sortByLastName 
                            = (p, o) -> p.lastName.compareToIgnoreCase(o.lastName);
Comparator<Person> sortByAge 
                            = (p, o) -> Integer.compare(p.age,o.age);

//Sort by first Name then Sort by last name then sort by age
personList.stream().sorted(
    sortByFirstName
        .thenComparing(sortByLastName)
        .thenComparing(sortByAge)
     ).forEach(person->
        System.out.println(person));        

চেহারা: একাধিক ক্ষেত্রে ব্যবহারকারী সংজ্ঞায়িত বস্তু বাছাই করুন - তুলক (ল্যাম্বদা স্ট্রিম)

Answer 11

পেয়ারা ব্যবহার করার সময় আমি সতর্কতা অবলম্বন করব ComparisonChainকারণ এটি তুলনামূলকভাবে উপাদানগুলির তুলনায় এটির একটি উদাহরণ তৈরি করে যাতে আপনি N x Log Nবাছাইয়ের তুলনায় কেবল তুলনা শৃঙ্খলার একটি সন্ধানের দিকে তাকিয়ে থাকবেন , বাN যদি আপনি পুনরাবৃত্তি করছেন এবং সমতার জন্য পরীক্ষা করছেন তবে উদাহরণগুলি।

পরিবর্তে আমি Comparatorসম্ভব হলে নতুন জাভা 8 এপিআই বা গুয়ারা'র এপিআই ব্যবহার করে একটি স্ট্যাটিক তৈরি করব Orderingযা আপনাকে এটি করতে দেয়, জাভা 8 এর সাথে এখানে একটি উদাহরণ রয়েছে:

import java.util.Comparator;
import static java.util.Comparator.naturalOrder;
import static java.util.Comparator.nullsLast;

private static final Comparator<Person> COMPARATOR = Comparator
  .comparing(Person::getName, nullsLast(naturalOrder()))
  .thenComparingInt(Person::getAge);

@Override
public int compareTo(@NotNull Person other) {
  return COMPARATOR.compare(this, other);
}

পেয়ারার Orderingএপিআই কীভাবে ব্যবহার করবেন তা এখানে : https://github.com/google/guava/wiki/OrderingExplained

Comments

"... উপাদান হিসাবে তুলনা করা হয়েছে এর একটি উদাহরণ তৈরি করে ..." - এটি সত্য নয়। পেয়ারা আধুনিক সংস্করণ, এর ডেকে অন্তত compareপদ্ধতি কিছুই সৃষ্টি করে না, কিন্তু আয় Singleton দৃষ্টান্ত এক LESS, GREATERবা ACTIVEতুলনার ফলাফলের উপর নির্ভর করে। এটি একটি অত্যন্ত অনুকূলিত পদ্ধতি এবং কোনও মেমরি বা কর্মক্ষমতা ওভারহেড যুক্ত করে না।

— Yoory এন।

হ্যাঁ; আমি এখনই সোর্স কোডটি দেখেছি, আপনি কী বলতে চাইছেন তা আমি দেখতে পেয়েছি তবে নির্ভরতার জন্য আমি নতুন জাভা 8 তুলনা এপিআই ব্যবহার করতে আরও ঝুঁকতে চাই।

— গুইডো মদিনা

Answer 12

অথবা আপনি Collections.sort()(বা Arrays.sort()) স্থিতিশীল (এটি সমান উপাদানগুলিকে পুনরায় Comparatorঅর্ডার করে না) এই সত্যটি কাজে লাগাতে পারেন এবং প্রথমে বয়স অনুসারে বাছাই করার জন্য এবং তারপরে নাম অনুসারে বাছাই করতে আরও একটি ব্যবহার করতে পারেন।

এই সুনির্দিষ্ট ক্ষেত্রে এটি খুব ভাল ধারণা নয় তবে আপনাকে রানটাইমে সাজানোর ক্রমটি পরিবর্তন করতে সক্ষম হতে পারলে এটি কার্যকর হতে পারে useful

Answer 13

আপনি একাধিক ক্ষেত্র দ্বারা সংগ্রহগুলি বাছাই করতে জেনেরিক সিরিয়াল তুলনামূলক ব্যবহার করতে পারেন।

import org.apache.commons.lang3.reflect.FieldUtils;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
* @author MaheshRPM
*/
public class SerialComparator<T> implements Comparator<T> {
List<String> sortingFields;

public SerialComparator(List<String> sortingFields) {
    this.sortingFields = sortingFields;
}

public SerialComparator(String... sortingFields) {
    this.sortingFields = Arrays.asList(sortingFields);
}

@Override
public int compare(T o1, T o2) {
    int result = 0;
    try {
        for (String sortingField : sortingFields) {
            if (result == 0) {
                Object value1 = FieldUtils.readField(o1, sortingField, true);
                Object value2 = FieldUtils.readField(o2, sortingField, true);
                if (value1 instanceof Comparable && value2 instanceof Comparable) {
                    Comparable comparable1 = (Comparable) value1;
                    Comparable comparable2 = (Comparable) value2;
                    result = comparable1.compareTo(comparable2);
                } else {
                    throw new RuntimeException("Cannot compare non Comparable fields. " + value1.getClass()
                            .getName() + " must implement Comparable<" + value1.getClass().getName() + ">");
                }
            } else {
                break;
            }
        }
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
    return result;
}
}

Answer 14

Arrays.sort(persons, new PersonComparator());



import java.util.Comparator;

public class PersonComparator implements Comparator<? extends Person> {

    @Override
    public int compare(Person o1, Person o2) {
        if(null == o1 || null == o2  || null == o1.getName() || null== o2.getName() ){
            throw new NullPointerException();
        }else{
            int nameComparisonResult = o1.getName().compareTo(o2.getName());
            if(0 == nameComparisonResult){
                return o1.getAge()-o2.getAge();
            }else{
                return nameComparisonResult;
            }
        }
    }
}


class Person{
    int age; String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

নতুন সংস্করণ:

public class PersonComparator implements Comparator<? extends Person> {

   @Override
   public int compare(Person o1, Person o2) {

      int nameComparisonResult = o1.getName().compareToIgnoreCase(o2.getName());
      return 0 == nameComparisonResult?o1.getAge()-o2.getAge():nameComparisonResult;

   }
 }

Comments

নালপয়েন্টার ব্যতিক্রম হ্যান্ডলিংটি দুর্দান্ত এবং পরিষ্কার করুন যে এটি নাল দিয়ে কাজ করবে না তবে এটি যেভাবেই উত্থাপিত হবে

— রাল্ফ

তুমি একদম সঠিক. আমি সম্প্রতি এক জায়গা থেকে অন্য স্থানে অনুলিপি করার জন্য কিছু মান পরীক্ষা করেছি এবং এখন আমি সর্বত্র এটি চালিয়ে যাচ্ছি।

— fmucar

Answer 15

এর Bookমতো শ্রেণির জন্য :

package books;

public class Book {

    private Integer id;
    private Integer number;
    private String name;

    public Integer getId() {
        return id;
    }

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

    public Integer getNumber() {
        return number;
    }

    public void setNumber(Integer number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "book{" +
                "id=" + id +
                ", number=" + number +
                ", name='" + name + '\'' + '\n' +
                '}';
    }
}

মক অবজেক্টের সাথে মুখ্য শ্রেণিকে বাছাই করা

package books;

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


public class Main {

    public static void main(String[] args) {
        System.out.println("Hello World!");

        Book b = new Book();

        Book c = new Book();

        Book d = new Book();

        Book e = new Book();

        Book f = new Book();

        Book g = new Book();
        Book g1 = new Book();
        Book g2 = new Book();
        Book g3 = new Book();
        Book g4 = new Book();




        b.setId(1);
        b.setNumber(12);
        b.setName("gk");

        c.setId(2);
        c.setNumber(12);
        c.setName("gk");

        d.setId(2);
        d.setNumber(13);
        d.setName("maths");

        e.setId(3);
        e.setNumber(3);
        e.setName("geometry");

        f.setId(3);
        f.setNumber(34);
        b.setName("gk");

        g.setId(3);
        g.setNumber(11);
        g.setName("gk");

        g1.setId(3);
        g1.setNumber(88);
        g1.setName("gk");
        g2.setId(3);
        g2.setNumber(91);
        g2.setName("gk");
        g3.setId(3);
        g3.setNumber(101);
        g3.setName("gk");
        g4.setId(3);
        g4.setNumber(4);
        g4.setName("gk");





        List<Book> allBooks = new ArrayList<Book>();

        allBooks.add(b);
        allBooks.add(c);
        allBooks.add(d);
        allBooks.add(e);
        allBooks.add(f);
        allBooks.add(g);
        allBooks.add(g1);
        allBooks.add(g2);
        allBooks.add(g3);
        allBooks.add(g4);



        System.out.println(allBooks.size());


        Collections.sort(allBooks, new Comparator<Book>() {

            @Override
            public int compare(Book t, Book t1) {
                int a =  t.getId()- t1.getId();

                if(a == 0){
                    int a1 = t.getNumber() - t1.getNumber();
                    return a1;
                }
                else
                    return a;
            }
        });
        System.out.println(allBooks);

    }


   }

Answer 16

আমি নিশ্চিত নই যে এই ক্ষেত্রে ব্যক্তি শ্রেণির অভ্যন্তরে কোনও বিভাগটি লিখতে কুৎসিত হয় কিনা। এটি কি পছন্দ করেছে:

public class Person implements Comparable <Person> {

    private String lastName;
    private String firstName;
    private int age;

    public Person(String firstName, String lastName, int BirthDay) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = BirthDay;
    }

    public int getAge() {
        return age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    @Override
    public int compareTo(Person o) {
        // default compareTo
    }

    @Override
    public String toString() {
        return firstName + " " + lastName + " " + age + "";
    }

    public static class firstNameComperator implements Comparator<Person> {
        @Override
        public int compare(Person o1, Person o2) {
            return o1.firstName.compareTo(o2.firstName);
        }
    }

    public static class lastNameComperator implements Comparator<Person> {
        @Override
        public int compare(Person o1, Person o2) {
            return o1.lastName.compareTo(o2.lastName);
        }
    }

    public static class ageComperator implements Comparator<Person> {
        @Override
        public int compare(Person o1, Person o2) {
            return o1.age - o2.age;
        }
    }
}
public class Test {
    private static void print() {
       ArrayList<Person> list = new ArrayList();
        list.add(new Person("Diana", "Agron", 31));
        list.add(new Person("Kay", "Panabaker", 27));
        list.add(new Person("Lucy", "Hale", 28));
        list.add(new Person("Ashley", "Benson", 28));
        list.add(new Person("Megan", "Park", 31));
        list.add(new Person("Lucas", "Till", 27));
        list.add(new Person("Nicholas", "Hoult", 28));
        list.add(new Person("Aly", "Michalka", 28));
        list.add(new Person("Adam", "Brody", 38));
        list.add(new Person("Chris", "Pine", 37));
        Collections.sort(list, new Person.lastNameComperator());
        Iterator<Person> it = list.iterator();
        while(it.hasNext()) 
            System.out.println(it.next().toString()); 
     }  
}