जवाबों:
आप 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" डॉक्स से - दो स्ट्रिंग्स को समसामयिक रूप से तुलना करता है" ।
Collections.sortदेशी संग्रह पुस्तकालय में एक स्थिर विधि है। यह वास्तविक छँटाई करता है, आपको बस एक तुलनित्र प्रदान करने की आवश्यकता होती है जो परिभाषित करता है कि आपकी सूची के दो तत्वों की तुलना कैसे की जानी चाहिए: यह compareविधि के अपने कार्यान्वयन को प्रदान करके प्राप्त किया जाता है ।
Comparable। @ Berry120
Comparator<Person> comparator = Comparator.comparing(Person::getName).thenComparingInt(Person::getAge);
जावा 8 स्ट्रीमिंग एपीआई का उपयोग करने में सक्षम लोगों के लिए, यहां एक अच्छी तरह से प्रलेखित किया गया है, एक neater दृष्टिकोण है: लैम्ब्डा और सॉर्टिंग
मुझे C # LINQ के बराबर की तलाश थी:
.ThenBy(...)मैं तुलनित्र पर जावा 8 में तंत्र पाया:
.thenComparing(...)तो यहाँ स्निपेट है जो एल्गोरिथ्म को प्रदर्शित करता है।
Comparator<Person> comparator = Comparator.comparing(person -> person.name);
comparator = comparator.thenComparing(Comparator.comparing(person -> person.age));एक neater तरीके के लिए ऊपर दिए गए लिंक की जाँच करें और एक स्पष्टीकरण के बारे में कि कैसे जावा के प्रकार के निष्कर्ष यह LINQ की तुलना में परिभाषित करने के लिए थोड़ा अधिक क्लंकी है।
यहाँ संदर्भ के लिए पूर्ण इकाई परीक्षण है:
@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);
}
}Comparator<Person> comparator = Comparator.comparing(Person::getName).thenComparing(Person::getAge);
thenComparingIntआयु (इंट) के लिए उपयोग करें
Collections.sort(people, comparator);इसके बजाय सिर्फ उपयोग कर सकते हैं ?
जावा 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));आपको अपने स्वयं के कार्यान्वयन की आवश्यकता है 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));
}
}
}तुलनित्र पहले नामों की तुलना करता है, यदि वे बराबर नहीं होते हैं तो यह परिणाम उनकी तुलना करने से वापस करता है, अन्यथा यह दोनों व्यक्तियों की आयु की तुलना करते समय तुलना परिणाम देता है।
यह कोड केवल एक मसौदा है: क्योंकि वर्ग अपरिवर्तनीय है आप इसके बारे में एक सिंगलटन के निर्माण के बारे में सोच सकते हैं, इसके बजाय प्रत्येक छंटाई के लिए एक नया उदाहरण बना सकते हैं।
इसे प्राप्त करने के लिए आप जावा 8 लैम्बडा दृष्टिकोण का उपयोग कर सकते हैं। ऐशे ही:
persons.sort(Comparator.comparing(Person::getName).thenComparing(Person::getAge));अपने व्यक्ति वर्ग को लागू करें 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()हैं।
अमरूद 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();
}उपयोग करें 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);
}
}आवश्यक के रूप में कई तुलनित्र बनाएँ। इसके बाद, प्रत्येक ऑर्डर श्रेणी के लिए "thenComparing" विधि को कॉल करें। यह धाराओं द्वारा करने का एक तरीका है। देख:
//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)); देखो: कई क्षेत्रों पर उपयोगकर्ता परिभाषित वस्तु को क्रमबद्ध करें - तुलनित्र (लैम्ब्डा स्ट्रीम)
अमरूद का उपयोग करते समय मुझे सावधान रहना चाहिए 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
compareविधि को कॉल करने से कुछ भी नहीं बनता है, लेकिन सिंगलटन इंस्टेंस में से एक की तुलना में LESS, GREATERया ACTIVEतुलना के परिणाम पर निर्भर करता है। यह एक अत्यधिक अनुकूलित दृष्टिकोण है और इसमें कोई मेमोरी या प्रदर्शन ओवरहेड नहीं जोड़ा जाता है।
या आप इस तथ्य का फायदा उठा सकते हैं कि Collections.sort()(या Arrays.sort()) स्थिर है (यह उन तत्वों को पुन: व्यवस्थित नहीं करता है जो समान हैं) और का उपयोग करेंComparator पहले नाम से छाँटने के का और फिर नाम के आधार पर छाँटने के लिए एक और।
इस विशिष्ट मामले में यह बहुत अच्छा विचार नहीं है, लेकिन यदि आपको क्रम में क्रम क्रम को बदलने में सक्षम होना है, तो यह उपयोगी हो सकता है।
आप कई क्षेत्रों द्वारा संग्रह को सॉर्ट करने के लिए सामान्य धारावाहिक तुलनित्र का उपयोग कर सकते हैं।
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;
}
}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;
}
}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);
}
}मुझे यकीन नहीं है कि इस मामले में व्यक्ति वर्ग के अंदर कंपार्टर लिखना बदसूरत है। क्या यह इस तरह था:
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());
}
}
Comparatorइनपुट डालने से बचने के लिए एक प्रकार का पैरामीटर भी जोड़ सकते हैं ।