जावा एक तुलनित्र ऑब्जेक्ट के रूप में स्ट्रिंग तुलना करें

Question

मैं स्ट्रिंग के माध्यम से तारों की स्थिर सरणी को सॉर्ट करना और द्विआधारी करना चाहता हूं। तुलना करने के लिए तुलनात्मक रूप से।

समस्या यह है कि सॉर्टिंग और बाइनरी खोज दोनों की आवश्यकता होती है कि एक तुलनात्मक वस्तु को पारित किया जाए - तो मैं अंतर्निहित स्ट्रिंग तुलनित्र में कैसे पास करूं?

Answer 1

Arrays वर्ग sort() और binarySearch() के संस्करणों जो एक Comparator. उदाहरण के लिए की आवश्यकता नहीं है, तो आप the version of Arrays.sort() which just takes an array of objects उपयोग कर सकते हैं। ये विधियां सरणी में ऑब्जेक्ट्स की compareTo() विधि को कॉल करती हैं।

Answer 2

आप yourslef एक Comparator की आवश्यकता होगी, मिलती है, तो अपने स्वयं के तुलनित्र

public class ExampleComparator implements Comparator<String> { 
    public int compare(String obj1, String obj2) { 
    if (obj1 == null) { 
     return -1; 
    } 
    if (obj2 == null) { 
     return 1; 
    } 
    if (obj1.equals(obj2)) { 
     return 0; 
    } 
    return obj1.compareTo(obj2); 
    } 
} 

Answer 3

लिख सकते हैं, और आप पहले से ही Guava उपयोग करते हैं, आप Ordering.natural() उपयोग कर सकते हैं।

Answer 4

यह Comparable वस्तु के किसी भी प्रकार के लिए एक सामान्य Comparator, नहीं है सिर्फ String:

package util; 

import java.util.Comparator; 

/** 
* The Default Comparator for classes implementing Comparable. 
* 
* @param <E> the type of the comparable objects. 
* 
* @author Michael Belivanakis (michael.gr) 
*/ 
public final class DefaultComparator<E extends Comparable<E>> implements Comparator<E> 
{ 
    @SuppressWarnings("rawtypes") 
    private static final DefaultComparator<?> INSTANCE = new DefaultComparator(); 

    /** 
    * Get an instance of DefaultComparator for any type of Comparable. 
    * 
    * @param <T> the type of Comparable of interest. 
    * 
    * @return an instance of DefaultComparator for comparing instances of the requested type. 
    */ 
    public static <T extends Comparable<T>> Comparator<T> getInstance() 
    { 
     @SuppressWarnings("unchecked") 
     Comparator<T> result = (Comparator<T>)INSTANCE; 
     return result; 
    } 

    private DefaultComparator() 
    { 
    } 

    @Override 
    public int compare(E o1, E o2) 
    { 
     if(o1 == o2) 
      return 0; 
     if(o1 == null) 
      return 1; 
     if(o2 == null) 
      return -1; 
     return o1.compareTo(o2); 
    } 
} 

कैसे String साथ उपयोग करने के लिए:

Comparator<String> stringComparator = DefaultComparator.getInstance(); 

Answer 5

इसके अलावा, अगर आप केस-संवेदी तुलना करना चाहते हैं, जावा के हाल के संस्करणों में String कक्षा में public static final फ़ील्ड CASE_INSENSITIVE_ORDER नामक फ़ील्ड है जो Comparator<String> प्रकार है, जैसा कि मैंने अभी हाल ही में पाया है। तो, आप String.CASE_INSENSITIVE_ORDER का उपयोग करके अपना काम पूरा कर सकते हैं।

Answer 6

फिर से, Arrays.binarySearch(Object[] a, Object key) के लिए तुलनित्र की आवश्यकता नहीं है जब तक कि वस्तुओं के प्रकार तुलनीय हैं, लेकिन लैम्ब्डा अभिव्यक्तियों के साथ यह अब आसान तरीका है। String::compareTo

उदाहरण के लिए::

सीधे शब्दों में विधि संदर्भ के साथ तुलनित्र की जगह

Arrays.binarySearch(someStringArray, "The String to find.", String::compareTo); 

तुम भी

Arrays.binarySearch(someStringArray, "The String to find.", (a,b) -> a.compareTo(b)); 

इस्तेमाल कर सकते हैं लेकिन फिर भी lambdas से पहले, वहाँ हमेशा गुमनाम वर्गों थे:

Arrays.binarySearch(
       someStringArray, 
       "The String to find.", 
       new Comparator<String>() { 
        @Override 
        public int compare(String o1, String o2) { 
         return o1.compareTo(o2); 
        } 
       }); 

Answer 7

हम असंवेदनशील क्रम में स्ट्रिंग की तुलना करने के लिए स्ट्रिंग.CASE_INSENSITIVE_ORDER तुलनित्र का उपयोग कर सकते हैं। जावा 8 java.util.Comparator.comparing(...) के आधार पर के लिए

Arrays.binarySearch(someStringArray, "The String to find.",String.CASE_INSENSITIVE_ORDER); 

Answer 8

समाधान:

Comparator<String> c = Comparator.comparing(String::toString); 

या

Comparator<String> c = Comparator.comparing((String x) -> x); 

Answer 9

के बारे में Nambari के answer कहीं कोई गलती हुई।आप डबल बराबर के चिह्न का उपयोग कर == कार्यक्रम विधि की तुलना तक पहुँचने कभी नहीं होगा, जब तक कि कोई नई कीवर्ड का उपयोग स्ट्रिंग वस्तु जो सबसे अच्छा अभ्यास नहीं है बनाने के लिए होगा मूल्यों की तुलना करते हैं। यह थोड़ा बेहतर समाधान हो सकता है:

public int compare(String o1, String o2) { 
     if (o1 == null && o2 == null){return 0;} 
     if (o1 == null) { return -1;} 
     if (o2 == null) { return 1;} 
     return o1.compareTo(o2); 
    } 

पीएस टिप्पणी के लिए धन्यवाद;)

Answer 10

String.CASE_INSENSITIVE_ORDER साथ माइक Nakis का अच्छा जवाब सामान्यीकरण करने के लिए, आप भी उपयोग कर सकते हैं:

Collator.getInstance(); 

देखें Collator

Answer 11

ठीक है यह कुछ साल बाद है, लेकिन जावा 8 के साथ आप Comparator.naturalOrder() का उपयोग कर सकते हैं:

http://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#naturalOrder--

जावाडोक से:

static <T extends Comparable<? super T>> Comparator<T> naturalOrder() 

एक तुलनित्र लौटाता है जो प्राकृतिक क्रम में तुलनात्मक वस्तुओं की तुलना करता है। लौटा हुआ तुलनित्र धारावाहिक है और शून्य की तुलना करते समय NullPointerException फेंकता है।