11

我对番石榴和它的风格有点陌生。我肯定在挖掘它，但我一直绊倒的一件事是链式方法的顺序。我似乎遇到这个问题最多的地方是使用 Compound Orderings 时。我必须不断问自己以下问题：

  • 去哪儿natural？
  • nullFirst（或最后）去哪儿了？
  • 哪个nullsFirst做什么？（在下面的示例中，一个用于主机，一个用于姓氏，一个用于名字？）

这是我刚刚研究的一个例子。它看起来很麻烦，我只是不确定我是否把它们放在一起正确。我有一些 JUnit 来测试它，看起来还不错，但总是有那些古怪的边界情况。

Ordering<Host> lastNameThenFirstNameOrdering = Ordering.natural().nullsFirst().onResultOf(new Function<Host, String>() {
    public String apply(Host host) {
        return host.getLastName();
    }}).compound(Ordering.natural().nullsFirst().onResultOf(new Function<Host, String>() {
    public String apply(Host host) {
        return host.getFirstName();
    }})).nullsFirst();

至于一个实际的问题：这些事情如何执行是否有明确的规则？这似乎是从后到先的，但我很难说清楚。

编辑：只是想指出我试图替换的大而丑陋的代码：

    Ordering<Host> ordering2 = new Ordering<Host>() {
        public int compare(Host host1, Host host2) {
            if (host1 == null || host2 == null) {
                return host1 == host2 ? 0 : ((host1 == null) ? -1 : 1); 
            }
            if(host1.getLastName() != null || host2.getLastName() != null){
                if (host1.getLastName() == null) {
                    return -1;
                } else if (host2.getLastName() == null) {
                    return 1;
                }

                if (host1.getLastName().compareTo(host2.getLastName()) != 0) {
                    return host1.getLastName().compareTo(host2.getLastName());
                }
            }

            if (host1.getFirstName() == null) {
                return -1;
            } else if (host2.getFirstName() == null) {
                return 1;
            }

            return host1.getFirstName().compareTo(host2.getFirstName());
        }};
4

3 回答 3

25

我认为你的做法是正确的，但非常丑陋。试试这个以提高可读性：

使用枚举

将函数移动到实现Function<Host, String>. 每个枚举项都可以提供它自己的实现。

enum HostFunctions implements Function<Host, String>{
    GETFIRSTNAME{

        @Override
        public String apply(final Host host){
            return host.getFirstName();
        }
    },
    GETLASTNAME{

        @Override
        public String apply(final Host host){
            return host.getLastName();
        }
    }

}

缩进你的代码

现在引用这些枚举函数并正确缩进您的代码。这就是它的样子：

final Ordering<Host> orderingByLastAndFirstName =
    Ordering
        .natural()
        .nullsFirst()
        .onResultOf(HostFunctions.GETLASTNAME)
        .compound(
            Ordering
                .natural()
                .nullsFirst()
                .onResultOf(HostFunctions.GETFIRSTNAME))
        .nullsFirst();

我会说这让一切变得更容易理解。

IDE 配置

关于正确的缩进（至少如果您使用 Eclipse），请参阅这个问题：

如何用eclipse“正确”缩进流畅的界面模式？

枚举作为函数

关于枚举：这称为枚举单例模式。Guava 家伙在他们的代码库中使用它。在 wikipedia或Effective Java的 Item 3 中阅读有关它的内容。虽然这些资料都谈到了单项枚举，但这里的方法几乎相同。

于 2011-02-11T13:00:18.303 回答
11

每个链接调用都将先前的顺序“包装”成一个新的顺序，所以你是对的，执行顺序可以被认为是“向后”。

我编写并查看了 Ordering 类，但我仍然不得不经常停下来，为 nullsFirst()、onResultOf() 和 reverse() 的正确交错而挠头！

于 2011-02-11T18:55:08.457 回答
9

以下是我这样做的偏好，假设您必须能够处理null主机、名字和姓氏。对我来说，似乎非null名字和姓氏应该是Host班级的要求。而且您通常应该尽量避免允许集合包含null对象。

Ordering<Host> lastNameFirstNameOrdering = new Ordering<Host>() {
  @Override public int compare(Host left, Host right) {
    return ComparisonChain.start()
      .compare(left.getLastName(), right.getLastName(), Ordering.natural().nullsFirst())
      .compare(left.getFirstName(), right.getFirstName(), Ordering.natural().nullsFirst())
      .result();
  }
}.nullsFirst();

或者，我会采用类似于 Sean 的方法，但为了可读性而将其分解。

Ordering<Host> lastNameOrder = Ordering.natural().nullsFirst()
    .onResultOf(Host.LAST_NAME);
Ordering<Host> firstNameOrder = Ordering.natural().nullsFirst()
    .onResultOf(Host.FIRST_NAME);
Ordering<Host> orderingByLastAndFirstName =
     lastNameOrder.compound(firstNameOrder).nullsFirst();

请记住，您还可以使这些单独的排序成为类的静态最终字段，从而允许您在排序时轻松地在任何地方使用它们，例如Host.LAST_NAME_ORDER.

于 2011-02-11T20:51:00.030 回答