Java常见的12个语法糖

最新推荐文章于 2023-07-06 17:40:44 发布
最新推荐文章于 2023-07-06 17:40:44 发布
阅读量2.1k 收藏 3
点赞数 2
分类专栏： 基础夯实 文章标签： 语法糖 反编译
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coder_what/article/details/96310967
版权

一定一定要向前看

之前在学习Java基础的时候，零零碎碎地看了一些语法糖相关，今天记录下来

switch

  • switch

  • 原始代码

    public class tesst{
    public static void main(String[] args) {
        String string = "world";
        switch (string){
            case "hello":
                System.out.println(string);
                break;
            case "world":
                System.out.println(string);
                break;
            default:
                break;
        }
    }
}

  • 编译后的代码

    public class tesst {
    public static void main(String[] args) {
        String string;
        String string2 = string = "world";
        int n = -1;
        switch (string2.hashCode()) {
            case 99162322: {
                if (!string2.equals("hello")) break;
                n = 0;
                break;
            }
            case 113318802: {
                if (!string2.equals("world")) break;
                n = 1;
            }
        }
        switch (n) {
            case 0: {
                System.out.println(string);
                break;
            }
            case 1: {
                System.out.println(string);
                break;
            }
        }
    }
}

  • 这样我们可以看出来，字符串需要先进行hash，然后为了防止hash碰撞，又加了equals

  • 之前阿里妹在公众号上发了五道题，其中有一个是这样的：

    public class SwitchTest {
    public static void main(String[] args) {
        String param = null;
        switch (param) {
            case "null":
                System.out.println("null");
                break;
            default:
                System.out.println("default");
        }
    }
}

    这个题有三种选项，一种是输出null，一种是走default，最后一种是报错。

    通过语法糖我们可以发现，switch中比较的是hashCode的值，而null.hashCode()自然会爆出空指针异常

forEach

  • 原来的代码

    public class ForEach {
    public static void main(String[] args) {
        String[] s = {"fxxk","suger","fxxk","java"};
        for (String s1 : s) {
            System.out.println(s1);
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

  • 编译后的代码

    public class ForEach{
    public ForEach(){
    }

    public static void main(String args[]){
        String s[] = {
            "fxxk", "suger", "fxxk", "java"
        };
        String args1[] = s;
        int j = args1.length;
        for(int k = 0; k < j; k++){
            String s1 = args1[k];
            System.out.println(s1);
        }

        List list = new ArrayList();
        for(int i = 0; i < 10; i++)
            list.add(Integer.valueOf(i));

        Integer integer;
        for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(integer))
            
            integer = (Integer)iterator.next();
    }
}

  • 可见，通过集合类是通过迭代器来实现了增强for循环，String通过普通的for循环来增强for循环。同时，因为其用了迭代器，我们需要注意，在foreach的时候只能遍历，不能修改。否则会爆出java.util.ConcurrentModificationException异常

lambda

  • lambda

  • 原始代码

    import java.util.ArrayList;
import java.util.List;
public class Lambda {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        list.forEach(System.out::println);
    }
}

  • 编译后代码

    import java.io.PrintStream;
import java.lang.invoke.LambdaMetafactory;
import java.util.ArrayList;
import java.util.function.Consumer;

public class Lambda {
    public static void main(String[] arrstring) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for (int i = 0; i < 10; ++i) {
            arrayList.add(i);
        }
        
        PrintStream printStream = System.out;
        printStream.getClass();
        
        arrayList.forEach(
            (Consumer<Integer>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, println(java.lang.Object ), (Ljava/lang/Integer;)V)((PrintStream)printStream));
    }

}

  • 我们可以看出lambda和内部类的不同之处，内部类是生成了多个类文件，而lambda则是在一个类文件中，最多生成多个方法而已

if

  • 原始文件

        public static void main(String[] args) {
        if (true){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        if (false){
            System.out.println("false");
        }else{
            System.out.println(false);
        }

    }

  • 编译过的文件

        public static void main(String args[])
    {
        System.out.println("true");
        System.out.println(false);
    }

enum

  • 原始文件

    public enum EnumClass {
    SPRING,SUMMER,FALL,WINTER;
}

  • 编译文件

    public final class EnumClass extends Enum
{

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

    public static EnumClass valueOf(String name)
    {
        return (EnumClass)Enum.valueOf(suger/EnumClass, name);
    }

    private EnumClass(String s, int i)
    {
        super(s, i);
    }

    public static final EnumClass SPRING;
    public static final EnumClass SUMMER;
    public static final EnumClass FALL;
    public static final EnumClass WINTER;
    private static final EnumClass $VALUES[];

    static 
    {
        SPRING = new EnumClass("SPRING", 0);
        SUMMER = new EnumClass("SUMMER", 1);
        FALL = new EnumClass("FALL", 2);
        WINTER = new EnumClass("WINTER", 3);
        $VALUES = (new EnumClass[] {
            SPRING, SUMMER, FALL, WINTER
        });
    }
}

    public static final Enum SPRING;
    public static final Enum SUMMER;
    public static final Enum FALL;
    public static final Enum WINTER;
    private static final Enum $VALUES[];

    static 
    {
        SPRING = new Enum("SPRING", 0);
        SUMMER = new Enum("SUMMER", 1);
        FALL = new Enum("FALL", 2);
        WINTER = new Enum("WINTER", 3);
        $VALUES = (new Enum[] {
            SPRING, SUMMER, FALL, WINTER
        });
    }
}

  • 我们可以看出，枚举是继承了Enum类的，同时他也是final，即不可继承的。

tryWithResource

  • 源代码

    public class TryWith {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new                   FileReader("d:\\TryWith.jad"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

  • 编译后的代码

    public class TryWith
{
    public TryWith()
    {
    }
    public static void main(String args[])
    {
        try
        {
            BufferedReader br = new BufferedReader(new FileReader("d:TryWith.jad"));
            String line;
            try
            {
                while((line = br.readLine()) != null) 
                    System.out.println(line);
            }
            catch(Throwable throwable)
            {
                try
                {
                    br.close();
                }
                catch(Throwable throwable1)
                {
                    throwable.addSuppressed(throwable1);
                }
                throw throwable;
            }
            br.close();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

  • 我们可以看到，是编译器帮我们把资源关闭了

assert

  • 原始代码

    public class Assert {
    public static void main(String[] args) {
        int a = 1;
        assert a > 0;
        System.out.println(a);
    }
}

  • 编译代码

    public class Assert
{

    public Assert()
    {
    }

    public static void main(String args[])
    {
        int a = 1;
        if(!$assertionsDisabled && a <= 0)
        {
            throw new AssertionError();
        } else
        {
            System.out.println(a);
            return;
        }
    }

    static final boolean $assertionsDisabled = !suger/Assert.desiredAssertionStatus();

}

  • 我们可以看到，断言通过if语句来执行

变长参数

  • 原始代码

    public class Long {
    public static void main(String... args) {
        String[] zi = {"i","am","zi","10ng"};
        ma(zi);
    }

    private static void ma(String... args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

  • 编译之后

    public class Long{
    public Long(){
    }

    public static transient void main(String args[]){
        String zi[] = {"i", "am", "zi", "10ng"};
        ma(zi);
    }

    private static transient void ma(String args[]){
        String as[] = args;
        int i = as.length;
        for(int j = 0; j < i; j++){
            String arg = as[j];
            System.out.println(arg);
        }
    }

自动装拆箱

  • 自动装拆箱

  • 原始代码

        public static void main(String[] args) {
        int a = 1;
        Integer b;
        b  = a;
        a = b;
    }

  • 编译之后

        public static void main(String args[])
    {
        int a = 1;
        Integer b = Integer.valueOf(a);
        a = b.intValue();
    }

  • 同时我们需要知道，在JDK5之后，Integer的操作中引入了一个新功能来节省内存和提高性能。即，整型对象通过使用相同的对象引用实现了缓存和重用。适用于整数值区间-128 至 +127。

泛型

  • 泛型

  • 源代码

    public class Generic extends Pair<String>{
    private String first;
    @Override
    public void setFirst(String first) {
        this.first = first;
    }
}
class Pair<T>{
    private T first;
    private T second;

    Pair() {
    }
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() {
        return first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}

  • 编译后的代码

    public class Generic extends Pair{
    private String first;
	public Generic()    {
    }
    public void setFirst(String first)    {
        this.first = first;
    }
    public volatile void setFirst(Object obj)   {
        setFirst((String)obj);
    }
    public volatile void setSecond(Object obj)    {
        super.setSecond(obj);
    }
    public volatile Object getSecond()    {
        return super.getSecond();
    }
    public volatile Object getFirst()    {
        return super.getFirst();
    }
}
class Pair{
    Pair(){
    }
    public Pair(Object first, Object second)    {
        this.first = first;
        this.second = second;
    }
    public Object getFirst()    {
        return first;
    }
    public void setFirst(Object first)    {
        this.first = first;
    }
    public Object getSecond()    {
        return second;
    }
    public void setSecond(Object second)   {
        this.second = second;
    }
    private Object first;
    private Object second;
}

  • 注意此处继承之后的桥接方法

  • 同时，我们需要知道因为类型擦除而出现的错误，详见泛型

内部类

多态

  • 多态

  • 原始代码

    class GrandFather{
    private int a;
    GrandFather() {
        a = 10;
    }
    public GrandFather method() {
        System.out.println("--------调用GrandFather method()方法");
        return new GrandFather();
    }
}
//父类
class Father extends GrandFather {
    private int b;
    Father() {
        b = 20;
    }
    @Override
    public Father method() {
        System.out.println("--------调用Father method()方法");
        return new Father();
    }
}

  • 编译器编译过后的Father类：

    class Father extends GrandFather
{
	private int b;
    Father(){
        b = 20;
    }
    public Father method(){
        System.out.println("--------\u8C03\u7528Father method()\u65B9\u6CD5");
        return new Father();
    }
    public volatile GrandFather method(){
        return method();
    }
}
王星星的魔灯
关注
专栏目录
浅析java常见语法糖
默默草
07-09 474
a
Java语法糖3：泛型
weixin_33936401的博客
10-13 91
泛型初探 在泛型（Generic type或Generics）出现之前，是这么写代码的： public static void main(String[] args) { List list = new ArrayList(); list.add("123"); list.add("456"); System.out.println((...
Java基础---常见的语法糖
最新发布
汤键的博客
07-06 1085
Java基础---常见的语法糖
深入理解Java常用语法糖
大唐雨夜的博客
12-08 3713
语法糖的存在主要是方便开发人员使用，使程序更加简洁，提高程序可读性。Java虚拟机并不支持这些语法糖，这些语法糖在编译阶段就会被还原成简单的基础语法结构，这个过程就是解语法糖。
Java编程常见的语法糖有哪些？
IT_studied的博客
08-11 225
　　语法糖，是由英国计算机科学家彼得·约翰·兰达(Peter J. Landin)发明的一个术语，简单来说就是对现有语法的一个封装。使用语法糖能够增加程序的可读性，减少程序代码出错的机会。作为一种与平台无关的高级编程语言，Java中也含有语法糖，这些语法糖并不被虚拟机所支持，在编译成字节码阶段会自动转换成简单常用的语法。下面就给大家介绍几个常见的语法糖。 　　一般来说Java中的语法糖主要有四种： 　　泛型与类型擦除 　　一个编译器处理泛型有两种方式：Code specializatio..
Java常见语法糖
工大樱木花道
10-28 564
语法糖定义 语法糖（英语：Syntactic sugar）是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。 语法糖是啥？语法糖没有一个官方的定义（或者说定义相当宽泛），更像是一种观念：任何让你写着爽、但是实际发生的和你看到的不一样的东西都可以“被认为”是语法糖。例如最常见的Integer和int的自动装拆箱操作背后就是语法糖。看上去你在写。 Java中很常见的Foreach就属于语法糖的一个
Java进阶之泛型与语法糖
lishinho的博客
07-19 817
Java泛型是一个重要的Java概念，虽然Java的继承和接口丰富了多态的灵活性，但我们仍然希望编写更通用的代码，能够适用“非特定的类型”，而不是一个具体的接口或类。同时泛型是如何产生并使用的，我们的代码里泛型究竟充当了什么样的角色？ 一，Java的编译期与运行期 从你写下Java代码（打印helllo world）到运行显示出你输入的效果，你的Java程序究竟经历了什么？ 程序从高级程序语言编译到机器语言；通过编译器的语法糖优化java程序用于提高代码效率 Java程序的编译与优化分为两个阶段，一
常见的语法糖
m0_46667398的博客
06-13 636
title: 语法糖 date: 2022-06-02 23:52:37 categories:Java常见的12个语法糖语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·兰 丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但 是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性语法糖往往给程序员提供了更实用的编码方式，有益于更好的编码风格，更易读。不过其并没有给语言添加什么新东西。需要声明的是“语法糖”这个词绝非贬义词，它可以给我带来方便
浅聊Java中的语法糖
Kaka_csdn14的博客
04-26 277
Java常见语法糖: 自动拆箱, 自动装箱... 枚举 泛型等等
Java 中12个常见的语法糖
weixin_51393513的博客
12-10 969
本文从Java编译原理角度，深入字节码及class文件，抽丝剥茧，了解Java中的语法糖原理及用法，帮助大家在学会如何使用Java语法糖的同时，了解这些语法糖背后的原理。 语法糖 语法糖(Syntactic Sugar)也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。 有意思的是，在编程领域，除了语法糖，还有语法盐和语法...
谈一谈JAVA里有哪些语法糖
重口味码农
09-24 1366
谈一谈JAVA里的语法糖 上周在听大牛分享JVM编译优化时，提到了在编译阶段会进行的一个步骤：解语法糖。他提出了一个问题是：JAVA里有哪些语法糖，听到这个问题，似乎很容易回答，因为我们都知道java有很多语法糖，但话到嘴边，也就只能想起字符串拼接和foreach来，果然，没有经过系统的梳理，一些听起来简单的知识点也会难倒你，所以我来梳理一下，看java里到底有哪些语法糖。 概述 在搜狗百科中，语...
【java】java 中的语法糖 一些常见的代码 内部很简单
九师兄
05-06 442
1.概述 转载并且补充：Java 中的语法糖，真甜 我们在日常开发中经常会使用到诸如泛型、自动拆箱和装箱、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等，我们只觉得用的很爽，因为这些特性能够帮助我们减轻开发工作量；但我们未曾认真研究过这些特性的本质是什么，那么这篇文章，cxuan 就来为你揭开这些特性背后的真相。 2.语法糖 在聊之前我们需要先了解一下 语法糖 的概念：语法糖（Syntactic sugar），也叫做糖衣语法，是英国科学家发明的一个术语，通常来
Java中部分常见语法糖
Don't rush and never settle. If it's meant to be, it will be.
11-11 1205
泛型java泛型学习笔记 http://blog.csdn.net/uncle_gy/article/details/77881849 java泛型擦除和泛型重载 http://blog.csdn.net/uncle_gy/article/details/78501893 java的PECS原则 http://blog.csdn.net/uncle_gy/article/details/7
java8---lambda表达式
weixin_30740295的博客
08-03 65
语法糖 lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包:java.util.function包以及java.util.stream包。 流(stream)就如同迭代器(i...
java-12 个语法糖
嘻哈熊的专栏
03-01 258
原文地址 mp.weixin.qq.com 本文从 Java 编译原理角度，深入字节码及 class 文件，抽丝剥茧，了解 Java 中的语法糖原理及用法，帮助大家在学会如何使用 Java 语法糖的同时，了解这些语法糖背后的原理 语法糖 语法糖（Syntactic Sugar），也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。 有意思的是.
JAVA-12 个语法糖
嘻哈熊的专栏
08-02 415
前面介绍了 12 种 Java 中常用的语法糖。所谓语法糖就是提供给开发人员便于开发的一种语法而已。但是这种语法只有开发人员认识。要想被执行，需要进行解糖，即转成 JVM 认识的语法。当我们把语法糖解糖之后，你就会发现其实我们日常使用的这些方便的语法，其实都是一些其他更简单的语法构成的。有了这些语法糖，我们在日常开发的时候可以大大提升效率，但是同时也要避免过渡使用。使用之前最好了解下原理，避免掉坑。END。...
什么是语法糖？Java中有哪些语法糖？
热门推荐
吴名氏的博客
03-21 12万+
什么是语法糖？Java中有哪些语法糖？
Java 的这12个语法糖，有点甜
LoveSummer
06-23 1万+
我们在日常开发中经常会使用到诸如泛型、自动拆箱和装箱、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等，我们只觉得用的很爽，因为这些特性能够帮助我们减轻开发工作量；但我们未曾认真研究过这些特性的本质是什么，那么这篇文章，cxuan 就来为你揭开这些特性背后的真相。在聊之前我们需要先了解一下 的概念：，也叫做糖衣语法，是英国科学家发明的一个术语，通常来说使用语法糖能够增加程序的，从而减少程序代码出错的机会，真是又香又甜。语法糖指的是计算机语言中添加的某种语法，这
Java语法糖
zhaohong_bo的专栏
04-10 285
先Mark，需要后续补齐、 参考： https://www.cnblogs.com/qingshanli/p/9375040.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值