设计模式第九讲：常见重构技巧 - 去除不必要的!=

private void xxxMethod(String key){
    if(key != null && !"".equals(key)){
        // do something
    }
}

private void xxxMethod(String key){
    if(StringUtils.isNotEmpty(key)){
        // do something
    }
}

private void xxxMethod(String key){
    Assert.notNull(key);
    // do something
}

/**
    * 是否有效身份证号
    *
    * @param idCard 身份证号，支持18位、15位和港澳台的10位
    * @return 是否有效
    */
public static boolean isValidCard(String idCard) {
    idCard = idCard.trim();// 这里idCard没判断空
    int length = idCard.length();
    switch (length) {
        case 18:// 18位身份证
            return isValidCard18(idCard);
        case 15:// 15位身份证
            return isValidCard15(idCard);
        case 10: {// 10位身份证，港澳台地区
            String[] cardVal = isValidCard10(idCard);
            return null != cardVal && "true".equals(cardVal[2]);
        }
        default:
            return false;
    }
}

/**
    * Copy bytes from a <code>byte[]</code> to an <code>OutputStream</code>.
    * @param input the byte array to read from
    * @param output the <code>OutputStream</code> to write to
    * @throws IOException In case of an I/O problem
    */
public static void copy(final byte[] input, final OutputStream output)
        throws IOException {
    output.write(input);
}

public interface Action {
    void doSomething();
}
public interface Parser {
    Action findAction(String userInput);
}

public class MyParser implements Parser {
    private static Action NO_ACTION = new Action() {
        public void doSomething() { /* do nothing */ }
    };
    public Action findAction(String userInput) {
        // ...
        if ( /* we can't find any actions */ ) {
            return NO_ACTION;
        }
    }
}

Parser parser = ParserFactory.getParser();
if (parser == null) {
    // now what?
    // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
    // do nothing} 
else {
    action.doSomething();
}

ParserFactory.getParser().findAction(someInput).doSomething();

class Outer {
    Nested nested;
    Nested getNested() {
        return nested;
    }
}
class Nested {
    Inner inner;
    Inner getInner() {
        return inner;
    }
}
class Inner {
    String foo;
    String getFoo() {
        return foo;
    }
}

Outer outer = new Outer();
if (outer != null && outer.nested != null && outer.nested.inner != null) {
    System.out.println(outer.nested.inner.foo);
}

Optional.of(new Outer())
    .map(Outer::getNested)
    .map(Nested::getInner)
    .map(Inner::getFoo)
    .ifPresent(System.out::println);

Outer obj = new Outer();
resolve(() -> obj.getNested().getInner().getFoo())
    .ifPresent(System.out::println);

public static <T> Optional<T> resolve(Supplier<T> resolver) {
    try {
        T result = resolver.get();
        return Optional.ofNullable(result);
    }
    catch (NullPointerException e) {
        return Optional.empty();
    }
}