Switch模式匹配

最新推荐文章于 2024-07-22 10:41:52 发布
最新推荐文章于 2024-07-22 10:41:52 发布
阅读量1k 收藏 24
点赞数 9
文章标签： java 前端 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43843882/article/details/135369060
版权

1.Switch表达式

Switch 语句，这是 Java 入门中控制流程的部分，它是除 if 语句外的另外一种条件判断，提供了比连续的 if-else 语句更加清晰和结构化的选择机制。

Switch 语句依然存在一些显著的缺陷：

  1. "Fall-through" 行为：在没有显式 break 语句的情况下，Switch 语句会从一个 case "穿透" 到下一个 case，忽略了这个会导致不可饶恕的错误。
  2. 代码冗余：每个 case，我们都需要重复类似的代码结构，增加了代码的冗余和维护难度。

为了解决 Switch 的现存问题，Java 12 引入全新的Switch 表达式，该表达式不仅增强了 Switch 语句的功能，还大幅提高了其灵活性和表达能力。

  • 传统Switch

    public static String getTypeOfDay(String day) {
        String typeOfDay;
        switch (day) {
            case "MONDAY":
            case "TUESDAY":
            case "WEDNESDAY":
            case "THURSDAY":
            case "FRIDAY":
                typeOfDay = "Weekday";
                break;
            case "SATURDAY":
            case "SUNDAY":
                typeOfDay = "Weekend";
                break;
            default:
                typeOfDay = "Unknown";
        }
        return typeOfDay;
    }

  • Switch表达式 

新的 Switch 表达式引入了 -> 操作符，用于替代传统的冒号（:）。与传统的 Switch 语句不同，使用 -> 的 case 分支不会出现 "fall-through" 现象，因此不需要 break 语句来防止穿透。这减少了代码的复杂性，也降低了编程错误的风险。

    public static String getTypeOfDay(String day) {
        String typeOfDay = switch (day) {
            case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> "Weekday";
            case "SATURDAY", "SUNDAY" -> "Weekend";
            default -> "Unknown";
        };
        return typeOfDay;
    }
  1. 返回值：传统的 Switch 仅仅只是语句，用来控制流程的，无法返回值。但是新的 Switch 可以作为表达式使用，支持返回值。
  2. ->代替：老的 Switch 需要在每个案例后面使用 break ，否则会发生“穿透”，而新的不需要，它会自动终止。
  3. 多值匹配：传统的 Switch 无法在一个案例标签中匹配多个值，而新的 Switch 表达式允许一个 case 匹配多个值，用"," 分割即可。
  4. 更简洁的语法: 整体代码更简洁，易于阅读和维护。

  • Switch表达式扩展 

为了进一步扩展 Switch 的功能，Java 13 引入yield关键字来处理多分支结构中的返回值。

yield用于在Switch表达式的每个分支中返回一个值，这点与传统的Switch语句需要通过变量赋值来返回值不同。同时在使用->的情况下，如果分支逻辑比较复杂，需要多条语句来处理，那么可以在这些语句的最后使用yield来返回最终的结果。

在 Java 12 中，虽然他允许直接从Switch表达式中返回值，但在处理复杂的逻辑时，仍需依赖外部变量来返回结果。比如下面这段简单的逻辑：

    public static String getTypeOfDay(String day) {
        String typeOfDay = switch (day) {
            case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> "Weekday";
            case "SATURDAY", "SUNDAY" -> "Weekend";
            default -> "Unknown";
        };
        return typeOfDay;
    }

对于这简单的逻辑 ，Java 12 可以直接返回，但是这里想在 default 处增加一个判断 day 是否为空的逻辑，这个时候就无法简单使用 -> 直接返回了，需要定义一个外部变量来处理 

    public static String getTypeOfDay(String day) {
        String typeOfDay = null;
        switch (day) {
            case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> typeOfDay  = "Weekday";
            case "SATURDAY", "SUNDAY" -> typeOfDay = "Weekend";
            default -> {
                // 处理复杂逻辑
                if (day.isEmpty()) {
                    typeOfDay =  "day is empty";
                } else {
                    typeOfDay = "Unknown";
                }
            }
        };
        return typeOfDay;
    }

但是，在 Java 13 中，我们可以使用 yield 在Switch表达式中直接返回：

    public static String getTypeOfDay(String day) {
        return switch (day) {
            case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" ->  "Weekday";
            case "SATURDAY", "SUNDAY" ->  "Weekend";
            default -> {
                if (day.isEmpty()) {
                   yield "day is empty";
                } else {
                    yield "Unknown";
                }
            }
        };
    }

在Switch表达式中处理复杂的case逻辑时，yield 使得在每个分支内部可以执行多条语句，并返回值，从而简化了代码结构并提高了可读性。 

但是，Switch 表达式只有一种类型，如果要处理多种类型呢？只能这样处理 ：

Object obj = ... // 某个对象

switch (obj.getClass().getName()) {
    case "java.lang.String":
        String str = (String) obj;
        // 处理字符串
        break;
    case "java.lang.Integer":
        Integer i = (Integer) obj;
        // 处理整数
        break;
    case "com.lang.Long":
        Long lon = (Long) obj;
        // 处理MyClass实例
        break;
    // 其他类型
}

 2.模式匹配

instanceof 用于检查一个对象是否是特定类的实例或者该类的子类的实例。它通常用在条件语句中，以确定对象的类型，从而避免在向下转型时发生 ClassCastException。在 Java 14 前，我们一般都是这样写

if (object instanceof String) {
    // 返回 true，确认是 String 类型，强制转换为 String 类型后使用
    String str = (String) object;
}

if 语句里面的强制转换显得很是多余，所以 Java 14 引入模式匹配的 instanceof 来解决这个问题，它允许在 instanceof 操作符的条件判断中直接定义一个变量，如果对象是指定的类型，这个变量会被初始化为被检查的对象，可以立即使用，无需额外的类型转换，如：

if (obj instanceof String str) {
    // 可以直接使用 str，而不需要显式的类型转换
}

3.Switch模式匹配

用于 instanceof 的模式匹配在Java 16 成为正式特性，到了 Java 21 模式匹配的应用扩展到了switch表达式并成为正式特性，这标志着 Switch 表达式又得到了一次增强。

在 Java 21 中，switch 表达式允许使用模式匹配来处理对象类型，这样就可以直接在 switch 语句中检查和转换类型，而不需要额外的 if...else 结构和显式类型转换。

  • 类型模式

这是一种比较常见的模式，它允许在 switch 语句的 case 分支中直接匹配对象的类型。例如，case String s允许你在该分支中直接作为字符串类型的 s 来使用，避免了显式的类型检查和强制类型转换。举个例子来说明下： 

    @Test
    public void switchTest() {
        Object[] objects = { "Hello", 123, "World", "Java", 3.14, "jjjava" };
        for (Object obj: objects) {
            if (obj instanceof Integer intR) {
                System.out.println("为整数型：" + intR);
            } else if (obj instanceof Float floatR) {
                System.out.println("为浮点型：" + floatR);
            } else if (obj instanceof Double doubleR) {
            System.out.println("为双精度浮点数：" + doubleR);
            } else if (obj instanceof String str) {
                System.out.println("为字符串：" + str);
            } else {
                System.out.println("其他类型：" + obj);
            }
        }
    }

用 Switch 表达式来改造下：

    @Test
    public void switchTest() {
        Object[] objects = { "Hello", 123, "World", "Java", 3.14, "jjjava" };
        for (Object obj: objects) {
            switch (obj) {
                case Integer intR -> System.out.println("为整数型：" + intR);
                case Float floatR -> System.out.println("为浮点型：" + floatR);
                case Double doubleR -> System.out.println("为双精度浮点数：" + doubleR);
                case String str -> System.out.println("为字符串：" + str);
                default -> System.out.println("其他类型：" + obj);
            }
        }
    }

相比上面的 if...else 简洁了很多。同时在 Java 21之前，Switch 选择器表达式只支持特定类型，即基本整型数据类型byte、short、char和int；对应的装箱形式Byte、Short、Character和Integer；String类；枚举类型。现在有了类型模式，Switch 表达式可以是任何类型啦。

  • 空模式

在Java 21之前，向switch语句传递一个null值，会抛出一个NullPointerException，现在可以通过类型模式，将 null 检查作为一个单独的case标签来处理，如下：

    @Test
    public void switchTest() {
        Object[] objects = { "Hello", 123, "World", "Java", 3.14, "jjjava" };
        for (Object obj: objects) {
            switch (obj) {
                // 省略...
                case null -> System.out.println("为空值");
                default -> System.out.println("其他类型：" + obj);
            }
        }
    }

 case null 可以直接匹配值为 null 的情况。

  • 守卫模式

守卫模式允许我们在 case 标签后添加一个额外的条件。只有当类型匹配并且额外条件为真时，才会进入该 case 块。

比如上面例子，我们要将字符串那块逻辑调整下，比如长度大于 5 的为长字符串，小于 5 的为短字符串，在不使用守卫模式的情况下，我们一般这样写：

    @Test
    public void switchTest() {
        Object[] objects = { "Hello", 123, "World", "Java", 3.14, "jjjava" };
        for (Object obj: objects) {
            switch (obj) {
                case Integer intR -> System.out.println("为整数型：" + intR);
                case Float floatR -> System.out.println("为浮点型：" + floatR);
                case Double doubleR -> System.out.println("为双精度浮点数：" + doubleR);
                case String str -> {
                    if (str.length() > 5) {
                        System.out.println("为长字符串：" + str);
                    } else {
                        System.out.println("为短字符串：" + str);
                    }
                }
                case null -> System.out.println("为空值");
                default -> System.out.println("其他类型：" + obj);
            }
        }
    }

这种写法就显得不是那么友好，使用守卫模式如下：

    @Test
    public void switchTest() {
        Object[] objects = { "Hello", 123, "World", "Java", 3.14, "jjjava" };
        for (Object obj: objects) {
            switch (obj) {
                case Integer intR -> System.out.println("为整数型：" + intR);
                case Float floatR -> System.out.println("为浮点型：" + floatR);
                case Double doubleR -> System.out.println("为双精度浮点数：" + doubleR);
                case String str && str.length() > 5 -> System.out.println("为长字符串：" + str);
                case String str -> System.out.println("为短字符串：" + str);
                case null -> System.out.println("为空值");
                default -> System.out.println("其他类型：" + obj);
            }
        }
    }

 使用守卫模式，我们可以编写更灵活和表达性强的代码。

诸葛铃铛
关注
C#：模式匹配与模式
子昊
08-15 751
“模式匹配”是一种测试表达式是否具有特定特征的方法。 C# 模式匹配提供更简洁的语法，用于测试表达式并在表达式匹配时采取措施。模式匹配最常见的方案之一是确保值不是 。 使用以下示例进行 测试时，可以测试可为 null 的值类型并将其转换为其基础类型： 上述代码时声明模式，用于测试变量类型并将其分配给新变量。变量 仅在 子句的 true 部分可供访问和分配。 如果尝试在 子句或 程序块后等其他位置访问，编译器将出错。 其次，由于不使用 运算符，因此当类型重载 运算符时，此模式有效。 这使该方
c#杂谈之四(模式匹配)
weixin_42710036的博客
11-30 1014
c#模式匹配
Swift中switch强大的模式匹配
享受开发，颠倒银河
07-03 4391
不少人觉得Swift中switch语句和C或C++,乃至ObjC中的差不多,此言大谬!让本猫带领大家看一下Swift中switch语句模式匹配的威力.所谓模式匹配就是利用一定模式(比如couple)去定制自己需要的匹配结果,比如以下一个3D空间的点坐标:let point3D:(x:Int,y:Int,z:Int) = (1,2,3)我们首先做一些简单的匹配,只是简单的比较是否等于或不等于指定的常量
Java 17 新特性：switch的模式匹配（Preview）
程序猿DD
05-15 2536
还记得Java 16中的instanceof增强吗？ 通过下面这个例子再回忆一下： Map<String, Object> data = new HashMap<>(); data.put("key1", "aaa"); data.put("key2", 111); if (data.get("key1") instanceof String s) { log.info(s); } 上面这个场景里，M
Java 21 新特性 - switch 模式匹配
最新发布
qq_33240556的博客
07-22 422
在 Java 21 中，"switch 模式匹配"这一特性得到了正式的引入和改进，这是对 Java 语言模式匹配支持的扩展。到了 Java 21，它可能已经成为标准功能，意味着它不再是预览状态，并且被鼓励在生产环境中使用。语句中使用模式匹配来处理不同类型的值，不仅仅是传统的基于枚举或整数的情况，还包括类实例、密封类及其子类实例等，通过解构这些实例来访问其内部组件。请记住，虽然基于Java的发展趋势和先前预览特性的演进，上述描述符合预期的更新方向，但具体实现细节和最终特性集仍应参考Java 21的官方文档。
Switch 块、Switch 表达式、Switch 模式匹配，越来越好用的 Switch
沉潜飞动
07-30 1629
与 if-else 一样，switch 语法是用来做条件判断的。当条件清晰简洁时，能够有效地提升代码可读性。switch 语法从 Java5 开始，Java12 增加了 Switch 表达式（Java14 提供正式版），Java17 增加 Switch 模式匹配（预览版）。...
【疯狂Java讲义】Java学习记录（Java17新增的switch模式匹配）
have_to_be的博客
08-02 1136
switch的模式匹配既支持传统语法（case后用冒号），也支持新式语法（case后用箭头）- switch模式匹配既支持switch语句，也支持switch表达式。
多路复用，模式匹配和switch语句
kekefen01的博客
04-08 250
老实说，很像 可能做硬件的喜欢说多路复用，函数式编程的喜欢用模式匹配这个词
switch模式匹配
08-12
Switch 模式匹配是一种在编程中用于根据不同的模式执行不同操作的语法结构。它通常用于多个条件分支的情况，可以简化代码并提高可读性。 在许多编程语言中，例如 Java、C#、Python 3.10+ 和 Rust，都支持类似 ...
switch匹配模式
09-22
在Java17中引入了Switch模式匹配的功能。通过Switch模式匹配，我们可以在Switch表达式中使用更复杂的模式，例如使用is模式、使用Deconstructor和位置匹配模式等。这些模式可以帮助我们更方便地进行条件判断和类型...
Swift中switch语句区间和元组模式匹配
08-31
与许多其他编程语言不同，Swift的`switch`语句提供了更多的灵活性，包括区间匹配和元组模式匹配。让我们深入探讨这两个特性。 ### 区间匹配 在传统的`switch`语句中，通常只能对特定的值进行匹配。然而，在Swift中...
Java 21 新特性：switch的模式匹配
程序猿DD
09-20 5920
如今，在JDK 21中，该特性得到了最终确定！这个功能还是非常有用的，尤其是存在一些抽象封装的时候，可能存在一些父子、兄弟等关系类的时候，为了判断是什么类型，就不用写很多if来处理了，代码简洁度可以得到进一步的优化。对于上面的例子，还没有升级到Java 17的用户，还涉及两个中间知识点，建议可以补充学习一下：第一个是。中可能存储了不同类型的对象，我们要判断的时候，就只能依靠。现在开始，这样的类型判断关系，就可以简化为如下的。中的类型匹配限制是很多的。，参与交流与讨论，更好的学习与进步！
模式匹配第一弹: switch, enums & where 子句
weixin_34360651的博客
04-26 125
作者：Olivier Halligon，原文链接，原文日期：2016-03-27译者：walkingway；校对：小锅；定稿：shanks 从简单的 switch 到复杂的表达式、Swift 中的模式匹配可以变得相当强大。今天开始我们来探索一下 switch 炫酷的使用技巧，稍后一系列文章会更进一步，为大家带来更高级的模式匹配技法。 本文...
总结：Java 17 新特性 - Pattern Matching for switch
weixin_38833041的博客
06-24 1841
在Java 17 preview中，switch支持模式匹配，并且允许选择器表达式的值为null。模式分为两种，分别是保护模式（*guarded patterns*）和带括号的模式（*parenthesized patterns*），其中保护模式允许使用任意的布尔表达式细化模式匹配的逻辑，带括号的模式用于解决歧义问题。...
switch模式匹配Java17～20
colinjustlove的博客
08-25 175
【代码】switch模式匹配Java17～20。
C# 中的switch case 模式匹配 写法 备忘
weixin_43542114的博客
06-16 906
private static void TestSwitch() { string path = "a.txt"; lab1: Console.WriteLine("Input Key R Read Or W Write:"); ConsoleKeyInfo inputKey = Console.ReadKey(); Console.WriteLine(); .
java 21 record模式和switch模式匹配
你的指尖有改变世界的力量
03-17 556
介绍java21的两个新语法特性
C#的Switch语句2（case后的值与模式匹配）
充满智慧的博客
06-19 1419
关键字了，default定义了一个默认的代码块，当Switch表达式的值与任何一个case标签的值都不匹配时，程序会执行default语句块中的代码。这在处理未预期或不明确的输入值时非常有用，确保了代码的健壮性，避免了因没有匹配的case而直接跳过Switch结构导致的潜在问题。当在switch语句块中遇到return语句时，它不仅仅会终止当前switch块的执行，而且会直接结束包含该switch语句的整个函数的执行，并立即返回到调用该函数的地方。但在某种写法下，C#也是可以穿透的，在文章后面会讲解。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值