有没有更简洁的方法来编写这个 Java 代码？

Question

This foo that is returned by lookup could be null .

That's why I'm trying to avoid calling foo.getFooStr() on a null value by first returning null if foo is null .

But is there a better (more concise) way to write this?

public static String getFooStr(String input)
{
    Foo foo = lookup(input);
    if(foo==null)
    {
        return null;
    }
    return foo.getFooStr();
}

Answer 1

You've two questions: is there a better way to write the code, and is there a more concise way to write the code.

Regarding more concise , this could work:

public static String getFooStr(String input) {
    Foo foo = lookup(input);          
    return foo == null ? null : foo.getFooStr();
}

Regarding better : I value readability over conciseness any day, and by a wide margin. Your original code looks fine to me. What matters is what looks good to you, and which is easier for you to understand and debug 3 months from now. I've heard someone say it best -- write your code so that is easily understandable by others, and even more importantly, by your future self.

Answer 2

为什么没有返回适当的 foo 字符串的lookup ？

Answer 3

I'm not into java, but I do like clean code... Source code should be easy to read and understand for humans - the machine doesn't care how it looks but your colleagues do. More concise code usually takes a moment or two longer to grasp (sometimes much longeer depending on the quantity and complexity). Keep code understandable and it will be maintainable (even if it is a bit more verbose)!

Answer 4

Groovy does it nicer .

return lookup(input)?.fooStr

or even just :

lookup(input)?.fooStr

Answer 5

For Java 7, at some point it was planned that you could just write this:

public static String getFooStr(String input)
{
    Foo foo = lookup(input);
    return foo?.getFooStr();
}

But until this feature is widely known, you will have to stick to the ?: operator.

Answer 6

I do not like multiple returns any where in any code. I will just change it to

public static String getFooStr(String input)
{
    Foo foo = lookup(input);
    String fooString;
    if(foo!=null)
    {
        fooString = foo.getFooStr();
    }
    return fooString;
}

Also the version from @Hovercraft Full Of Eels is good in my opinion but less readable but still a common way of doing.

Answer 7

在 Java8 中：

Optional.ofNullable(lookup(input)).map(f->f.getFooStr()).orElse(null);