阿里云面试:什么是语法糖?Java中有哪些语法糖?

2021最新Java大厂面试题来袭!附面试答案 One:JVM实践思维图(完整版) Two: 走近Java 概述+ Java技术体系+Java发展史+Java虚拟机家族:(Sun Classic/Exact VM、HotSpot VM、Mobile/Embedded VM、BEA JRockit/IBM J9 VM、BEA Liquid VM/Azul VM、Apache Harmony/Google Android Dalvik VM、Microsoft JVM及其他)+展望Java技术的未来+实战:自己编译JDK Three:自动内存管理 Ja 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:hollis


语法糖是大厂 Java 面试常问的一个知识点。

本文从 Java 编译原理角度,深入字节码及 class 文件,抽丝剥茧,了解 Java 中的语法糖原理及用法,帮助大家在学会如何使用 Java 语法糖的同时,了解这些语法糖背后的原理

语法糖

语法糖(Syntactic Sugar),也称糖衣语法,是由英国计算机学家 Peter.J.Landin 发明的一个术语,指在计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。简而言之,语法糖让程序更加简洁,有更高的可读性。

有意思的是,在编程领域,除了语法糖,还有语法盐和语法糖精的说法,篇幅有限这里不做扩展了。

我们所熟知的编程语言中几乎都有语法糖。作者认为,语法糖的多少是评判一个语言够不够牛逼的标准之一。

很多人说Java是一个“低糖语言”,其实从Java 7开始Java语言层面上一直在添加各种糖,主要是在“Project Coin”项目下研发。尽管现在Java有人还是认为现在的Java是低糖,未来还会持续向着“高糖”的方向发展。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

解语法糖

前面提到过,语法糖的存在主要是方便开发人员使用。但其实,Java虚拟机并不支持这些语法糖。这些语法糖在编译阶段就会被还原成简单的基础语法结构,这个过程就是解语法糖。

说到编译,大家肯定都知道,Java语言中,javac命令可以将后缀名为.java的源文件编译为后缀名为.class的可以运行于Java虚拟机的字节码。

如果你去看com.sun.tools.javac.main.JavaCompiler的源码,你会发现在compile()中有一个步骤就是调用desugar(),这个方法就是负责解语法糖的实现的。

Java 中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。本文主要来分析下这些语法糖背后的原理。一步一步剥去糖衣,看看其本质。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

糖块一、 switch 支持 String 与枚举

前面提到过,从Java 7 开始,Java语言中的语法糖在逐渐丰富,其中一个比较重要的就是Java 7中switch开始支持String。

在开始coding之前先科普下,Java中的swith自身原本就支持基本类型。比如int、char等。

对于int类型,直接进行数值的比较。对于char类型则是比较其ascii码。

所以,对于编译器来说,switch中其实只能使用整型,任何类型的比较都要转换成整型。比如byte。short,char(ackii码是整型)以及int。

那么接下来看下switch对String得支持,有以下代码:

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

反编译后内容如下:

public class switchDemoString
{
    public switchDemoString()
    {
    }
    public static void main(String args[])
    {
        String str = "world";
        String s;
        switch((s = str).hashCode())
        {
        default:
            break;
        case 99162322:
            if(s.equals("hello"))
                System.out.println("hello");
            break;
        case 113318802:
            if(s.equals("world"))
                System.out.println("world");
            break;
        }
    }
}

看到这个代码,你知道原来字符串的switch是通过equals()和hashCode()方法来实现的。还好hashCode()方法返回的是int,而不是long。

仔细看下可以发现,进行switch的实际是哈希值,然后通过使用equals方法比较进行安全检查,这个检查是必要的,因为哈希可能会发生碰撞。因此它的性能是不如使用枚举进行switch或者使用纯整数常量,但这也不是很差。

糖块二、 泛型

我们都知道,很多语言都是支持泛型的,但是很多人不知道的是,不同的编译器对于泛型的处理方式是不同的。

通常情况下,一个编译器处理泛型有两种方式:Code specialization和Code sharing。

C++和C#是使用Code specialization的处理机制,而Java使用的是Code sharing的机制。

Code sharing方式为每个泛型类型创建唯一的字节码表示,并且将该泛型类型的实例都映射到这个唯一的字节码表示上。将多种泛型类形实例映射到唯一的字节码表示是通过类型擦除(type erasue)实现的。

也就是说,对于Java虚拟机来说,他根本不认识Map<String, String> map这样的语法。需要在编译阶段通过类型擦除的方式进行解语法糖。

类型擦除的主要过程如下:

  • 1.将所有的泛型参数用其最左边界(最顶级的父类型)类型替换。

  • 2.移除所有的类型参数。

以下代码:

Map<String, String> map = new HashMap<String, String>();  
map.put("name", "yudaoyuanma");  
map.put("wechat", "芋道源码");  
map.put("blog", "www.iocoder.cn");

解语法糖之后会变成:

Map map = new HashMap();  
map.put("name", "yudaoyuanma");  
map.put("wechat", "芋道源码");  
map.put("blog", "www.iocoder.cn");

以下代码:

public static <A extends Comparable<A>> A max(Collection<A> xs) {
    Iterator<A> xi = xs.iterator();
    A w = xi.next();
    while (xi.hasNext()) {
        A x = xi.next();
        if (w.compareTo(x) < 0)
            w = x;
    }
    return w;
}

类型擦除后会变成:

public static Comparable max(Collection xs){
    Iterator xi = xs.iterator();
    Comparable w = (Comparable)xi.next();
    while(xi.hasNext())
    {
        Comparable x = (Comparable)xi.next();
        if(w.compareTo(x) < 0)
            w = x;
    }
    return w;
}

虚拟机中没有泛型,只有普通类和普通方法,所有泛型类的类型参数在编译时都会被擦除,泛型类并没有自己独有的Class类对象。比如并不存在List.class或是List.class,而只有List.class。

糖块三、 自动装箱与拆箱

自动装箱就是Java自动将原始类型值转换成对应的对象,比如将int的变量转换成Integer对象,这个过程叫做装箱,反之将Integer对象转换成int类型值,这个过程叫做拆箱。

因为这里的装箱和拆箱是自动进行的非人为转换,所以就称作为自动装箱和拆箱。

原始类型byte, short, char, int, long, float, double 和 boolean 对应的封装类为Byte, Short, Character, Integer, Long, Float, Double, Boolean。

先来看个自动装箱的代码:

public static void main(String[] args) {
    int i = 10;
    Integer n = i;
}

反编译后代码如下:

public static void main(String args[])
{
    int i = 10;
    Integer n = Integer.valueOf(i);
}

再来看个自动拆箱的代码:

public static void main(String[] args) {

    Integer i = 10;
    int n = i;
}

反编译后代码如下:

public static void main(String args[])
{
    Integer i = Integer.valueOf(10);
    int n = i.intValue();
}

从反编译得到内容可以看出,在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

所以,装箱过程是通过调用包装器的valueOf方法实现的,而拆箱过程是通过调用包装器的 xxxValue方法实现的。

糖块四 、 方法变长参数

可变参数(variable arguments)是在Java 1.5中引入的一个特性。它允许一个方法把任意数量的值作为参数。

看下以下可变参数代码,其中print方法接收可变参数:

public static void main(String[] args)
    {
        print("Holis", "公 众号:芋道源码", "博客:www.iocoder.cn", "QQ:7685413");
    }

public static void print(String... strs)
{
    for (int i = 0; i < strs.length; i++)
    {
        System.out.println(strs[i]);
    }
}

反编译后代码:

public static void main(String args[])
{
    print(new String[] {
        "Holis", "\u516C\u4F17\u53F7:芋道源码", "\u535A\u5BA2\uFF1Awww.iocoder.cn", "QQ\uFF1A907607222"
    });
}

// transient 不能修饰方法,这里应该是反编译错误了?
public static transient void print(String strs[])
{
    for(int i = 0; i < strs.length; i++)
        System.out.println(strs[i]);

}

从反编译后代码可以看出,可变参数在被使用的时候,他首先会创建一个数组,数组的长度就是调用该方法是传递的实参的个数,然后再把参数值全部放到这个数组当中,然后再把这个数组作为参数传递到被调用的方法中。

糖块五 、 枚举

Java SE5提供了一种新的类型-Java的枚举类型,关键字enum可以将一组具名的值的有限集合创建为一种新的类型,而这些具名的值可以作为常规的程序组件使用,这是一种非常有用的功能。

要想看源码,首先得有一个类吧,那么枚举类型到底是什么类呢?是enum吗?

答案很明显不是,enum就和class一样,只是一个关键字,他并不是一个类。

那么枚举是由什么类维护的呢,我们简单的写一个枚举:

public enum t {
    SPRING,SUMMER;
}

然后我们使用反编译,看看这段代码到底是怎么实现的,反编译后代码内容如下:

public final class T extends Enum
{
    private T(String s, int i)
    {
        super(s, i);
    }
    public static T[] values()
    {
        T at[];
        int i;
        T at1[];
        System.arraycopy(at = ENUM$VALUES, 0, at1 = new T[i = at.length], 0, i);
        return at1;
    }

    public static T valueOf(String s)
    {
        return (T)Enum.valueOf(demo/T, s);
    }

    public static final T SPRING;
    public static final T SUMMER;
    private static final T ENUM$VALUES[];
    static
    {
        SPRING = new T("SPRING", 0);
        SUMMER = new T("SUMMER", 1);
        ENUM$VALUES = (new T[] {
            SPRING, SUMMER
        });
    }
}

通过反编译后代码我们可以看到,public final class T extends Enum,说明,该类是继承了Enum类的,同时final关键字告诉我们,这个类也是不能被继承的。

当我们使用enmu来定义一个枚举类型的时候,编译器会自动帮我们创建一个final类型的类继承Enum类,所以枚举类型不能被继承。

糖块六 、 内部类

内部类又称为嵌套类,可以把内部类理解为外部类的一个普通成员。

内部类之所以也是语法糖,是因为它仅仅是一个编译时的概念。

outer.java里面定义了一个内部类inner,一旦编译成功,就会生成两个完全不同的.class文件了,分别是outer.class和outer$inner.class。所以内部类的名字完全可以和它的外部类名字相同。

public class OutterClass {
    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public static void main(String[] args) {

    }

    class InnerClass{
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

以上代码编译后会生成两个class文件:OutterClass$InnerClass.class 、OutterClass.class 。

当我们尝试使用jad对OutterClass.class文件进行反编译的时候,命令行会打印以下内容:

Parsing OutterClass.class...
Parsing inner class OutterClass$InnerClass.class...
Generating OutterClass.jad

他会把两个文件全部进行反编译,然后一起生成一个OutterClass.jad文件。文件内容如下:

public class OutterClass
{
    class InnerClass
    {
        public String getName()
        {
            return name;
        }
        public void setName(String name)
        {
            this.name = name;
        }
        private String name;
        final OutterClass this$0;

        InnerClass()
        {
            this.this$0 = OutterClass.this;
            super();
        }
    }

    public OutterClass()
    {
    }
    public String getUserName()
    {
        return userName;
    }
    public void setUserName(String userName){
        this.userName = userName;
    }
    public static void main(String args1[])
    {
    }
    private String userName;
}

糖块七 、条件编译

—般情况下,程序中的每一行代码都要参加编译。但有时候出于对程序代码优化的考虑,希望只对其中一部分内容进行编译,此时就需要在程序中加上条件,让编译器只对满足条件的代码进行编译,将不满足条件的代码舍弃,这就是条件编译。

如在C或CPP中,可以通过预处理语句来实现条件编译。其实在Java中也可实现条件编译。我们先来看一段代码:

public class ConditionalCompilation {
    public static void main(String[] args) {
        final boolean DEBUG = true;
        if(DEBUG) {
            System.out.println("Hello, DEBUG!");
        }

        final boolean ONLINE = false;

        if(ONLINE){
            System.out.println("Hello, ONLINE!");
        }
    }
}

反编译后代码如下:

public class ConditionalCompilation
{

    public ConditionalCompilation()
    {
    }

    public static void main(String args[])
    {
        boolean DEBUG = true;
        System.out.println("Hello, DEBUG!");
        boolean ONLINE = false;
    }
}

首先,我们发现,在反编译后的代码中没有System.out.println("Hello, ONLINE!");,这其实就是条件编译。

当if(ONLINE)为false的时候,编译器就没有对其内的代码进行编译。

所以,Java语法的条件编译,是通过判断条件为常量的if语句实现的。根据if判断条件的真假,编译器直接把分支为false的代码块消除。通过该方式实现的条件编译,必须在方法体内实现,而无法在正整个Java类的结构或者类的属性上进行条件编译。

这与C/C++的条件编译相比,确实更有局限性。在Java语言设计之初并没有引入条件编译的功能,虽有局限,但是总比没有更强。

糖块八 、 断言

在Java中,assert关键字是从JAVA SE 1.4 引入的,为了避免和老版本的Java代码中使用了assert关键字导致错误,Java在执行的时候默认是不启动断言检查的(这个时候,所有的断言语句都将忽略!)。

如果要开启断言检查,则需要用开关-enableassertions或-ea来开启。

看一段包含断言的代码:

public class AssertTest {
    public static void main(String args[]) {
        int a = 1;
        int b = 1;
        assert a == b;
        System.out.println("芋道源码");
        assert a != b : "芋道源码";
        System.out.println("博客:www.iocoder.cn");
    }
}

反编译后代码如下:

public class AssertTest {
   public AssertTest()
    {
    }
    public static void main(String args[])
{
    int a = 1;
    int b = 1;
    if(!$assertionsDisabled && a != b)
        throw new AssertionError();
    System.out.println("\u516C\u4F17\u53F7\uFF1A芋道源码");
    if(!$assertionsDisabled && a == b)
    {
        throw new AssertionError("芋道源码");
    } else
    {
        System.out.println("\u535A\u5BA2\uFF1Awww.iocoder.cn");
        return;
    }
}

static final boolean $assertionsDisabled = !com/hollis/suguar/AssertTest.desiredAssertionStatus();


}

很明显,反编译之后的代码要比我们自己的代码复杂的多。所以,使用了assert这个语法糖我们节省了很多代码。

其实断言的底层实现就是if语言,如果断言结果为true,则什么都不做,程序继续执行,如果断言结果为false,则程序抛出AssertError来打断程序的执行。

-enableassertions会设置$assertionsDisabled字段的值。

糖块九 、 数值字面量

在java 7中,数值字面量,不管是整数还是浮点数,都允许在数字之间插入任意多个下划线。这些下划线不会对字面量的数值产生影响,目的就是方便阅读。

比如:

public class Test {
    public static void main(String... args) {
        int i = 10_000;
        System.out.println(i);
    }
}

反编译后:

public class Test
{
  public static void main(String[] args)
  {
    int i = 10000;
    System.out.println(i);
  }
}

反编译后就是把_删除了。也就是说编译器并不认识在数字字面量中的_,需要在编译阶段把他去掉。

糖块十 、 for-each

增强for循环(for-each)相信大家都不陌生,日常开发经常会用到的,他会比for循环要少写很多代码,那么这个语法糖背后是如何实现的呢?

public static void main(String... args) {
    String[] strs = {"芋道源码", "公 众号:芋道源码", "博客:www.iocoder.cn"};
    for (String s : strs) {
        System.out.println(s);
    }
    List<String> strList = ImmutableList.of("芋道源码", "公 众号:芋道源码", "博客:www.iocoder.cn");
    for (String s : strList) {
        System.out.println(s);
    }
}

反编译后代码如下:

public static transient void main(String args[])
{
    String strs[] = {
        "芋道源码", "\u516C\u4F17\u53F7\uFF1A芋道源码", "\u535A\u5BA2\uFF1Awww.iocoder.cn"
    };
    String args1[] = strs;
    int i = args1.length;
    for(int j = 0; j < i; j++)
    {
        String s = args1[j];
        System.out.println(s);
    }

    List strList = ImmutableList.of("芋道源码", "\u516C\u4F17\u53F7\uFF1A芋道源码", "\u535A\u5BA2\uFF1Awww.iocoder.cn");
    String s;
    for(Iterator iterator = strList.iterator(); iterator.hasNext(); System.out.println(s))
        s = (String)iterator.next();

}

代码很简单,for-each的实现原理其实就是使用了普通的for循环和迭代器。

糖块十一 、 try-with-resource

Java里,对于文件操作IO流、数据库连接等开销非常昂贵的资源,用完之后必须及时通过close方法将其关闭,否则资源会一直处于打开状态,可能会导致内存泄露等问题。

关闭资源的常用方式就是在finally块里是释放,即调用close方法。比如,我们经常会写这样的代码:

public static void main(String[] args) {
    BufferedReader br = null;
    try {
        String line;
        br = new BufferedReader(new FileReader("d:\\hollischuang.xml"));
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        // handle exception
    } finally {
        try {
            if (br != null) {
                br.close();
            }
        } catch (IOException ex) {
            // handle exception
        }
    }
}

从Java 7开始,jdk提供了一种更好的方式关闭资源,使用try-with-resources语句,改写一下上面的代码,效果如下:

public static void main(String... args) {
    try (BufferedReader br = new BufferedReader(new FileReader("d:\\ hollischuang.xml"))) {
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        // handle exception
    }
}

看,这简直是一大福音啊,虽然我之前一般使用IOUtils去关闭流,并不会使用在finally中写很多代码的方式,但是这种新的语法糖看上去好像优雅很多呢。

反编译以上代码,看下他的背后原理:

public static transient void main(String args[])
    {
        BufferedReader br;
        Throwable throwable;
        br = new BufferedReader(new FileReader("d:\\ hollischuang.xml"));
        throwable = null;
        String line;
        try
        {
            while((line = br.readLine()) != null)
                System.out.println(line);
        }
        catch(Throwable throwable2)
        {
            throwable = throwable2;
            throw throwable2;
        }
        if(br != null)
            if(throwable != null)
                try
                {
                    br.close();
                }
                catch(Throwable throwable1)
                {
                    throwable.addSuppressed(throwable1);
                }
            else
                br.close();
            break MISSING_BLOCK_LABEL_113;
            Exception exception;
            exception;
            if(br != null)
                if(throwable != null)
                    try
                    {
                        br.close();
                    }
                    catch(Throwable throwable3)
                      {
                        throwable.addSuppressed(throwable3);
                    }
                else
                    br.close();
        throw exception;
        IOException ioexception;
        ioexception;
    }
}

其实背后的原理也很简单,那些我们没有做的关闭资源的操作,编译器都帮我们做了。

所以,再次印证了,语法糖的作用就是方便程序员的使用,但最终还是要转成编译器认识的语言。

糖块十二、Lambda表达式

关于lambda表达式,有人可能会有质疑,因为网上有人说他并不是语法糖。其实我想纠正下这个说法。

Labmda表达式不是匿名内部类的语法糖,但是他也是一个语法糖。实现方式其实是依赖了几个JVM底层提供的lambda相关api。

先来看一个简单的lambda表达式。遍历一个list:

public static void main(String... args) {
    List<String> strList = ImmutableList.of("芋道源码",  "公 众号:芋道源码", "博客:www.iocoder.cn");

    strList.forEach( s -> { System.out.println(s); } );
}

为啥说他并不是内部类的语法糖呢,前面讲内部类我们说过,内部类在编译之后会有两个class文件,但是,包含lambda表达式的类编译后只有一个文件。

反编译后代码如下:

public static /* varargs */ void main(String ... args) {
    ImmutableList strList = ImmutableList.of((Object)"芋道源码", (Object)"\u516c\u4f17\u53f7\uff1a芋道源码", (Object)"\u535a\u5ba2\uff1awww.iocoder.cn");
    strList.forEach((Consumer<String>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, lambda$main$0(java.lang.String ), (Ljava/lang/String;)V)());
}

private static /* synthetic */ void lambda$main$0(String s) {
    System.out.println(s);
}

可以看到,在forEach方法中,其实是调用了java.lang.invoke.LambdaMetafactory#metafactory方法,该方法的第四个参数implMethod指定了方法实现。可以看到这里其实是调用了一个lambda0方法进行了输出。

再来看一个稍微复杂一点的,先对List进行过滤,然后再输出:

public static void main(String... args) {
    List<String> strList = ImmutableList.of("芋道源码",  "公 众号:芋道源码", "博客:www.iocoder.cn");

    List 芋道源码List = strList.stream().filter(string -> string.contains("芋道源码")).collect(Collectors.toList());

    芋道源码List.forEach( s -> { System.out.println(s); } );
}

反编译后代码如下:

public static /* varargs */ void main(String ... args) {
    ImmutableList strList = ImmutableList.of((Object)"芋道源码", (Object)"\u516c\u4f17\u53f7\uff1a芋道源码", (Object)"\u535a\u5ba2\uff1awww.iocoder.cn");
    List<Object> 芋道源码List = strList.stream().filter((Predicate<String>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)Z, lambda$main$0(java.lang.String ), (Ljava/lang/String;)Z)()).collect(Collectors.toList());
    芋道源码List.forEach((Consumer<Object>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, lambda$main$1(java.lang.Object ), (Ljava/lang/Object;)V)());
}

private static /* synthetic */ void lambda$main$1(Object s) {
    System.out.println(s);
}

private static /* synthetic */ boolean lambda$main$0(String string) {
    return string.contains("芋道源码");
}

两个lambda表达式分别调用了lambda1和lambda0两个方法。

所以,lambda表达式的实现其实是依赖了一些底层的api,在编译阶段,编译器会把lambda表达式进行解糖,转换成调用内部api的方式。

可能遇到的坑

泛型——当泛型遇到重载
public class GenericTypes {    public static void method(List<String> list) {  
        System.out.println("invoke method(List<String> list)");  
    }  

    public static void method(List<Integer> list) {  
        System.out.println("invoke method(List<Integer> list)");  
    }  
}

上面这段代码,有两个重载的函数,因为他们的参数类型不同,一个是List另一个是List,但是,这段代码是编译通不过的。因为我们前面讲过,参数List和List编译之后都被擦除了,变成了一样的原生类型List,擦除动作导致这两个方法的特征签名变得一模一样。

泛型——当泛型遇到catch

泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除,JVM是无法区分两个异常类型MyException和MyException的

泛型——当泛型内包含静态变量
public class StaticTest{
    public static void main(String[] args){
        GT<Integer> gti = new GT<Integer>();
        gti.var=1;
        GT<String> gts = new GT<String>();
        gts.var=2;
        System.out.println(gti.var);
    }
}
class GT<T>{
    public static int var=0;
    public void nothing(T x){}
}

以上代码输出结果为:2!由于经过类型擦除,所有的泛型类实例都关联到同一份字节码上,泛型类的所有静态变量是共享的。

自动装箱与拆箱——对象相等比较
public static void main(String[] args) {
    Integer a = 1000;
    Integer b = 1000;
    Integer c = 100;
    Integer d = 100;
    System.out.println("a == b is " + (a == b));
    System.out.println(("c == d is " + (c == d)));
}

输出结果:

a == b is false
c == d is true

在Java 5中,在Integer的操作上引入了一个新功能来节省内存和提高性能。整型对象通过使用相同的对象引用实现了缓存和重用。

适用于整数值区间-128 至 +127。

只适用于自动装箱。使用构造函数创建对象不适用。

增强for循环
for (Student stu : students) {    
    if (stu.getId() == 2)     
        students.remove(stu);    
}

会抛出ConcurrentModificationException异常。

Iterator是工作在一个独立的线程中,并且拥有一个 mutex 锁。Iterator被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,这个索引表的内容不会同步改变,所以当索引指针往后移动的时候就找不到要迭代的对象,所以按照 fail-fast 原则 Iterator 会马上抛出java.util.ConcurrentModificationException异常。

所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法remove()来删除对象,Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

8984e9058414711f8aea011848958187.png

总结

前面介绍了12种Java中常用的语法糖。由于篇幅问题,其他还有一些常见的语法糖比如字符串拼接其实基于 StringBuilder,Java10 里面的 var 关键字声明局部变量采用的是智能类型推断这里就不提了。

所谓语法糖就是提供给开发人员便于开发的一种语法而已。但是这种语法只有开发人员认识。要想被执行,需要进行解糖,即转成JVM认识的语法。

当我们把语法糖解糖之后,你就会发现其实我们日常使用的这些方便的语法,其实都是一些其他更简单的语法构成的。

有了这些语法糖,我们在日常开发的时候可以大大提升效率,但是同时也要避免过渡使用。使用之前最好了解下原理,避免掉坑。



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

aef73b8457a7a05a2da1ce04cac6f709.png

已在知识星球更新源码解析如下:

63a7c2572bd0c6a302cfc2c0aa80f39f.jpeg

a8608532761b394c24deee6406d4f8c4.jpeg

f2a1d4b0123dbb21e4e540e2be4f94a7.jpeg

8779b4f4ee095988518356d414c45b4e.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
优雅谈大模型:“System2”与“System 1” 研究人员探索了三种System 2方法——RaR、S2A 和 BSM,这些方法已经成功提炼到新的LLM,这个新的模型与System 1相比,产生了更好的结果,而且成本低于System 2。然而这种方法是有局限性,只能适用于特定的任务。 阅读详情

相关推荐

利用SPSS实现逻辑回归,树模型,以及广义线性模型

本案例是IBM SPSS数据分析与挖掘实战案例精粹----第九章的学习记录 案例背景:分析出导致急救后迟发性颅脑损伤的主要影响因素,共有201项案例: 分析思路:先使用logistic回归模型进行影响因素筛选,然后利用分类树探索自变量中是否存在交互作用,最后利用广义线性模型过程拟合带交互项的Logistic回归模型 字段:性别,年龄,收缩压,舒张压,血小板,脑挫伤,中线位移,脑肿胀,入院意识,是否手术急救,其余急救措施,是否出现迟发性脑损伤; ...

hepan_defeng的博客 1万+

【日常知识点】Java 语法糖,你用过几个?

语法糖(Syntactic sugar),也称作糖衣语法,是由英国计算机科学家彼得·约翰·兰达(Peter J. Landin)提出的一个术语。它指的是编程语言中为了使代码更加易读、易于编写而添加的某种简洁或方便的语法特性。这些语法特性并不会增加语言的基本功能,也就是说,使用语法糖和不使用语法糖实现的功能是等价的,但使用语法糖可以使代码更清晰,更符合人类的思维习惯。提高可读性:通过简化代码结构,使得代码更加直观,更容易被其他开发者理解。减少错误。

激流丶的博客 2077

避坑指南:Unity与Visual Studio开发环境配置中的5个常见问题及解决方案

本文针对Unity与Visual Studio开发环境配置中的5个常见问题,提供了详细的解决方案。重点解决了项目文件生成失败导致命名空间无法识别、调试器无法附加、包管理器与扩展安装混乱、脚本编译错误以及多版本环境冲突等核心痛点,帮助开发者构建稳定高效的开发调试环境。

weixin_27791839的博客 281

javaee框架技术课后题答案,字节Java高工面试

蚂蚁面试比较重视基础,所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的,因为我面的是稳定性保障部门,还有许多单独的小组,什么三年1班,很有青春的感觉。面试官基本水平都比较高,基本都P7以上,除了基础还问了不少架构设计方面的问题,收获还是挺大的。经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有:蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初,中级,高级Java面试题集合,附带超详细答案,希望能帮助到大家。

2401_84413145的博客 491

手把手教你用ROS2 Humble给PX4无人机写个“画圆”程序:从C++代码到Gazebo仿真全流程

本文详细介绍了如何使用ROS2 Humble和PX4飞控实现无人机圆形轨迹控制,涵盖从环境配置、Gazebo仿真到C++代码实现的完整流程。通过实战教程,读者将掌握轨迹跟踪仿真的核心技术,包括ROS2与PX4的通信接口、圆形轨迹算法设计及Gazebo仿真调试技巧。

weixin_29056781的博客 257

【我的Android进阶之旅】解决android应用使用android:persistent属性带来的系统Launcher应用必须重启设备才生效的问题,大幅度提升开发效率

一、问题描述 我们在开发系统级别应用,比如Launcher桌面的时候,会发现有个问题:每次Launcher修改完代码,重新编译之后,安装到android设备上之后,必须重启才会生效。否则就是使用了之前的Launcher版本的内容。而每次重启设备得一分钟左右,太慢了,太影响效率了! 1.1 痛点 每次更新完代码,重新安装之后,必须重启设备才会生效。效率太TM低了! 二、分析问题 经过一轮代码排查,最终发现是因为src\main\AndroidManifest.xml文件中,定义application使用了an

字节卷动 1715

独家!阿里云大师深入拆解Java虚拟机,告诉你什么叫细节爆炸

这样,等真的沉下心来学习,不至于被找资料分散了心神。以上就是本文的全部内容,希望对大家的面试有所帮助,祝大家早日升职加薪迎娶白富美走上人生巅峰!以上就是本文的全部内容,希望对大家的面试有所帮助,祝大家早日升职加薪迎娶白富美走上人生巅峰!

srtnwn1的博客 222

麒麟操作系统提示“默认密钥环已上锁”的解决办法

麒麟操作系统提示“默认密钥环已上锁”的解决办法

太极淘的博客 1万+

2024年2024最新Android大厂高频面试题解析大全(BAT TMD JD 小米),android初级面试

首先是感觉自己的基础还是不够吧,大厂好像都喜欢问这些底层原理。之前的准备只涉及了Java、Android、计网、数据结构与算法这些方面,面对面试官对其他基础课程的考察显得捉襟见肘。下一步还是要查漏补缺,进行针对性复习。最后的最后,那套资料这次一定要全部看完,是真的太全面了,各个知识点都涵盖了,几乎我面试遇到的所有问题的知识点这里面都有!希望大家不要犯和我一样的错误呀!!!一定要看完!网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。

2301_79098336的博客 1095

【二】MADDPG多智能体算法实现(parl)【追逐游戏复现】

论文全称:Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments 论文原文:https://download.youkuaiyun.com/download/sinat_39620217/16203960 论文翻译:https://blog.youkuaiyun.com/qiusuoxiaozi/article/details/79066612 ...

丨汀、的博客 2万+

Altium Designer(AD24/25)PCB编辑的几种方法介绍

本文介绍了Altium Designer(AD24/25)软件中PCB编辑的四种操作方法:1)通过菜单栏"Place→Component"激活;2)点击工具栏元器件图标;3)右键快捷菜单选择;4)快捷键P+C组合操作。建议初学者先通过菜单栏和快捷菜单熟悉操作,熟练后转为工具栏和快捷键以提高效率。文章配有操作示意图,帮助用户快速掌握PCB元器件放置技巧。

fydar的博客 947

2020最新Android大厂高频面试题解析大全(BAT TMD JD 小米)

本文首发于简书——Alvin老师,搬运转载请注明出处,否则将追究版权责任。 上次搜集整理字节跳动面试专题文章的时候也过去了差不多一个月了,期间收到了面试交流群友的积极响应,纷纷表示获益匪浅。部分同学也因此收获了理想的offer! 但看到还有很多人最近还在找Android开发工作, 而且很多人都感觉今年受疫情影响,找工作比去年难很多, 竞争力也增加不少, 因此激发我整理这份Android大厂高...

weixin_43901866的博客 1753

YOLOv11涨点改进 | 首发全网创新、主干改进篇 | AAAI 2026 | PartialNet 主干让 YOLOv11 更加强大!引入部分通道机制 和 部分注意力卷积,全方面提升了模型的性能

本文提出PartialNet主干网络改进YOLOv11的方法,通过部分通道机制(PCM)和部分注意力卷积(PATConv)提升模型效率。PartialNet将特征图通道拆分并应用不同操作,显著减少计算量和内存占用。主要创新包括:1)部分通道机制实现计算优化;2)三种注意力模块(PATch/PATsp/PATsf)增强特征提取;3)动态部分卷积(DPConv)自适应调整计算复杂度。文章详细提供了代码实现和YOLOv11集成方法。

Ai缝合怪、助力小伙伴高效发论文 270

2024最新Android大厂高频面试题解析大全(BAT-TMD-JD-小米),程序员去公司面试准备什么

搜集整理。面试题解析采用了等一线互联网技术团队大咖分享的源码解析、项目实战案例应用。确保了这份面试资料的专业性和权威性。同时也能让我们更加深入的去理解Android高频面试要点,尽快拿到理想的offer。当然这里面可能还会有纰漏,如果有问题欢迎大家留言或者讨论并领取这份资料!第一章 Android 相关第二章 性能优化第三章 Java 相关第四章 Kotlin 相关第五章 网络相关第六章 插件化&热修复&模块化&组件化&增量更新&Gradle第七章 图片相关。

2301_82243799的博客 952

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

读者投稿:阿里 P6 面试体验

本文转载自:code秘密花园“”17 年从上家公司离职之后就尝试过去阿里面试,结果还没进入状态就被凉凉了,在扇贝呆了 2 年多的时间,赶上正好租的房子要到期了,就想着再次尝试一下吧,结...

WantFlyDaCheng的博客 391

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Java面试八股文:基础核心与工程实践解析

Java内存模型(JMM)和并发编程是构建高可靠系统的技术基石。JVM通过垃圾回收机制自动管理内存,其分代收集算法和GC调优参数直接影响应用性能。在多线程场景下,synchronized与CAS等同步机制保障线程安全,而Java 21引入的虚拟线程进一步降低并发编程复杂度。这些基础概念在分布式系统、高并发服务等场景具有重要价值。本文以HashMap实现原理和动态代理技术为例,解析Java集合框架与反射机制的设计思想,并探讨其在微服务架构中的实际应用。掌握这些核心知识对通过技术面试和解决工程问题都至关重要。

weixin_34194087的博客 340

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

2024最新Android大厂高频面试题解析大全(BAT TMD JD 小米)

插件化技术可以说是Android高级工程师所必须具备的技能之一,从2012年插件化概念的提出(Android版本),到2016年插件化的百花争艳,可以说,插件化技术引领着Android技术的进步。本章分别从绘制(UI)、内存、存储、稳定性、耗电以及安装包等几个方面进行优化,从系统上深入分析绘制和内存的原理,一步步深入了解导致性能问题的本质原因,同时讲述了多种性能优化工具的使用,通过分析典型案例,得到有效的优化方案,从而实现更高质量的应用。Java是Android开发的基础,同时也是大厂面试的第一道门槛。

2401_85112794的博客 514

倾心五年全力打造!一文看完Java知识结构体系,Java基础学习超全知识指南

近日里,很多人邀请我回答各种j2ee开发的初级问题,我无一都强调java初学者要先扎实自己的基础知识,那什么才是Java的基础知识?又怎么样才算掌握了java的基础知识呢?这个问题还真值得仔细思考。 今天给大家带来的是阿里巴巴技术专家和阿里云开发者社区联合出品的【Java工程师成神之路】,相信有不少的朋友都有在各大网站有听说过这个名字,就在最近,这份成神之路的电子版教程终于问世了,历时6个月。从2015年的首次发布,持续更新到了现在。 【Java工程师成神之路】该系列共包含基础篇、底层篇、进阶篇、高级篇、

资料免费分享,点击名片 1354

Java八股文面试核心解析与高效记忆法

Java面试中的八股文考察是开发者必须掌握的基础技能,尤其在JVM、并发编程和Spring框架等核心领域。理解JVM内存模型、ConcurrentHashMap的演进原理以及Spring Bean的生命周期,不仅能帮助开发者应对技术面试,更能提升实际工程能力。随着云原生和分布式系统的普及,面试考点也在升级,如K8s优雅停机和Seata的AT模式应用。通过脑图记忆法和错题本技巧,可以有效掌握这些知识点,避免过度背诵和原理与实践脱节的常见问题。

weixin_30905981的博客 396

阿里巴巴技术专家倾心五年全力打造!Java成神之路电子版教程已问世!

近日里,很多人邀请我回答各种j2ee开发的初级问题,我无一都强调java初学者要先扎实自己的基础知识,那什么才是Java的基础知识?又怎么样才算掌握了java的基础知识呢?这个问题还真值得仔细思考。 今天给大家带来的是阿里巴巴技术专家和阿里云开发者社区联合出品的【Java工程师成神之路】,相信有不少的朋友都有在各大网站有听说过这个名字,就在最近,这份成神之路的电子版教程终于问世了,历时6个月。从2015年的首次发布,持续更新到了现在。 【Java工程师成神之路】该系列共包含基础篇、底层篇、进阶篇、高级篇、

Java_Jishu的博客 314

【好书推荐-第三期】《深入理解Java核心技术:写给Java工程师的干货笔记》全网阅读量千万的Java工程师成神之路学习笔记,Java基础知识点查漏补缺

【好书推荐-第三期】《深入理解Java核心技术:写给Java工程师的干货笔记》全网阅读量千万的Java工程师成神之路学习笔记,Java基础知识点查漏补缺

努力才是唯一的入场券。 1万+

java语言基础教程,Java高级工程师必备知识

我还通过一些渠道整理了一些大厂真实面试主要有:蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初,中级,高级Java面试题集合,附带超详细答案,希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。

F1520080的博客 900
上一篇: 是什么让Redis“气急败坏”回击:13年来,总有人想替Redis换套新架构
下一篇: gRPC:一个性能强到爆的RPC框架
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值