Java常见的12个语法糖揭秘

后端 潘老师 3个月前 (11-22) 81 ℃ (0) 扫码查看

本文主要讲解关于Java常见的12个语法糖揭秘相关内容,让我们来一起学习下吧!

简介

语法糖(Syntactic Sugar),也称糖衣语法,是由英国计算机学家 Peter.J.Landin 发明的一个术语,指在计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。简而言之,语法糖让程序更加简洁,非常利于操作。事实上听名字也能想到,加在语法中的糖让语法变得更”甜“。

语法糖1:switch

switch对于char, byte, short, int类型是本身就支持的,但其实它们都是转换成了整型,最后支持的其实是整型。但由于Java语法糖的出现,switch也支持String和enum类型了

原代码

public class SugarTest {
    public static void main(String[] args) {
        String str = "java";
        switch (str) {
            case "java":
                System.out.println("1");
                break;
            case "javac":
                System.out.println("2");
                break;
            default:
                System.out.println("default");
        }
    }
}

编译后代码

public class SugarTest {
    public SugarTest() {
    }

    public static void main(String[] args) {
        String str = "java";
        byte var3 = -1;
        switch(str.hashCode()) {
        case 3254818:
            if (str.equals("java")) {
                var3 = 0;
            }
            break;
        case 100899457:
            if (str.equals("javac")) {
                var3 = 1;
            }
        }

        switch(var3) {
        case 0:
            System.out.println("1");
            break;
        case 1:
            System.out.println("2");
            break;
        default:
            System.out.println("default");
        }

    }
}

可以看出,switch对于字符串类是比较字符串的hashcode方法以及通过equals方法确定是哪个字符串的,由于hashcode有一定概率会出现hash碰撞,用hashcode比较可能不太安全,所以仍需要进一步通过equals比较

语法糖2:自动拆装箱

自动拆装箱实际上是通过包装类的valueOf方法和xxxValue方法实现的,这里就不详细说了。

语法糖3:for-each语法

增强for循环可谓是广泛使用,省去了去定义一个自增变量

public class SugarTest {
    public static void main(String[] args) {
        String[] strs = new String[]{"java", "python", "c++"};
        for (String str : strs) {
            System.out.println(str);
        }

        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add(i);
        }

        for (Integer num : list) {
            System.out.println(num);
        }
    }
}

编译后代码

public class SugarTest {
    public SugarTest() {
    }

    public static void main(String[] args) {
        String[] strs = new String[]{"java", "python", "c++"};
        String[] var2 = strs;
        int i = strs.length;

        for(int var4 = 0; var4 < i; ++var4) {
            String str = var2[var4];
            System.out.println(str);
        }

        List list = new ArrayList();

        for(i = 0; i < 3; ++i) {
            list.add(i);
        }

        Iterator var7 = list.iterator();

        while(var7.hasNext()) {
            Integer num = (Integer)var7.next();
            System.out.println(num);
        }

    }
}

可以看出,一般的数组使用for-each背后的实现仅仅是把它变为普通fot循环而已,对于集合类使用for-each循环背后的实现是使用了Iterator遍历的

由于使用了迭代器Iterator,所以在数组遍历时不能修改数组(比如调用remove方法),否则根据fail-fast机制会抛出java.util.ConcurrentModificationException异常

语法糖4:方法变长参数

Java是允许将一种类型的任意数量的值作为参数使用的

public class SugarTest {
    public static void main(String[] args) {
        test("java", "python", "c++");
    }

    public static void test(String... strs) {
        for (String str : strs) {
            System.out.println(str);
        }
    }
}

编译后的代码

public class SugarTest {
    public SugarTest() {
    }

    public static void main(String[] args) {
        test("java", "python", "c++");
    }

    public static void test(String... strs) {
        String[] var1 = strs;
        int var2 = strs.length;

        for(int var3 = 0; var3 < var2; ++var3) {
            String str = var1[var3];
            System.out.println(str);
        }

    }
}

事实上就是将参数转变为了对应的数组

语法糖5:if条件编译

条件编译就是在编译期间编译器会选择有效的代码编译,不满足条件的代码称为无用代码,会被直接丢弃

public class SugarTest {
    private static final boolean DEBUG = true;

    public static void main(String[] args) {
        if (DEBUG) {
            System.out.println("DEBUG模式");
        } else {
            System.out.println("非DEBUG模式");
        }
    }
}

编译后的代码

public class SugarTest {
    private static final boolean DEBUG = true;

    public SugarTest() {
    }

    public static void main(String[] args) {
        System.out.println("DEBUG模式");
    }
}

上面的代码中编译器在编译时已经能确定只用执行DEBUG为true的代码,那么编译器只需要保存满足条件的一行代码即可,不需要全部保存

谈一谈条件编译的作用

有人会问了,既然DEBUG已知为true了,还去写个if多此一举干嘛,这其实是为了后期便于维护,就像上述代码一样,DEBUG模式可能是一段代码,非DEBUG模式可能是另外一段代码,开发者只需要改变常量DEBUG的值即可做到两种模式下的自由切换,岂不乐哉?这样配合编译器的条件编译机制又能使编译后的代码更为简洁,简直perfect!(通常这个常量可通过配置文件配置更为简便)

语法糖6:泛型

泛型可谓是个好东西了,在没有泛型时我们返回的方法值、参数等都在编写代码时就必须确定它的类型,这为我们带来了诸多不便,我们往往需要将这些参数和返回值设置为Object类型然后强转,但基于开发者的强转是极易出现问题的。而有了泛型后这些问题便都不是问题了

public class SugarTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("111");
    }
}

编译后的代码

public class SugarTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("111");
    }
}

可以看出,泛型在编译期间便直接被扔掉了。泛型的实现机制是通过编译器的一种被称为类型擦除(type erasure)的处理实现的,也就是编译器不认识List这个类,它只认识并执行List这个类

类型擦除主要两个过程

  • 将所有使用到泛型参数的地方都用其最顶级的层次(顶层父类)替换掉
  • 将所有泛型擦除,即将尖括号<>删除

如下这个例子

public class SugarTest {
    public static void main(String[] args) {
        String s = "1234";
        test(s);
    }

    public static <T extends Object> void test(T arg) {
        List<T> list = new ArrayList<>();
        list.add(arg);
    }
}

编译后的代码将所有泛型替换为Object型

public class SugarTest {
    public static void main(String[] args) {
        String s = "1234";
        test((Object)s);
    }

    public static void test(Object arg) {
        List list = new ArrayList();
        list.add(arg);
    }
}

语法糖7:内部类

class OutClass {
    class Node {
        public Integer num;
    }
}

public class SugarTest {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        OutClass.Node node = outClass.new Node();
        node.num = 10;
    }
}

编译后事实上会产生两个后缀为.class的字节码文件,OutClass.class和OutClass$Node.class文件,由此可以看出内部类并不是真正套在一个类的内部,而是分成两个类编译

再看看静态内部类实际上是一样的

class OutClass {
    static class Node {
        public Integer num;
    }
}

public class SugarTest {
    public static void main(String[] args) {
        OutClass.Node node = new OutClass.Node();
        node.num = 10;
    }
}

从上我们也能看出内部类和静态内部类的一些区别,内部类必须通过它的外部类的实例去new一个内部类,而静态内部类可以直接new一个内部类(但是要求内部类存在时外部类必定也存在)

语法糖8:assert断言

assert关键字是后来引入的,为了避免和老版本的Java代码引入assert关键字而出错,默认Java是不开启断言检查的,也就是说assert等于无用,如果要开启断言检查使用选项-ea或-enableassertions开启

【即java -ea SugarTest运行】

public class SugarTest {
    public static void main(String[] args) {
        Integer num = 1;
        assert num != null : "Error!";
        System.out.println(num);
    }
}

编译后的代码

public class SugarTest {
    public SugarTest() {
    }
    
    public static void main(String[] args) {
        Integer num = 1;
        if(!$assertionsDisabled && num == null) {
            throw new AssertionError("Error!");
        } else {
             System.out.println(num);
            return;
        }
    }
    
    static final boolean $assertionsDisabled = !src/SugarTest.desiredAssertionStatus();
}

断言首先会检查$assertionsDisabled是否为true,如果为true说明断言被禁用了,直接执行else的内容,如果设置了开启断言则会判断断言后的表达式是否正确,不正确会抛出异常

语法糖9:数值字面量

允许在数字间插入任意数量的下划线,对数字的值不会产生任何影响,主要是方便阅读

【比如1_0000_0000可以直接看出是1亿】

public class SugarTest {
    public static void main(String[] args) {
        Integer num = 1_0000_0000;
        System.out.println(num);
    }
}

编译后的代码

public class SugarTest {
    public SugarTest() {
    }

    public static void main(String[] args) {
        Integer num = 100000000;
        System.out.println(num);
    }
}

语法糖10:Enum枚举类

枚举类让我们可以更方便的使用和定义一些常量,但在代码中实际上enum就是个关键字,看不出来枚举类到底是个什么神仙玩意,也看不出它是个什么对象

public enum EnumTest {
    JAVA, PYTHON, JS;
}

编译后的代码

public final class EnumTest extends Enum {

    public static final EnumTest JAVA;
    public static final EnumTest PYTHON;
    public static final EnumTest JS;
    private static final EnumTest $VALUES[];

    static {
        JAVA = new EnumTest("JAVA", 0);
        PYTHON = new EnumTest("PYTHON", 1);
        JS = new EnumTest("JS", 2);
        $VALUES = (new EnumTest[]{
                JAVA, PYTHON, JS
        });
    }
    private EnumTest(String s, int i) {
        super(s, i);
    }

    public static EnumTest[] values() {
        return (EnumTest[]) $VALUES.clone();
    }

    public static EnumTest valueOf(String name) {
        return (EnumTest) Enum.valueOf(EnumTest, name);
    }
}

可以看出,每一个枚举类中的一个常量都是一个EnumTest对象,这个对象有两个属性,一个是常量的名字,另一个是从0开始的数值字面量

所有变量定义为final连类也定义为final,说明枚举类的变量不能被修改该类也不能被继承,values方法返回的是数组的深拷贝,所以即使通过该方法获得了数组也无法修改数组中的值

枚举类的构造器是私有化的,所以用户定义的每一个变量返回给用户时都是同一个EnumTest对象,如果只在枚举类定义一个常量,那么这个枚举类就是个单例模式了

语法糖11:try-with-resource异常处理

相信大家都写过try-catch-finally代码,每次new一个流时一般都要在finally中将这个流close,如果流比较多,代码就会显得臃肿,那么这个语法糖就能让代码及其简洁

public class SugarTest {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(
                                        new FileReader("c:\file\test.txt"));
             BufferedWriter writer = new BufferedWriter(new PrintWriter(System.out))) {
            String str;
            while ((str = reader.readLine()) != null) {
                System.out.println(str);
            }
            writer.write("读取文件完毕");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

编译后代码

public class SugarTest {
    public SugarTest() {
    }

    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("c:\file\test.txt"));
            Throwable var2 = null;

            try {
                BufferedWriter writer = new BufferedWriter(new PrintWriter(System.out));
                Throwable var4 = null;

                try {
                    String str;
                    while((str = reader.readLine()) != null) {
                        System.out.println(str);
                    }

                    writer.write("读取文件完毕");
                } catch (Throwable var29) {
                    var4 = var29;
                    throw var29;
                } finally {
                    if (writer != null) {
                        if (var4 != null) {
                            try {
                                writer.close();
                            } catch (Throwable var28) {
                                var4.addSuppressed(var28);
                            }
                        } else {
                            writer.close();
                        }
                    }

                }
            } catch (Throwable var31) {
                var2 = var31;
                throw var31;
            } finally {
                if (reader != null) {
                    if (var2 != null) {
                        try {
                            reader.close();
                        } catch (Throwable var27) {
                            var2.addSuppressed(var27);
                        }
                    } else {
                        reader.close();
                    }
                }

            }
        } catch (IOException var33) {
            var33.printStackTrace();
        }

    }
}

事实上这么简洁的代码最后编译器也只是把它转换成了try-catch-finally而已,代码故意采取两个流,目的是让读者清楚编译器会先对writer释放流再对reader释放流,也就是先写的流后释放

语法糖12:Lambda表达式

public class SugarTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("JAVA");
        list.forEach((elem) -> System.out.println(elem));
    }
}

编译后的代码

public class Lambda {
    public static void main(String[] arrstring) {
        List list = new ArrayList();
        list.add("JAVA");
        
        list.forEach((Consumer<String>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, lambda$main$0(java.lang.String ), (Ljava/lang/String;)V)());
    }
    
    private static void lambda$main$0(String s) {
        System.out.println(s);
    }

}

可以看出编译后端Lambda语法是新增了一个方法,方法中是匿名内部类的方法体,然后调用LambdaMetafactory.metafactory这个方法执行。

以上就是关于Java常见的12个语法糖揭秘相关的全部内容,希望对你有帮助。欢迎持续关注潘子夜个人博客(www.panziye.com),学习愉快哦!


版权声明:本站文章,如无说明,均为本站原创,转载请注明文章来源。如有侵权,请联系博主删除。
本文链接:https://www.panziye.com/back/11747.html
喜欢 (0)
请潘老师喝杯Coffee吧!】
分享 (0)
用户头像
发表我的评论
取消评论
表情 贴图 签到 代码

Hi,您需要填写昵称和邮箱!

  • 昵称【必填】
  • 邮箱【必填】
  • 网址【可选】