如何使用比较器比较空值？

Question

我有几个比较器——一个用于日期，一个用于小数，一个用于百分比，等等。

开始我的小数比较器看起来像这样：

class NumericComparator implements Comparator<String> {

  @Override
  public int compare(String s1, String s2) {
    final Double i1 = Double.parseDouble(s1);
    final Double i2 = Double.parseDouble(s2);
    return i1.compareTo(i2);
  }

}

一 简单的。当然，这不能处理字符串不可解析的情况。所以我改进了 compare()：

class NumericComparator implements Comparator<String> {

  @Override
  public int compare(String s1, String s2) {
    final Double i1;
    final Double i2;

    try {
      i1 = Double.parseDouble(s1);
    } catch (NumberFormatException e) {
      try {
        i2 = Double.parseDouble(s2);
      } catch (NumberFormatException e2) {
        return 0;
      }
      return -1;
    }
    try {
      i2 = Double.parseDouble(s2);
    } catch (NumberFormatException e) {
      return 1;
    }

    return i1.compareTo(i2);
  }
}

生活变得更好了。测试感觉更扎实。然而，我的代码审阅者指出，“null 怎么样？”

太棒了，所以现在我必须使用 NullPointerException 重复上述内容，或者在方法主体前面加上：

if (s1 == null) {
  if (s2 == null) {
    return 0;
  } else {
    return -1;
  }
} else if (s2 == null) {
  return 1;
}

这个方法很大。最糟糕的是，我需要与其他三个类重复此模式，这些类比较不同类型的字符串，并可能在解析时引发其他三个异常。

我不是 Java 专家。有没有比复制和粘贴更干净、整洁的解决方案？只要有记录，我是否应该用正确性来换取不复杂性？

---

更新：有些人认为处理 null 值不是 Comparator 的工作。由于排序结果显示给用户，我确实希望对空值进行一致排序。

Answer 1

您正在实现一个Comparator。 String 的方法（包括 compareTo）如果向它们传递 null，则会抛出 NullPointerException，所以您也应该这么做。同样，如果参数的类型阻止进行比较，Comparator 会抛出 ClassCastException。我建议您实现这些继承的行为。

class NumericComparator implements Comparator<String> {

  public int compare(String s1, String s2) {
    final Double i1;
    final Double i2;
    if(s1 == null)
    {
      throw new NullPointerException("s1 is null"); // String behavior
    }
    try {
      i1 = Double.parseDouble(s1)
    } catch (NumberFormatException e) {
      throw new ClassCastException("s1 incorrect format"); // Comparator  behavior
    }

    if(s2 == null)
    {
      throw new NullPointerException("s2 is null"); // String behavior
    }
    try {
      i2 = Double.parseDouble(s1)
    } catch (NumberFormatException e) {
      throw new ClassCastException("s2 incorrect format"); // Comparator  behavior
    }
    return i1.compareTo(i2);
  }
}

通过提取方法来进行类型检查和转换，你几乎可以恢复原来的优雅。

class NumericComparator implements Comparator<String> {

  public int compare(String s1, String s2) {
    final Double i1;
    final Double i2;

    i1 = parseStringAsDouble(s1, "s1");
    i2 = parseStringAsDouble(s2, "s2");
    return i1.compareTo(i2);
  }

  private double parseStringAsDouble(String s, String name) {

    Double i;
    if(s == null) {
      throw new NullPointerException(name + " is null"); // String behavior
    }
    try {
      i = Double.parseDouble(s1)
    } catch (NumberFormatException e) {
      throw new ClassCastException(name + " incorrect format"); // Comparator  behavior
    }
    return i;
  }
}

如果您不特别关注异常消息，则可能会丢失“name”参数。我相信你可以通过应用一些小技巧来失去这里多余的一行或那里多余的单词。

您说您需要与其他三个类重复此模式，这些类比较不同类型的字符串并可能引发其他三个异常。在没有看到情况的情况下很难提供具体细节，但是您可以使用 "Pull Up 方法” 将我的 parseStringAsDouble 版本转换为 NumericComparator 的共同祖先，它本身实现了 java 的 Comparator。

Answer 2

这个问题有很多主观答案。这是我自己的 0.02 美元。

首先，您所描述的问题是缺乏一流函数的语言的典型症状，这将使您能够简洁地描述这些模式。

其次，在我看来，如果其中一个字符串不能被视为双精度数的表示，那么将两个字符串作为双精度数进行比较应该是错误的。 （对于空值等也是如此）因此，您应该允许异常传播！我预计这将是一个有争议的观点。

Answer 3

以下是我改进比较器的方法：

首先，提取用于转换值的方法。它被重复，多次尝试...捕获总是丑陋的 ->最好是尽可能少的。

private Double getDouble(String number) {
 try {
  return Double.parseDouble(number);
 } catch(NumberFormatException e) {
  return null;
 }
}

接下来，写下简单的规则来显示您希望比较器的流程如何。

if i1==null && i2!=null return -1
if i1==null && i2==null return 0
if i1!=null && i2==null return 1
if i1!=null && i2!=null return comparison

最后对实际比较器进行可怕的混淆，以在代码审查中引发一些WTF：（或者像其他人喜欢说的那样，“实现比较器”）：

class NumericComparator implements Comparator<String> {

     public int compare(String s1, String s2) {
      final Double i1 = getDouble(s1);
      final Double i2 = getDouble(s2);

      return (i1 == null) ? (i2 == null) ? 0 : -1 : (i2 == null) ? 1 : i1.compareTo(i2);
     }
     private Double getDouble(String number) {
          try {
               return Double.parseDouble(number);
          } catch(NumberFormatException e) {
               return null;
          }
     }
}

...是的，这是一个分支嵌套三元。如果有人对此抱怨，请说出这里其他人的说法：处理 null 不是 Comparator 的工作。

Answer 4

您可以创建一个实用程序方法来处理解析并在出现空值或解析异常时返回特定值。

Answer 5

退一步。这些字符串从哪里来？这个Comparator有什么用？您是否有想要排序的字符串的集合？

Answer 6

试试这个：

import com.google.common.base.Function;
import com.google.common.collect.Ordering;

Ordering.nullsFirst().onResultOf(
    new Function<String, Double>() {
      public Double apply(String s) {
      try {
        return Double.parseDouble(s);
      } catch (NumberFormatException e) {
        return null;
      }
    })

如果您认为的话，唯一的问题是空字符串和其他不可解析的字符串将全部混合在一起。考虑到好处，这可能不是什么大问题——这为您提供了一个保证正确的比较器，而使用手工编码的比较器，即使是相对简单的比较器，令人惊讶的是，很容易犯一个微妙的错误，从而破坏传递性，或者，嗯，反对称性。

http://google-collections.googlecode.com

Answer 7

似乎这里混合了两个问题，也许应该分解为单独的组件。请考虑以下事项：

public class ParsingComparator implements Comparator<String> {
  private Parser parser;

  public int compare(String s1, String s2) {
    Object c1 = parser.parse(s1);
    Object c2 = parser.parse(s2);
    new CompareToBuilder().append(c1, c2).toComparison();
  }
}

Parser 接口将具有数字、日期等的实现。您可能会为 Parser 接口使用 java.text.Format 类。如果您不想使用 commons-lang，可以将 CompareToBuilder 的使用替换为一些处理 null 的逻辑，并使用 Comparable 而不是 c1 和 c2 的 Object。

Answer 8

tl;dr: 从 JDK 获取指导。 Double 比较器没有为非数字或空值定义。让人们给你有用的数据（双打、日期、恐龙等等）并为此编写你的比较器。

据我所知，这是用户输入验证的情况。例如，如果您从对话框中获取输入，则确保您拥有可解析的字符串（Double、Date 或输入处理程序中的任何内容）的正确位置。在用户可以按 Tab 键离开、点击“确定”或类似操作之前，请确保一切正常。

这就是我这样认为的原因：

第一个问题：如果字符串无法解析为数字，我认为您试图在错误的位置解决问题。举例来说，我尝试将 "1.0" 与 "Two" 进行比较。第二个显然不能解析为 Double 但它比第一个小吗？或者说它更大。我认为用户应该先将他们的字符串转换为双精度数，然后再询问哪个更大（例如，您可以使用 Double.compareTo 轻松回答）。

第二个问题：如果字符串是 "1.0" 和 null，哪个更大？ JDK 源代码不处理比较器中的 NullPointerException：如果给它一个 null，自动装箱将失败。

最糟糕的是，我需要重复一遍
这个模式与其他三个类
比较不同类型的
字符串并可以提高另外三个
解析时出现异常。

正是为什么我认为解析应该在比较器之外进行，并在到达代码之前进行异常处理。

Answer 9

如果您能够更改签名，我建议您编写该方法，以便它可以接受任何支持的对象。

  public int compare(Object o1, Object o2) throws ClassNotFoundException {
      String[] supportedClasses = {"String", "Double", "Integer"};
      String j = "java.lang.";
      for(String s : supportedClasses){
          if(Class.forName(j+s).isInstance(o1) && Class.forName(j+s).isInstance(o1)){
              // compare apples to apples
              return ((Comparable)o1).compareTo((Comparable)o2);
          }
      }
      throw new ClassNotFoundException("Not a supported Class");
  }

您甚至可以递归地定义它，将字符串转换为双精度数，然后返回使用这些对象调用自身的结果。

Answer 10

恕我直言，您应该首先创建一个从字符串返回 Double 的方法，嵌入 null 并解析失败情况（但您必须定义在这种情况下要做什么：抛出异常？返回默认值？？）。

然后你的比较器只需要比较获得的 Double 实例。

换句话说，重构......

但我仍然想知道为什么你需要比较字符串，尽管期望它们代表双精度数。我的意思是，是什么阻止您在实际使用此比较器的代码中操作双精度数？

Answer 11

根据您的需求和 Ewan 的帖子，我认为有一种方法可以提取您可以重用的结构：

class NumericComparator implements Comparator<String> {
    private SafeAdaptor<Double> doubleAdaptor = new SafeAdaptor<Double>(){
        public Double parse(String s) {
            return Double.parseDouble(s);
        }
    };
    public int compare(String s1, String s2) {
        final Double i1 =doubleAdaptor.getValue(s1, "s1");
        final Double i2 = doubleAdaptor.getValue(s2, "s2");
        return i1.compareTo(i2);
    }
}

abstract class SafeAdaptor<T>{
    public abstract T parse(String s);
    public T getValue(String str, String name) {
        T i;
        if (str == null) {
            throw new NullPointerException(name + " is null"); // String
        }
        try {
            i = parse(str);
        } catch (NumberFormatException e) {
            throw new ClassCastException(name + " incorrect format"); // Comparator
        }
        return i;
    }

}

我将该方法提取为抽象类，可以在其他情况下重用（尽管类名很糟糕）。

干杯。

Answer 12

所以我改进了compare()...

当然你也这么做了。

首先，Comparator 接口没有指定空值会发生什么。如果您的 null 检查 if 语句适用于您的用例，那很好，但一般的解决方案是抛出 npe。

至于清洁剂...为什么是最终的？为什么所有的捕获/抛出？为什么使用compareTo作为原始包装器？

class NumericComparator implements Comparator<String> {
 public int compare(String s1, String s2) throws NullPointerException, NumberFormatException {

  double test = Double.parseDouble(s1) - Double.parseDouble(s2);

  int retVal = 0;
  if (test < 0) retVal = -1;
  else if (test > 0) retVal = 1;

  return retVal;  
 }
}

似乎您可能会发现将 test 重命名为 t1 并将 retVal 重命名为 q 更清晰。

至于重复模式...呃。您也许可以使用带有反射的泛型来调用适当的 parseX 方法。似乎这不值得。