Hollis原创|不了解这12个语法糖，别说你会Java

时间 2019-12-10

标签 hollis 原创不了解语法别说 java 栏目 Java 繁體版

原文原文链接

GitHub 2.5k Star 的Java工程师成神之路，不来了解一下吗?java

GitHub 2.5k Star 的Java工程师成神之路，真的不来了解一下吗?git

GitHub 2.5k Star 的Java工程师成神之路，真的肯定不来了解一下吗?程序员

本文从 Java 编译原理角度，深刻字节码及 class 文件，抽丝剥茧，了解 Java 中的语法糖原理及用法，帮助你们在学会如何使用 Java。github

语法糖

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

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

咱们所熟知的编程语言中几乎都有语法糖。做者认为，语法糖的多少是评判一个语言够不够牛逼的标准之一。不少人说Java是一个“低糖语言”，其实从Java 7开始Java语言层面上一直在添加各类糖，主要是在“Project Coin”项目下研发。尽管如今Java有人仍是认为如今的Java是低糖，将来还会持续向着“高糖”的方向发展。api

解语法糖

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

说到编译，你们确定都知道，Java语言中，javac命令能够将后缀名为.java的源文件编译为后缀名为.class的能够运行于Java虚拟机的字节码。若是你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发如今compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。缓存

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

糖块1、 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或者使用纯整数常量，但这也不是不好。

糖块2、泛型

咱们都知道，不少语言都是支持泛型的，可是不少人不知道的是，不一样的编译器对于泛型的处理方式是不一样的，一般状况下，一个编译器处理泛型有两种方式：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", "hollis");  
map.put("wechat", "Hollis");  
map.put("blog", "www.hollischuang.com");

解语法糖以后会变成：

Map map = new HashMap();  
map.put("name", "hollis");  
map.put("wechat", "Hollis");  
map.put("blog", "www.hollischuang.com");

如下代码：

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<String>.class或是List<Integer>.class，而只有List.class。

糖块3、自动装箱与拆箱

自动装箱就是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", "公众号:Hollis", "博客：www.hollischuang.com", "QQ：907607222");
    }

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:Hollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com", "QQ\uFF1A907607222"
    });
}

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

}

从反编译后代码能够看出，可变参数在被使用的时候，他首先会建立一个数组，数组的长度就是调用该方法是传递的实参的个数，而后再把参数值所有放到这个数组当中，而后再把这个数组做为参数传递到被调用的方法中。

PS：反编译后的print方法声明中有一个transient标识，是否是很奇怪？transient不是不能够修饰方法吗？transient不是和序列化有关么？transient在这里的做用是什么？由于这个与本文关系不大，这里不作深刻分析了。相了解的同窗能够关注我微信公众号或者博客。

糖块五、枚举

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 。当咱们尝试对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语句实现的。其原理也是Java语言的语法糖。根据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("公众号：Hollis");
        assert a != b : "Hollis";
        System.out.println("博客：www.hollischuang.com");
    }
}

反编译后代码以下：

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\uFF1AHollis");
    if(!$assertionsDisabled && a == b)
    {
        throw new AssertionError("Hollis");
    } else
    {
        System.out.println("\u535A\u5BA2\uFF1Awww.hollischuang.com");
        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 = {"Hollis", "公众号：Hollis", "博客：www.hollischuang.com"};
    for (String s : strs) {
        System.out.println(s);
    }
    List<String> strList = ImmutableList.of("Hollis", "公众号：Hollis", "博客：www.hollischuang.com");
    for (String s : strList) {
        System.out.println(s);
    }
}

反编译后代码以下：

public static transient void main(String args[])
{
    String strs[] = {
        "Hollis", "\u516C\u4F17\u53F7\uFF1AHollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com"
    };
    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("Hollis", "\u516C\u4F17\u53F7\uFF1AHollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com");
    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;
    }
}

其实背后的原理也很简单，那些咱们没有作的关闭资源的操做，编译器都帮咱们作了。因此，再次印证了，语法糖的做用就是方便程序员的使用，但最终仍是要转成编译器认识的语言。

糖块12、Lambda表达式

关于lambda表达式，有人可能会有质疑，由于网上有人说他并非语法糖。其实我想纠正下这个说法。Labmda表达式不是匿名内部类的语法糖，可是他也是一个语法糖。实现方式实际上是依赖了几个JVM底层提供的lambda相关api。

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

public static void main(String... args) {
    List<String> strList = ImmutableList.of("Hollis", "公众号：Hollis", "博客：www.hollischuang.com");

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

为啥说他并非内部类的语法糖呢，前面讲内部类咱们说过，内部类在编译以后会有两个class文件，可是，包含lambda表达式的类编译后只有一个文件。

反编译后代码以下:

public static /* varargs */ void main(String ... args) {
    ImmutableList strList = ImmutableList.of((Object)"Hollis", (Object)"\u516c\u4f17\u53f7\uff1aHollis", (Object)"\u535a\u5ba2\uff1awww.hollischuang.com");
    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指定了方法实现。能够看到这里实际上是调用了一个lambda$main$0方法进行了输出。

再来看一个稍微复杂一点的，先对List进行过滤，而后再输出：

public static void main(String... args) {
    List<String> strList = ImmutableList.of("Hollis", "公众号：Hollis", "博客：www.hollischuang.com");

    List HollisList = strList.stream().filter(string -> string.contains("Hollis")).collect(Collectors.toList());

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

反编译后代码以下：

public static /* varargs */ void main(String ... args) {
    ImmutableList strList = ImmutableList.of((Object)"Hollis", (Object)"\u516c\u4f17\u53f7\uff1aHollis", (Object)"\u535a\u5ba2\uff1awww.hollischuang.com");
    List<Object> HollisList = 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());
    HollisList.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("Hollis");
}

两个lambda表达式分别调用了lambda$main$1和lambda$main$0两个方法。

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

可能遇到的坑

泛型

1、当泛型遇到重载 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，擦除动做致使这两个方法的特征签名变得如出一辙。

2、当泛型遇到catch 泛型的类型参数不能用在Java异常处理的catch语句中。由于异常处理是由JVM在运行时刻来进行的。因为类型信息被擦除，JVM是没法区分两个异常类型MyException<String>和MyException<Integer>的

3、当泛型内包含静态变量

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 class BoxingTest {

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循环

ConcurrentModificationException

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() 方法会在删除当前迭代对象的同时维护索引的一致性。

总结

前面介绍了12种Java中经常使用的语法糖。所谓语法糖就是提供给开发人员便于开发的一种语法而已。可是这种语法只有开发人员认识。要想被执行，须要进行解糖，即转成JVM认识的语法。当咱们把语法糖解糖以后，你就会发现其实咱们平常使用的这些方便的语法，其实都是一些其余更简单的语法构成的。

有了这些语法糖，咱们在平常开发的时候能够大大提高效率，可是同时也要避免过渡使用。使用以前最好了解下原理，避免掉坑。

参考资料：
Java的反编译
 Java中的Switch对整型、字符型、字符串型的具体实现细节深度分析Java的枚举类型—-枚举的线程安全性及序列化问题
 Java的枚举类型用法介绍
 Java中的加强for循环（for each）的实现原理与坑
 Java中泛型的理解
 Java中整型的缓存机制
 Java中的可变参数

Hollis原创|不了解这12个语法糖，别说你会Java

语法糖

解语法糖

糖块1、 switch 支持 String 与枚举

糖块2、 泛型

糖块3、 自动装箱与拆箱

糖块四 、 方法变长参数

糖块五 、 枚举

糖块六 、 内部类

糖块七 、条件编译

糖块八 、 断言

糖块九 、 数值字面量

糖块十 、 for-each

糖块十一 、 try-with-resource

糖块12、Lambda表达式

可能遇到的坑

泛型

自动装箱与拆箱

加强for循环

总结

糖块2、泛型

糖块3、自动装箱与拆箱

糖块四、方法变长参数

糖块五、枚举

糖块六、内部类

糖块七、条件编译

糖块八、断言

糖块九、数值字面量

糖块十、 for-each

糖块十一、 try-with-resource