Java nhận String CompareTo như một đối tượng so sánh

Question

Tôi muốn sắp xếp và tìm kiếm nhị phân một mảng tĩnh của chuỗi thông qua bộ so sánh String.CompareTo.

Vấn đề là cả phân loại và tìm kiếm nhị phân yêu cầu đối tượng Comparator được chuyển vào - Vậy làm cách nào để vượt qua trong trình so sánh chuỗi dựng sẵn?

Answer 1

Lớp Arrays có các phiên bản của sort() và binarySearch() mà không đòi hỏi một Comparator. Ví dụ, bạn có thể sử dụng the version of Arrays.sort() which just takes an array of objects. Các phương thức này gọi phương thức compareTo() của các đối tượng trong mảng.

Answer 2

Bạn có thể viết so sánh của riêng bạn

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

Nếu bạn tìm yourslef cần một Comparator, và bạn đã sử dụng Guava, bạn có thể sử dụng Ordering.natural().

Answer 4

Đây là một generic Comparator cho bất kỳ loại Comparable đối tượng, không chỉ 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); 
    } 
} 

Làm thế nào để sử dụng với String:

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

Answer 5

Ngoài ra, nếu bạn muốn so sánh case-insensitive, trong các phiên bản Java gần đây của lớp String có trường public static final được gọi là CASE_INSENSITIVE_ORDER thuộc loại Comparator<String>, như tôi vừa mới phát hiện ra. Vì vậy, bạn có thể hoàn thành công việc của mình bằng cách sử dụng String.CASE_INSENSITIVE_ORDER.

Answer 6

Một lần nữa, không cần so sánh cho Arrays.binarySearch(Object[] a, Object key) miễn là các loại đối tượng có thể so sánh được, nhưng với các biểu thức lambda thì cách này dễ dàng hơn.

Đơn giản chỉ cần thay thế so sánh với các tài liệu tham khảo phương pháp: String::compareTo

Ví dụ:

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

Bạn cũng có thể sử dụng

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

nhưng ngay cả trước khi lambdas, luôn có lớp vô danh:

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

Answer 7

Chúng tôi có thể sử dụng trình so sánh String.CASE_INSENSITIVE_ORDER để so sánh các chuỗi theo thứ tự không phân biệt chữ hoa chữ thường.

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

Answer 8

Giải pháp cho Java 8 dựa trên java.util.Comparator.comparing(...):

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

hoặc

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

Answer 9

Về Nambari của answer đã có một sai lầm.Nếu bạn so sánh giá trị sử dụng đôi dấu bằng chương trình == sẽ không bao giờ đạt được phương pháp so sánh, trừ khi ai đó sẽ sử dụng mới từ khóa để tạo đối tượng String mà không phải là thực hành tốt nhất. Đây có thể là giải pháp tốt hơn một chút:

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

P.S. Cảm ơn ý kiến;)

Answer 10

Để khái quát những câu trả lời tốt của Mike Nakis với String.CASE_INSENSITIVE_ORDER, bạn cũng có thể sử dụng:

Collator.getInstance(); 

Xem Collator

Answer 11

Ok đây là một vài năm sau đó nhưng với java 8 bạn có thể sử dụng Comparator.naturalOrder():

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

Từ javadoc:

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

Trả về một bộ so sánh so sánh Các đối tượng có thể so sánh theo thứ tự tự nhiên. Bộ so sánh được trả về có thể tuần tự hóa và ném NullPointerException khi so sánh null.