Java87自制多糖-switch

背景

JDK 12 和 JDK 13 已经发布了，伴随着许多对 Java 语法的小改进，比如我们非常熟悉的 switch：

JDK12 之前

switch (type) {
    case "all":
        System.out.println("列出所有帖子");
        break;
    case "auditing":
        System.out.println("列出审核中的帖子");
        break;
    case "accepted":
        System.out.println("列出审核通过的帖子");
        break;
    case "rejected":
        System.out.println("列出审核不通过的帖子");
        break;
    default:
        System.out.println("参数'type'错误，请检查");
        break;
}

JDK12

switch (type) {case "all" -> System.out.println("列出所有帖子");
    case "auditing" -> System.out.println("列出审核中的帖子");
    case "accepted" -> System.out.println("列出审核通过的帖子");
    case "rejected" -> System.out.println("列出审核不通过的帖子");
    default -> System.out.println("参数'type'错误，请检查");
}

JDK13

String value = switch (i) {
    case  0 -> "zero"
    case  1 -> "one"
    case  2 -> "two"
    default -> "many"
};

新特性很美好，但是如今在业界最流行的版本依然是 JDK8，所以想要在生产环境用上这么舒服的 switch，目前看来还是遥遥无期。好在我们还有 Lambda，正所谓“自己动手，丰衣足食”，我们来试试能不能自己做出一个和 JDK12 & JDK13 的 swtich 类似的东西，好给我们平淡的编码生活，加点糖。

实现

对标 JDK12 的 switch

首先，我们定义一个 Switch 类，然后它接收一个泛型参数，就类似与 Java 的 switch 语句，需要接受一个参数。

public class Switch<T> {
    
    private final T input;
    
    private Switch(T input) {this.input = input;}
    
    public static <T> Switch<T> on(T input) {return new Switch<>(input);
    }   
}

通过静态方法 on，我们可以构造出一个 Switch。然后，我们定义一个 Predicate，用来表示当前的条件：

public class Switch<T> {

    private final T input;

    private Predicate<T> condition;

    private Switch(T input) {this.input = input;}

    public static <T> Switch<T> on(T input) {return new Switch<>(input);
    }

    public Switch<T> is(T target) {
        // 判断待检测目标是否和 target 相等
        condition = Predicate.isEqual(target);
        return this;
    }
}

is 方法的作用就是将当前的条件 condition 定义为 判断判断待检测目标是否和传入的 target 相等 。既然都引入条件了，自然我们可以让用户自己来定义条件：

public Switch<T> when(Predicate<T> condition) {Objects.requireNonNull(condition);

    this.condition = condition;
    return this;
}

接着我们就可以来定义 switch 语句中的 case ... break 功能：

public Switch<T> thenAccept(Consumer<T> action) {Objects.requireNonNull(action);

    if (condition == null) {throw new IllegalStateException("A condition must be set first.");
    }

    if (condition.test(input)) {action.accept(input);
    }

    return this;
}

好像有点不对劲？对哦，switch 只能满足一个 case，如果是我们自己来设定条件，可能会存在多个条件都满足的情况 —— 那就不是我们预期的 switch 了。我们可以定义一个 boolean 标记，用来表示用户设定的多个条件是否存在某一个满足，如果有一个满足了，则链式调用后面的消费方法都直接短路处理。

public class Switch<T> {
        
      ...
      
    /**
     * 是否已经存在过满足的条件
     */
    private boolean accepted;

    public Switch<T> is(T target) {if (!accepted) {
            // 判断待检测目标是否和 target 相等
            condition = Predicate.isEqual(target);
        }

        return this;
    }

    public Switch<T> when(Predicate<T> condition) {Objects.requireNonNull(condition);

        if (!accepted) {this.condition = condition;}

        return this;
    }

    public Switch<T> thenAccept(Consumer<T> action) {Objects.requireNonNull(action);

        if (condition == null) {throw new IllegalStateException("A condition must be set first.");
        }

        if (!accepted && condition.test(input)) {action.accept(input);

            // 标记已经存在过满足的条件
            accepted = true;
        }

        return this;
    }
}

好像还少了点什么？对哦，switch 还有个 default ... break。我们定义一个 elseAccept 方法，当且仅当之前没有任何一个条件被满足时，调用这个方法：

public void elseAccept(Consumer<T> action) {Objects.requireNonNull(action);

    // 之前没有任何一个条件被满足
    if (!accepted) {action.accept(input);
    }
}

OK，我们来写个小 demo 对比感受一下：

public class Demo {public static void main(String[] args) {
        // 获得前端传递的某个参数
        String type = getType();

        switch (type) {
            case "all":
                System.out.println("列出所有帖子");
                break;
            case "auditing":
                System.out.println("列出审核中的帖子");
                break;
            case "accepted":
                System.out.println("列出审核通过的帖子");
                break;
            case "rejected":
                System.out.println("列出审核不通过的帖子");
                break;
            default:
                System.out.println("参数'type'错误，请检查");
                break;
        }

        Switch.on(type)
                .is("all")
                .thenAccept(t -> System.out.println("列出所有帖子"))
                .is("auditing")
                .thenAccept(t -> System.out.println("列出审核中的帖子"))
                .is("accepted")
                .thenAccept(t -> System.out.println("列出审核通过的帖子"))
                .is("rejected")
                .thenAccept(t -> System.out.println("列出审核不通过的帖子"))
                .elseAccept(t -> System.out.println("参数'type'错误，请检查"));

    }
}

我们的 Switch 看起来没有 JDK12 的 switch 那样简单，但是比 JDK12 之前的 switch 语句简洁了 —— 而且链式调用，配合 Lambda，写起来更舒服了~ 更重要的是，我们都知道 switch 语句支持的类型有限（整数、枚举、字符串），而我们自定义的 Switch，支持任何类型，比如：

Object value = getValue();

Switch.on(value)
        .is(null)
        .thenAccept(v -> System.out.println("value is null"))
        .is(123)
        .thenAccept(v -> System.out.println("value is 123"))
        .is("abc")
        .thenAccept(v -> System.out.println("value is abc"))
        .is(Arrays.asList(1, 2, 3))
        .thenAccept(v -> System.out.println("value is [1, 2, 3]"))
        .elseAccept(v -> System.out.println("Unknown value"));

而且我们还支持自定义条件语句，所以很显然，我们的 Switch 可以用来代替 if-else 语句：

Object value = getValue();

Switch.on(value)
        .is(null)
        .thenAccept(v -> System.out.println("value is null"))
        .when(v -> v instanceof Integer)
        .thenAccept(v -> System.out.println("value is Integer"))
        .when(v -> v instanceof String)
        .thenAccept(v -> System.out.println("value is String"))
        .when(v -> v instanceof Boolean)
        .thenAccept(v -> System.out.println("value is Boolean"))
        .elseAccept(v -> System.out.println("Unknown type of value"));

// 等价的 if-else
if (value == null) {System.out.println("value is null");
} else if (value instanceof Integer) {System.out.println("value is Integer");
} else if (value instanceof String) {System.out.println("value is String");
} else if (value instanceof Boolean) {System.out.println("value is Boolean");
} else {System.out.println("Unknown type of value");
}

至于哪个更好用和阅读起来更舒服，就“仁者见仁，智者见智”了。

对标 JDK13 的 Switch

JDK13 中，是赋予了 switch 语句求值的功能。当然，我们也可以很容易的改造我们的 Switch 来支持这个功能。首先，加入返回值的泛化类型：

public class Switch<T, R> {

    private final T input;
    private R output;

    /**
     * 是否已经存在输出
     */
    private boolean outputted;
}

然后加入两个方法，用来满足条件时求值和不满足任意条件时求值：

public Switch<T, R> thenGet(R value) {if (condition == null) {throw new IllegalStateException("A condition must be set first.");
    }

    // 满足条件
    if (!outputted && condition.test(input)) {
        output = value;
      
        // 标记已经存在输出
        outputted = true;
    }

    return this;
}

public R elseGet(R value) {return outputted ? output : value;}

同样，写个 demo 看看效果：

int k = getNum();

String value = Switch.on(k)
        .is(0).thenGet("zero")
        .is(1).thenGet("one")
        .is(2).thenGet("two")
        .elseGet("many");

System.out.println(value);

然而，编译不过 —— 因为 Java 推导不出返回值的类型 —— 哎，Java 的泛型啊 … 没办法，加入点东西“示意”一下吧：

public static <T, R> Switch<T, R> on(T input, Class<R> outType) {return new Switch<>(input);
}

即告诉 Java 编译器我们要返回的类型：

int num = getNum();

String value = Switch.on(num, String.class)
        .is(0).thenGet("zero")
        .is(1).thenGet("one")
        .is(2).thenGet("two")
        .elseGet("many");

System.out.println(value);

对比下 JDK13：

int num = getNum();

String value = switch (num) {
    case  0 -> "zero"
    case  1 -> "one"
    case  2 -> "two"
    default -> "many"
}

System.out.println(value);

除了要指定下返回值的类型，二者功能一致；虽然没有 JDK13 简洁，但是我们的 Switch 看起来也非常的直观。而且我们可以引入函数来进一步增强我们的 Switch 的求值功能：

public Switch<T, R> thenApply(Function<T, R> mapper) {Objects.requireNonNull(mapper);

    if (condition == null) {throw new IllegalStateException("A condition must be set first.");
    }

    if (!outputted && condition.test(input)) {output = mapper.apply(input);
        
        // 标记已经存在输出
        outputted = true;
    }
    
    return this;
}

写个 demo：

long getLongValueWithIfElse(Object value) {if (value instanceof Long) {return ((Long) value);
    }

    if (value instanceof Integer) {return ((Integer) value).longValue();}

    if (value instanceof String) {return Long.parseLong((String) value);
    }

    if (value instanceof BigInteger) {return ((BigInteger) value).longValue();}

    if (value instanceof BigDecimal) {return ((BigDecimal) value).longValue();}

    return Long.MIN_VALUE;
}

long getLongValueWithSwitch(Object value) {return Switch.on(value, Long.class)

            .when(Long.class::isInstance)
            .thenApply(Long.class::cast)
            
            .when(Integer.class::isInstance)
            .thenApply(v -> ((Integer) v).longValue())

            .when(String.class::isInstance)
            .thenApply(v -> Long.parseLong((String) v))

            .when(BigInteger.class::isInstance)
            .thenApply(v -> ((BigInteger) v).longValue())

            .when(BigDecimal.class::isInstance)
            .thenApply(v -> ((BigDecimal) v).longValue())

            .elseGet(Long.MAX_VALUE);
}

扩展

大家还有什么改进和想法呢，欢迎评论交流~