昨天早上通过远程的方式 review 了两名新来同事的代码，大部分代码都写得很漂亮，严谨的同时注释也很到位，这令我非常满意。但当我看到他们当中有一个人写的 switch 语句时，还是忍不住破口大骂：“我擦，小王，你丫写的 switch 语句也太老土了吧！”

来看看小王写的代码吧，看完不要骂我装逼啊。

private static String createPlayer(PlayerTypes playerType) {
    switch (playerType) {
        case TENNIS:
            return "网球运动员费德勒";
        case FOOTBALL:
            return "足球运动员C罗";
        case BASKETBALL:
            return "篮球运动员詹姆斯";
        case UNKNOWN:
            throw new IllegalArgumentException("未知");
        default:
            throw new IllegalArgumentException(
                    "运动员类型: " + playerType);

    }
}

看完上述代码后，你是不是会发出这样的感慨——“代码写得很好，没有任何问题啊！”是不是觉得我在无事生非，错怪了小王！但此时我要送上《了不起的盖茨比》中的一句话：

我年纪还轻，阅历不深的时候，我父亲教导过我一句话，我至今还念念不忘。 “每逢你想要批评任何人的时候， ”他对我说，“你就记住，这个世界上所有的人，并不是个个都有过你拥有的那些优越条件。”

哈哈，这句话不光是让你看的，也是给我看的。是时候冷静下来谈谈上述 switch 语句的老土问题了。

看到上图了吧，当不小心删掉 default 语句后，编译器就会报错，提示：“没有返回语句”，为了解决这个问题，我们可以新建一个 player 变量作为返回结果，就像下面这样：

private static String createPlayer(PlayerTypes playerType) {
    String player = null;
    switch (playerType) {
        case TENNIS:
            player = "网球运动员费德勒";
            break;
        case FOOTBALL:
            player = "足球运动员C罗";
            break;
        case BASKETBALL:
            player = "篮球运动员詹姆斯";
            break;
        case UNKNOWN:
            throw new IllegalArgumentException("未知");
    }

    return player;
}

当添加了 player 变量后，case 语句中就需要添加上 break 关键字；另外在 switch 语句结束后，返回 player。这时候，编译器并不会提示任何错误，说明 default 语句在这种情况下是可以省略的。

从 JDK 12 开始（本例使用的是 JDK 13），switch 语句升级了，不仅可以像传统的 switch 语句那样作为条件的判断，还可以直接作为一个返回结果。来对小王的代码进行改造，如下所示：

private static String createPlayer(PlayerTypes playerType) {
   return switch (playerType) {
        case TENNIS -> "网球运动员费德勒";
        case FOOTBALL -> "足球运动员C罗";
        case BASKETBALL -> "篮球运动员詹姆斯";
        case UNKNOWN ->  throw new IllegalArgumentException("未知");
    };
}

够 fashion 吧？不仅 switch 关键字之前加了 return 关键字，case 中还见到了 Lambda 表达式的影子，中划线和箭头替代了冒号，意味着箭头右侧的代码只管执行无须 break。

并且，default 语句变成了可选项，可有可无，不信？你也动手试试。

新的 switch 语句足够的智能化，除了有上述的 3 个优势，还可以对枚举类型的条件进行校验。假如在 PlayerTypes 中增加了新的类型 PINGPANG（乒乓球）：

public enum PlayerTypes {
    TENNIS,
    FOOTBALL,
    BASKETBALL,
    PINGPANG,
    UNKNOWN
}

此时编译器会发出以下警告：

意思就是 switch 中的 case 条件没有完全覆盖枚举中可能存在的值。好吧，那就把 PINGPANG 的条件加上吧。来看一下完整的代码：

public class OldSwitchDemo {
    public enum PlayerTypes {
        TENNIS,
        FOOTBALL,
        BASKETBALL,
        PINGPANG,
        UNKNOWN
    }

    public static void main(String[] args) {
        System.out.println(createPlayer(PlayerTypes.BASKETBALL));
    }

    private static String createPlayer(PlayerTypes playerType) {
        return switch (playerType) {
            case TENNIS -> "网球运动员费德勒";
            case FOOTBALL -> "足球运动员C罗";
            case BASKETBALL -> "篮球运动员詹姆斯";
            case PINGPANG -> "乒乓球运动员马龙";
            case UNKNOWN -> throw new IllegalArgumentException("未知");
        };
    }
}

switch 语句变成了强大的 switch 表达式，美滋滋啊！那假如一个运动员既会打篮球又会打乒乓球呢？

private static String createPlayer(PlayerTypes playerType) {
    return switch (playerType) {
        case TENNIS -> "网球运动员费德勒";
        case FOOTBALL -> "足球运动员C罗";
        case BASKETBALL,PINGPANG -> "牛逼运动员沉默王二";
        case UNKNOWN -> throw new IllegalArgumentException("未知");
    };
}

就像上述代码那样，使用英文逗号“,”把条件分割开就行了，666 啊！

不服气？switch 表达式还有更厉害的，-> 右侧还可以是 {} 括起来的代码块，就像 Lambda 表达式那样。

private static String createPlayer(PlayerTypes playerType) {
    return switch (playerType) {
        case TENNIS -> {
            System.out.println("网球");
            yield "网球运动员费德勒";
        }
        case FOOTBALL -> {
            System.out.println("足球");
            yield "足球运动员C罗";
        }
        case BASKETBALL -> {
            System.out.println("篮球");
            yield "篮球运动员詹姆斯";
        }
        case PINGPANG -> {
            System.out.println("乒乓球");
            yield "乒乓球运动员马龙";
        }
        case UNKNOWN -> throw new IllegalArgumentException("未知");
    };
}

细心的同学会发现一个之前素未谋面的关键字 yield，它和传统的 return、break 有什么区别呢？

先来看官方的解释：

A yield statement transfers control by causing an enclosing switch expression to produce a specified value.

意思就是说 yield 语句通过使一个封闭的 switch 表达式产生一个指定值来转移控制权。为了进一步地了解 yield 关键字，我们可以反编译一下字节码：

private static String createPlayer(NewSwitchDemo3.PlayerTypes playerType) {
    String var10000;
    switch(playerType) {
        case TENNIS:
            System.out.println("网球");
            var10000 = "网球运动员费德勒";
            break;
        case FOOTBALL:
            System.out.println("足球");
            var10000 = "足球运动员C罗";
            break;
        case BASKETBALL:
            System.out.println("篮球");
            var10000 = "篮球运动员詹姆斯";
            break;
        case PINGPANG:
            System.out.println("乒乓球");
            var10000 = "乒乓球运动员马龙";
            break;
        case UNKNOWN:
            throw new IllegalArgumentException("未知");
        default:
            throw new IncompatibleClassChangeError();
    }

    return var10000;
}

编译器在生成字节码的时候对 yield 关键字做了自动化转义，转成了传统的 break 语句。这下清楚了吧？

但是，话又说出来，那些看似 fashion 的代码也不过是把部分秀技的工作交给了编译器，还可能存在对旧版本不兼容、对队友不友好的问题——代码土点就土点呗，没准是最实用的。

“不好意思，我为昨天早上的嚣张向你道歉。。。。。。”我向小王发送了一条信息。

好了，我亲爱的读者朋友，以上就是本文的全部内容了，希望能够博得你的欢心。

最后，一定会有不少读者想要问我怎么学习 Java 的，那我干脆就把我看过的优质书籍贡献出来：

1）入门版：《Head First Java》、《Java 核心技术卷》

2）进阶版：《Java编程思想》、《Effective Java》、《Java网络编程》、《代码整洁之道》

3）大牛版：《Java并发编程》、《深入理解Java虚拟机》、《Java性能权威指南》、《重构》、《算法》

就先介绍这么多，希望对那些不知道看什么书的同学有所帮助。

对了，我介绍的这些书籍，已经顺便帮你整理好了，你可以在我的原创微信公众号『沉默王二』回复『书籍』获取哦

有收获？希望老铁们来个三连击，给更多的同学看到这篇文章

在PCI-E之前的一代标准是PCI-X，那时候并没有Switch的概念，Fanout采用的是桥接的形式，形成一个树形结构，如上图中间所示。 Switch的概念是在PCI-E时代引入的，其相对于桥最大的一个本质区别就是同一个Bus内部的多个角色之间采用的是Switch交换而不是Bus。PCI-X时代真的是使用共享Bus传递数据，这就意味着仲裁，意味着低效率。然而，PCI-E保留了PCI-X体系的基本概念，比如依然沿用“Bus”这个词，以及“桥/Bridge”这个词，但是这两个角色都成为了虚拟角色。一个Switch相当于一个虚拟桥+虚拟Bus的集合体，每个虚拟桥（VB）之下只能连接一个端点设备（也就是最终设备/卡，End Point/EP）或者级联另外一个Switch，而不能连接到一个Bus，因为物理Bus已经没了。这种Fanout形式依然必须遵循树形结构，因为树形结构最简单，没有环路，不需要考虑复杂路由。 2.Partition分区功能相当于以太网Switch里的Vlan，相当于SAS Switch/Expander里的Zone。

如上图所示，两台或者多台机器，可以连接到同一片PCI-E Switch，在Switch做分区配置，将某些EP设备分配给某个服务器。这样可以做到统一管理，灵活分配。每台服务器的BIOS或者OS在枚举PCI-E总线时只会发现分配给它的虚拟桥、虚拟BUS、和EP。多个分区之间互不干扰。 多台独立服务器连接到同一片Switch上，如果不做Partition，是会出现问题的，因为两个OS会分别枚举同一堆PCI-E总线内的角色，并为其分配访问地址，此时会出现冲突。 3.NTB有些特殊场景下，比如传统存储系统中的多个控制器，它们之间需要同步很多数据和控制信息，希望使用PCI-E链路直接通信。问题是，图中的两台服务器并不可以直接通信，因为必须身处两个不同的分区中。为了满足这个需求，出现了NTB技术。其基本原理是地址翻译，因为两个不同的系统（术语System Image，SI）各有各的地址空间，是重叠的。那么只要 在PCI-E Switch内部将对应的数据包进行地址映射翻译，便可以实现双方通信。这种带有地址翻译的桥接技术叫做None Transparent Bridge，非透明桥。

基本功能1.Dynamic Partition上文中的分区配置必须是静态配置，必须在BIOS启动之前，也就是CPU加电之前，对PCI-E Switch进行分区配置，可以使用BMC做配置。分区配置好之后，在系统运行期间，不能够动态改变。这就意味着，某个PCI-E卡如果被分配到了服务器A，则其不能在不影响服务器A和B的运行前提下，被动态重新分配到服务器B。 PMC-Sierra公司Switchtec旗下的PCI-E Switch产品则支持动态分配。具体的实现手段笔者就不能透露了。不过，对于内行开发者来讲，这些都不是问题，问题是对应的芯片内部的架构是否足够灵活可配置，这是限制高级功能设计的关键。 2.Fabric上文中说过，不管是PCI-X还是PCI-E体系标准内，只支持树形拓扑。树形拓扑的问题在于，路径过长，整个网络的直径太大。另外，无法实现冗余，一旦某个链路故障，链路后方的分支全部无法访问。 于是， 支持Fabric成了一个非常复杂的高级功能。这个场景目前还很少有人使用，对于整机架服务器比如天蝎等，其对这项功能兴趣则比较大。然而，目前这个技术的实现还非常初级不完善，也没有形成标准。

3.IOVSR-IOV，不少人都听说过，但却不知道里面具体的门道，Single Root IO Virtualization里的Root是什么意思？Single Root又何解？还有Multi Root IOV，这又是什么鬼？ SR-IOV，是指把插在一台服务器上的一块PCI-E卡虚拟成多块虚拟卡，给运行在这台服务器上的多个虚拟机用，每个虚拟机都识别到一个PCI-E卡，但是VM并不知道这个卡是虚拟出来的。如果不虚拟成多块卡，多个VM怎么共享这个设备？答，必须通过Hypervisor提供的服务来使用该设备。Hypervisor会在VM内安装一个驱动程序，这个驱动会虚拟一个并不存在的设备，比如 “XXX牌以太网卡”，这个驱动会真的与OS协议栈挂接上，从而接收上层下发的数据包。但是这个驱动收到数据包之后，由于根本不存在实际的网卡，这个驱动其实是将这个包发送给了Hypervisor，或者有些虚拟机实现是使用一个domain 0特权VM来负责与真实硬件打交道，那么这个驱动会将数据发送给这个特权VM，Guest VM与特权VM之间通过进程间通信来传递数据，Hypervisor或者特权VM收到数据之后，再通过真实的驱动，比如“Intel xxx Ethernet card”将数据包发送给真实网卡。 这么一转发，就慢了，因为内存拷贝的代价比较高，吞吐量要求如果很大的话，这种方式就不行了。于是，SR-IOV出马解决了这个问题。SR-IOV需要直接在PCI-E卡的硬件里虚拟出多个子设备。如何做到？ 首先，支持SR-IOV的PCI-E卡，需要向系统申请成倍的地址空间，想虚拟出几个设备，就需要按照SR-IOV的规范格式来声明相比原先几倍的地址空间。这个地址空间会在内核或者BIOS枚举PCI-E设备的时候被获取到，系统会将为该设备申请的地址空间段的基地址写入设备寄存器。比如某网卡虚拟出8个虚拟网卡来，然后由内核PCI-E管理模块向系统申报8个PCI-E设备。随后就是由Hypervisor将对应的设备映射给对应的VM，VM中加载对应的Host Driver。Hypervisor还需要执行地址翻译，或者硬件辅助的地址翻译。 只要PCI-E设备自身支持SR-IOV，PCI-E Switch不需要做任何额外处理即可原生支持。但是 MR-IOV则必须在PCI-E switch上做额外处理才可以支持。原因还是因为多个独立系统之间是互不沟通的，如果都尝试对PCI-E总线进行配置会冲突。PCI-E Switch针对MR-IOV的支持基本手段，还是靠增加一层地址映射管理来实现。 Dell PowerEdge FX2平台对PCI-E Switch的应用Dell PowerEdge FX2是一款2U多节点服务器平台框架，其采用一个2U的Chassis机箱，最大可以容纳： 2个1U Server Sled或者1个1U Server Sled+2个1U半宽存储Sled或者1个1U半宽Server Sled+3个1U半宽存储Sled或者4个1U半宽Server Sled或者2个1U半宽Server Sled+2个1U半宽存储Sled或者3个1U半宽Server Sled+1个1U半宽存储Sled或者8个1U四分之一宽Server Sled 多种灵活组合都可实现。如下图所示。

机箱背面有8个PCI-E槽位。

这8个PCI-E槽位可以被灵活的分配给机箱正面的各种组合的Server Sled。这就得益于PCI-E Switch以及Partition功能的使用。笔者画了一张示意图来向大家介绍一下其内部的导向路径。如下图所示，1/2号槽位所连接的端口与服务器Sled1所连接的端口处于红色分区之内，3/4槽位与服务器Sled2处于黄色分区。而5/6/7/8槽位、存储Sled、服务器Seld3则同处于蓝色分区内。意味着，服务器Sled3会识别到5/6/7/8槽位上的PCI-E卡（如有），同时识别到存储Sled上的RAID卡。

基于Web的配置界面，通过连接到BMC，可以对整个FX2平台所囊括的所有Sled进行全局配置，包括分配对应的PCI-E槽位，也就是底层的对PCI-E Switch的分区操作。

通过对PCI-E Switch分区功能的灵活运用，Dell PowerEdge FX2平台可以实现后面8个PCI-E设备的灵活分配，从而更好的适配日益灵活的应用场景和业务需求。

当分支比较少的时候我们使用if else语句解决，当分支比较多的时候，我们要使用switch case语句解决，针对分支的复杂性选择合适的程序解决。

当分支过多时，用 if else 处理会不太方便，而且容易出现 if else 配对出错的情况。例如，输入一个整数，输出该整数对应的星期几的英文表示：

#include <stdio.h>
int main(){
    int a;
    printf("Input integer number:");
    scanf("%d",&a);
    if(a==1){
        printf("Monday\n");
    }else if(a==2){
        printf("Tuesday\n");
    }else if(a==3){
        printf("Wednesday\n");
    }else if(a==4){
        printf("Thursday\n");
    }else if(a==5){
        printf("Friday\n");
    }else if(a==6){
        printf("Saturday\n");
    }else if(a==7){
        printf("Sunday\n");
    }else{
        printf("error\n");
    }
    return 0;
}

运行结果：

Input integer number:3↙
Wednesday

对于上述情况，在实际开发中一般使用 switch 语句代替，请看下面的代码：

#include <stdio.h>
int main(){
    int a;
    printf("Input integer number:");
    scanf("%d",&a);
    switch(a){
        case 1: printf("Monday\n"); break;
        case 2: printf("Tuesday\n"); break;
        case 3: printf("Wednesday\n"); break;
        case 4: printf("Thursday\n"); break;
        case 5: printf("Friday\n"); break;
        case 6: printf("Saturday\n"); break;
        case 7: printf("Sunday\n"); break;
        default:printf("error\n"); break;
    }
    return 0;
}

运行结果：

Input integer number:4↙
Thursday

switch 是另外一种选择结构的语句，用来代替简单的、拥有多个分枝的 if else 语句，基本格式如下：

switch(表达式){
    case 整型数值1: 语句 1;
    case 整型数值2: 语句 2;
    ......
    case 整型数值n: 语句 n;
    default: 语句 n+1;
}

执行过程：
1 . 首先计算“表达式”的值，假设为 m。

2 . 从第一个 case 开始，比较“整型数值1”和 m，如果它们相等，就执行冒号后面的所有语句，也就是从“语句1”一直执行到“语句n+1”，而不管后面的 case 是否匹配成功。

3 . 如果“整型数值1”和 m 不相等，就跳过冒号后面的“语句1”，继续比较第二个 case、第三个 case……一旦发现和某个整型数值相等了，就会执行后面所有的语句。假设 m 和“整型数值5”相等，那么就会从“语句5”一直执行到“语句n+1”。

4 . 如果直到最后一个“整型数值n”都没有找到相等的值，那么就执行 default 后的“语句 n+1”。

注意，当和某个整型数值匹配成功后，会执行该分支以及后面所有分支的语句。例如：

#include <stdio.h>
int main(){
    int a;
    printf("Input integer number:");
    scanf("%d",&a);
    switch(a){
        case 1: printf("Monday\n");
        case 2: printf("Tuesday\n");
        case 3: printf("Wednesday\n");
        case 4: printf("Thursday\n");
        case 5: printf("Friday\n");
        case 6: printf("Saturday\n");
        case 7: printf("Sunday\n");
        default:printf("error\n");
    }
    return 0;
}

运行结果：

Input integer number:4↙
Thursday
Friday
Saturday
Sunday
error

输入4，发现和第四个分支匹配成功，于是就执行第四个分支以及后面的所有分支。这显然不是我们想要的结果，我们希望只执行第四个分支，而跳过后面的其他分支。为了达到这个目标，必须要在每个分支最后添加break;语句。

break 是C语言中的一个关键字，专门用于跳出 switch 语句。所谓“跳出”，是指一旦遇到 break，就不再执行 switch 中的任何语句，包括当前分支中的语句和其他分支中的语句；也就是说，整个 switch 执行结束了，接着会执行整个 switch 后面的代码。

使用 break 修改上面的代码：

#include <stdio.h>
int main(){
    int a;
    printf("Input integer number:");
    scanf("%d",&a);
    switch(a){
        case 1: printf("Monday\n"); break;
        case 2: printf("Tuesday\n"); break;
        case 3: printf("Wednesday\n"); break;
        case 4: printf("Thursday\n"); break;
        case 5: printf("Friday\n"); break;
        case 6: printf("Saturday\n"); break;
        case 7: printf("Sunday\n"); break;
        default:printf("error\n"); break;
    }
    return 0;
}

运行结果：

Input integer number:4↙
Thursday

由于 default 是最后一个分支，匹配后不会再执行其他分支，所以也可以不添加break;语句。

最后需要说明的两点是：
1 . case 后面必须是一个整数，或者是结果为整数的表达式，但不能包含任何变量。请看下面的例子：

case 10: printf("..."); break;  //正确
case 8+9: printf("..."); break;  //正确
case 'A': printf("..."); break;  //正确，字符和整数可以相互转换
case 'A'+19: printf("..."); break;  //正确，字符和整数可以相互转换
case 9.5: printf("..."); break;  //错误，不能为小数
case a: printf("..."); break;    //错误，不能包含变量
case a+10: printf("..."); break;  //错误，不能包含变量

2 . default 不是必须的。当没有 default 时，如果所有 case 都匹配失败，那么就什么都不执行。

如果感觉不错的话请点赞哟！！！