दो मानदंडों की तुलना दो मानदंडों से करें

Question

मेरे पास एक क्लास उपयोगकर्ता है जिसमें एक बूलियन फ़ील्ड है, मैं उपयोगकर्ताओं की एक सूची को सॉर्ट करना चाहता हूं, मैं चाहता हूं कि जिन उपयोगकर्ताओं के पास बुलियन फ़ील्ड है, वे सूची के शीर्ष पर हों और उससे अधिक मैं उन्हें उनके नाम से सॉर्ट करना चाहता हूं।

ArrayList<User> users = new ArrayList<User>(); 
users.add(new User(1,"user1",false)); 
users.add(new User(2,"user2",true)); 
users.add(new User(3,"user3",true)); 
users.add(new User(4,"user4",false)); 
Collections.sort(users, new Comparator<User>() { 
    @Override 
    public int compare(User u1, User u2) { 
     //Here i'm lookin for what should i add to compare the two users depending to the boolean field 
     return u1.name.compareTo(u2.name); 
    } 
}); 
for(User u : users){ 
    System.out.println(u.name); 
} 

मैं इस परिणाम प्राप्त करने के उपयोगकर्ताओं क्रमबद्ध करना चाहते हैं: कहना है कि मैं उन के इस संग्रह है देता है:

public class User{ 
    int id; 
    String name; 
    boolean myBooleanField; 
    public User(int id, String name, boolean myBooleanField){ 
     this.id = id; 
     this.name = name; 
     this.myBooleanField = myBooleanField; 
    } 

    @Override 
    public boolean equals(Object obj) { 
     return this.id == ((User) obj).id; 
    } 
} 

यहाँ स्पष्ट करने के लिए मैं क्या चाहते हैं एक उदाहरण है: यहाँ मेरी वर्ग है :

user2 
user3 
user1 
user4 

Answer 1

आप पहली बार Boolean.compare(boolean x, boolean y) विधि का उपयोग कर सकता है। और चूंकि true तत्वों सरणी की शुरुआत करने के लिए हल कर रहे हैं, तो आप compare(u2.myBooleanField, u1.myBooleanField) का प्रयोग करेंगे:

@Override 
public int compare(User u1, User u2) { 
    final int booleanCompare = Boolean.compare(u2.myBooleanField, 
               u1.myBooleanField); 
    if (booleanCompare != 0) { 
     return booleanCompare; 
    } 
    return u1.name.compareTo(u2.name); 
} 

Answer 2

शायद इन लाइनों के साथ कुछ?

Collections.sort(users, new Comparator<User>() { 
    public int compare(User u1, User u2) { 
     String val1 = (u1.myBooleanField ? "0" : "1") + u1.name; 
     String val2 = (u2.myBooleanField ? "0" : "1") + u2.name; 

     return val1.compareTo(val2); 
    } 
});    

Answer 3

if(!u1.myBooleanField && u2.myBooleanField){ 
return 1; 
} else if (!u1.myBooleanField && u2.myBooleanField){ 
return -1; 
} else { 
//Whatever comparator you would like to sort on after sorting based on true and false 
} 

क्या जावा compareTo() विधि रिटर्न पर एक नजर डालें। मेरे उपर्युक्त उदाहरण में, हम पहले सत्य और झूठे के आधार पर क्रमबद्ध करते हैं, और फिर, यदि myBooleanField दोनों उपयोगकर्ताओं के बराबर है, तो आप किसी अन्य प्रॉपर्टी के आधार पर सॉर्ट कर सकते हैं।

Answer 4

if (u1.myBooleanField) { 
    if (u2.myBooleanField) 
     return u1.name.compareTo(u2.name); 
    return -1; 
} else if (u2.myBooleanField) { 
    return 1; 
} else { 
    return u1.name.compareTo(u2.name); 
} 

Answer 5

आप Collectors.groupingBy उपयोग कर सकते हैं उन में से बाकी के बाकी

Map<Boolean, List<User>> list = users.stream() 
      .collect(
       Collectors.groupingBy(
        Info::getMyBooleanField); 

से शीर्ष उपयोगकर्ताओं अलग करने के शीर्ष उपयोगकर्ताओं का चयन करें और उन्हें नाम से सॉर्ट

List<User> topUsers = list.get(true); 
topUsers.sort((u1, u2) -> u1.getName().compareTo(u2.getName())); 

का चयन करें और से उन्हें सॉर्ट नाम:

List<User> restUsers = list.get(false); 
restUsers.sort((u1, u2) -> u1.getName().compareTo(u2.getName())); 

और यहाँ अंतिम सूची

topUsers.addAll(restUsers); 
users=(ArrayList<User>)topUsers;