I would like to sort and binary search a static array of strings via the String.CompareTo comparator.
The problem is that both sorting, and binary searching requires that a Comparator object be passed in -- So how do I pass in the built in string comparator?
您可以编写自己的比较器
public class ExampleComparator implements Comparator<String> {
public int compare(String obj1, String obj2) {
if (obj1 == obj2) {
return 0;
}
if (obj1 == null) {
return -1;
}
if (obj2 == null) {
return 1;
}
return obj1.compareTo(obj2);
}
}
基于java.util.Comparator.comparing(...)的 Java 8 解决方案：
Comparator<String> c = Comparator.comparing(String::toString);
或者
Comparator<String> c = Comparator.comparing((String x) -> x);
该类Arrays具有不需要的版本例如，您可以使用sort()仅需要对象数组的版本。这些方法调用数组中对象的方法。binarySearch()Comparator.Arrays.sort()compareTo()
如果您确实发现自己需要一个Comparator，并且您已经在使用Guava，您可以使用Ordering.natural()。
好的，这是几年后的事了，但是使用 java 8，您可以使用 Comparator.naturalOrder()：
http://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#naturalOrder--
来自 javadoc：
static <T extends Comparable<? super T>> Comparator<T> naturalOrder()
返回按自然顺序比较 Comparable 对象的比较器。返回的比较器是可序列化的，并在比较 null 时抛出 NullPointerException。
Comparator这对于任何类型的对象都是通用的Comparable，而不仅仅是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();
Arrays.binarySearch(Object[] a, Object key)同样，只要对象的类型具有可比性，就不需要比较器，但是使用 lambda 表达式现在更容易了。
只需将比较器替换为方法参考：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);
}
});
此外，如果您想要不区分大小写的比较，在最近的 Java 版本中，String该类包含一个public static final名为CASE_INSENSITIVE_ORDERwhich is of type的字段Comparator<String>，正如我最近发现的那样。因此，您可以使用String.CASE_INSENSITIVE_ORDER.
我们可以使用 String.CASE_INSENSITIVE_ORDER 比较器以不区分大小写的顺序比较字符串。
Arrays.binarySearch(someStringArray, "The String to find.",String.CASE_INSENSITIVE_ORDER);
您可以使用StringUtils.compare("a", "b")
关于南巴里的回答，有一个错误。如果您使用双等号==比较值，程序将永远不会到达 compare 方法，除非有人会使用new关键字来创建 String 对象，这不是最佳做法。这可能是一个更好的解决方案：
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);
}
PS 感谢您的评论；）