简介：
当谈到Java中的语法糖时，我们指的是一些在编译器中进行转换的语法结构，使代码更易读、更易写，但在底层仍然会被转换为普通的Java代码。下面详细介绍每个语法糖，并给出相应的代码示例：
1. 自动装箱和拆箱：
自动装箱和拆箱使得基本数据类型和对应的包装类型之间的转换更加方便。
自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。
因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。
| byte | short | char | int | long | float | double | boolean |
| Byte | Short | Character | Integer | Long | Float | Double | Boolean |
// 自动装箱 Integer num = 10; // 自动拆箱 int value = num;
2. 增强的for循环：
增强的for循环提供了一种简洁的方式遍历数组或集合，不需要使用传统的索引方式。
int[] numbers = {1, 2, 3, 4, 5}; // 增强的for循环遍历数组 for (int num : numbers) { System.out.println(num); } List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); names.add("Charlie"); // 增强的for循环遍历集合 for (String name : names) { System.out.println(name); }
3. 可变参数：
可变参数允许在方法声明中使用可变数量的参数，而不需要显式创建数组。
public void printValues(String... values) { for (String value : values) { System.out.println(value); } } // 调用可变参数的方法 printValues("Hello", "World"); printValues("Java", "is", "awesome");
4. 泛型：
泛型提供了一种在编译时强制检查类型安全性的机制，并且不需要进行类型转换。
List<String> names = new ArrayList<>(); // 添加元素时进行类型检查 names.add("Alice"); names.add("Bob"); names.add("Charlie"); // 获取元素时不需要进行类型转换 String first = names.get(0); String second = names.get(1);
泛型擦除
对于Java虚拟机来说，他根本不认识Map<String, String> map这样的语法。需要在编译阶段通过类型擦除的方式进行解语法糖。
类型擦除的主要过程如下：
- 将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。
- 移除所有的类型参数。
以下代码：
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.class或是List.class，而只有List.class。
5. 字符串模板：
字符串模板是一种更简洁的方式来构建字符串，可以在字符串中插入变量或表达式。
String name = "Alice"; int age = 30; String message = String.format("My name is %s and I'm %d years old.", name, age); System.out.println(message);
6. try-with-resources：
try-with-resources语句是用于确保在代码块结束后关闭资源的简洁方式。在try块中声明的资源会在代码块结束时自动关闭。
try (FileReader reader = new FileReader("example.txt")) { // 使用reader读取文件 } catch (IOException e) { // 处理异常 }
7. Diamond操作符：
Diamond操作符使得在创建泛型实例时，可以省略类型参数，编译器会根据上下文推断出正确的类型。
List<String> names = new ArrayList<>(); Map<String, Integer> scores = new HashMap<>();
8. Lambda表达式：
Lambda表达式提供了一种更简洁的方式来定义匿名函数，常用于函数式编程和集合操作。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // 使用Lambda表达式进行遍历和操作 numbers.forEach(n -> System.out.println(n)); numbers.stream().filter(n -> n % 2 == 0).forEach(System.out::println);
9. 方法引用：
方法引用是一种使用已有方法作为Lambda表达式的简化形式，常用于函数式接口的实现。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); // 使用方法引用排序集合 names.sort(String::compareToIgnoreCase); // 使用方法引用输出集合元素 names.forEach(System.out::println);
10. 接口的默认方法：
Java 8引入了接口的默认方法，允许在接口中提供方法的默认实现。
public interface MyInterface { void normalMethod(); default void defaultMethod() { System.out.println("This is a default method."); } } public class MyClass implements MyInterface { @Override public void normalMethod() { System.out.println("This is a normal method."); } } MyClass myObject = new MyClass(); myObject.normalMethod(); // 调用正常的方法 myObject.defaultMethod(); // 调用默认方法
11. Optional类：
Optional类是用于处理可能为空的值的容器类，提供了更直观的方式处理空值，避免了NullPointerException。
Optional<String> optionalName = Optional.ofNullable(name); if (optionalName.isPresent()) { String value = optionalName.get(); System.out.println(value); } String value = optionalName.orElse("Default Value"); System.out.println(value);
12. try-with-resources的多资源声明：
Java 9引入了try-with-resources的多资源声明，可以在一个try语句中声明多个资源，并确保它们在代码块结束时自动关闭。
try (FileReader reader = new FileReader("file1.txt"); BufferedReader bufferedReader = new BufferedReader(reader)) { String line; while ((line = bufferedReader.readLine()) != null) { System.out.println(line); } } catch (IOException e) { // 处理异常 }
13. switch表达式：
Java 12引入了switch表达式，它允许在一个switch语句中返回一个值，并且不需要使用break语句。
String dayOfWeek = "Monday"; int dayNumber = switch (dayOfWeek) { case "Monday" -> 1; case "Tuesday" -> 2; case "Wednesday" -> 3; case "Thursday" -> 4; case "Friday" -> 5; case "Saturday" -> 6; case "Sunday" -> 7; default -> throw new IllegalArgumentException("Invalid day of week: " + dayOfWeek); }; System.out.println(dayNumber);
14. instanceof模式匹配：
Java 14引入了instanceof模式匹配，可以直接在条件语句中使用instanceof操作符，并将匹配的对象赋给一个新变量。
if (obj instanceof String str) { System.out.println("Length: " + str.length()); System.out.println("First character: " + str.charAt(0)); }
15. Records：
Java 14引入了Records（记录）类，它是一种简化的类声明方式，用于创建不可变的数据类。编译器会自动生成构造函数、getter和equals/hashCode等方法。
public record Person(String name, int age) { // 可以在这里添加自定义方法 } Person person = new Person("Alice", 30); System.out.println(person.name()); System.out.println(person.age());
16. Switch表达式的新特性：
Java 14进一步增强了switch表达式的功能，包括yield语句、新的case标签和箭头标签等。
int dayNumber = switch (dayOfWeek) { case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> { System.out.println("Weekday"); yield 1; } case "Saturday", "Sunday" -> { System.out.println("Weekend"); yield 2; } default -> throw new IllegalArgumentException("Invalid day of week: " + dayOfWeek); }; System.out.println(dayNumber);
总结：
所谓语法糖就是提供给开发人员便于开发的一种语法而已。
但是这种语法只有开发人员认识。要想被执行，需要进行解糖，即转成JVM认识的语法。当我们把语法糖解糖之后，你就会发现其实我们日常使用的这些方便的语法，其实都是一些其他更简单的语法构成的。
有了这些语法糖，我们在日常开发的时候可以大大提升效率，但是同时也要避免过渡使用。使用之前最好看看源码。了解原理，避免掉坑。
