Java 常用语法糖及其对比总结

TE-茶叶蛋

于 2024-10-11 10:30:28 发布

阅读量198

点赞数 16

分类专栏： java 文章标签： java python 开发语言

本文链接：https://blog.csdn.net/Bruce__taotao/article/details/142847044

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

前言

前言

Java 中的语法糖使代码更简洁、更易读，同时在某些情况下提高开发效率和运行性能。下面列举了 50 个常用的语法糖，每条语法糖都详细比较了使用和不使用的代码，并解释了其优势。

1. 增强的 `for` 循环

使用语法糖：

for (String item : list) {
    System.out.println(item);
}

不使用语法糖：

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

优势：增强的 for 循环避免了手动处理索引，更加简洁和安全，减少了数组越界的风险。

2. 泛型

使用语法糖：

List<String> list = new ArrayList<>();
list.add("Hello");
String s = list.get(0);

不使用语法糖：

List list = new ArrayList();
list.add("Hello");
String s = (String) list.get(0);

优势：泛型提供了类型安全，避免了强制类型转换和 ClassCastException。

3. 自动装箱/拆箱

使用语法糖：

Integer i = 10;  // 自动装箱
int j = i;       // 自动拆箱

不使用语法糖：

Integer i = Integer.valueOf(10);
int j = i.intValue();

优势：减少了手动调用装箱和拆箱方法的代码量，简化了代码。

4. `var` 关键字（Java 10）

使用语法糖：
```
var list = new ArrayList<String>();
```

不使用语法糖：

ArrayList<String> list = new ArrayList<String>();

优势：减少类型重复，编译器自动推断类型，代码更简洁。

5. `try-with-resources`

使用语法糖：

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    System.out.println(br.readLine());
}

不使用语法糖：

BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("file.txt"));
    System.out.println(br.readLine());
} finally {
    if (br != null) {
        br.close();
    }
}

优势：自动管理资源关闭，避免资源泄漏，减少了 finally 块的冗余代码。

6. Lambda 表达式

使用语法糖：

list.forEach(item -> System.out.println(item));

不使用语法糖：

list.forEach(new Consumer<String>() {
    @Override
    public void accept(String item) {
        System.out.println(item);
    }
});

优势：简化了匿名类的写法，提升了代码可读性和开发效率。

7. Stream API

使用语法糖：

List<String> filteredList = list.stream()
                                .filter(s -> s.length() > 3)
                                .collect(Collectors.toList());

不使用语法糖：

List<String> filteredList = new ArrayList<>();
for (String s : list) {
    if (s.length() > 3) {
        filteredList.add(s);
    }
}

优势：使用 Stream API 简化了集合操作逻辑，增强了代码的可读性和可维护性。

8. `Optional`

使用语法糖：

Optional<String> name = Optional.ofNullable(getName());
name.ifPresent(System.out::println);

不使用语法糖：

String name = getName();
if (name != null) {
    System.out.println(name);
}

优势：减少了对 null 值的显式检查，避免了 NullPointerException 的风险。

9. 方法引用

使用语法糖：
```
list.forEach(System.out::println);
```

不使用语法糖：

list.forEach(item -> System.out.println(item));

优势：进一步简化了 Lambda 表达式的写法，使代码更加简洁明了。

10. `switch` 支持 `String`

使用语法糖：

switch (command) {
    case "start":
        start();
        break;
    case "stop":
        stop();
        break;
    default:
        unknown();
}

不使用语法糖：

if ("start".equals(command)) {
    start();
} else if ("stop".equals(command)) {
    stop();
} else {
    unknown();
}

优势：switch 支持 String 后，代码结构更加清晰，减少了 if-else 嵌套。

11. `diamond` 运算符（`<>`）

使用语法糖：
```
List<String> list = new ArrayList<>();
```

不使用语法糖：

List<String> list = new ArrayList<String>();

优势：减少了类型参数的重复声明，使代码更加简洁。

12. 菱形类型推断（Java 9+）

使用语法糖：

List<?> list = new ArrayList<>(List.of("A", "B", "C"));

不使用语法糖：

List<?> list = new ArrayList<Object>(List.of("A", "B", "C"));

优势：推断了容器类型，减少了类型声明的冗余。

13. `text blocks`（Java 13）

使用语法糖：

String text = """
              This is a text block.
              It preserves formatting.
              """;

不使用语法糖：

String text = "This is a text block.\n"
            + "It preserves formatting.\n";

优势：使多行字符串处理更加直观，减少了拼接符号和转义字符。

14. 多重 catch 块

使用语法糖：

try {
    // 可能抛出多种异常
} catch (IOException | SQLException e) {
    e.printStackTrace();
}

不使用语法糖：

try {
    // 可能抛出多种异常
} catch (IOException e) {
    e.printStackTrace();
} catch (SQLException e) {
    e.printStackTrace();
}

优势：减少了多余的 catch 块，简化了异常处理代码。

15. 默认方法和静态接口方法（Java 8）

使用语法糖：

interface MyInterface {
    default void defaultMethod() {
        System.out.println("Default method");
    }

    static void staticMethod() {
        System.out.println("Static method");
    }
}

不使用语法糖：

interface MyInterface {
    // 无法在接口中定义默认或静态方法
}

优势：允许接口提供默认实现和静态方法，增强接口的灵活性。

16. `final` 关键字（局部变量和方法参数）

使用语法糖：
```
final int x = 10;
```
不使用语法糖：
```
int x = 10;
```
优势：确保变量不可修改，增加代码的健壮性，特别适合多线程编程。

17. 私有构造方法防止实例化

使用语法糖：
```
private Singleton() {}
```
不使用语法糖：
```
// 默认构造函数允许实例化
```
优势：防止类被外部实例化，用于工具类和单例模式。

18. 静态导入（`static import`）

使用语法糖：

import static java.lang.Math.*;

double result = sqrt(25);

不使用语法糖：
```
double result = Math.sqrt(25);
```
优势：简化类名调用，使代码更简洁，尤其适合常用工具类方法。

19. `instanceof` 带类型转换（Java 16）

使用语法糖：

if (obj instanceof String s) {
    System.out.println(s.toUpperCase());
}

不使用语法糖：

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.toUpperCase());
}

优势：减少类型检查后的显式强制类型转换，代码更加紧凑。

20. 菱形运算符结合泛型方法

使用语法糖：

MyClass<String> myObject = MyClass.createInstance();

不使用语法糖：

MyClass<String> myObject = MyClass.<String>createInstance();

优势：消除了在调用泛型方法时显式声明类型的必要，代码更加简洁。

21. 三目运算符（`?:`）

使用语法糖：
```
int result = (a > b) ? a : b;
```

不使用语法糖：

int result;
if (a > b) {
    result = a;
} else {
    result = b;
}

优势：简化条件选择逻辑，使代码更加简洁。

22. 数组初始化语法

使用语法糖：
```
int[] arr = {1, 2, 3};
```

不使用语法糖：

int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

优势：简化数组初始化操作，减少样板代码。

23. `forEach` 方法（Java 8）

使用语法糖：
```
list.forEach(System.out::println);
```

不使用语法糖：

for (String item : list) {
    System.out.println(item);
}

优势：简化集合的遍历操作，结合方法引用和 Lambda 提升代码简洁性。

24. `default` 方法（Java 8）

使用语法糖：

interface MyInterface {
    default void print() {
        System.out.println("Hello");
    }
}

不使用语法糖：

interface MyInterface {
    void print();
}

class MyClass implements MyInterface {
    @Override
    public void print() {
        System.out.println("Hello");
    }
}

优势：允许在接口中提供默认方法实现，减少实现类中的重复代码。

25. 可变参数（`varargs`）

使用语法糖：

public void printNumbers(int... numbers) {
    for (int number : numbers) {
        System.out.println(number);
    }
}

不使用语法糖：

public void printNumbers(int[] numbers) {
    for (int number : numbers) {
        System.out.println(number);
    }
}

优势：允许方法接收可变数量的参数，提供更灵活的 API。

26. `Objects.requireNonNull`

使用语法糖：

Objects.requireNonNull(obj, "Object cannot be null");

不使用语法糖：

if (obj == null) {
    throw new NullPointerException("Object cannot be null");
}

优势：简化空指针检查，减少冗余的 null 检查代码。

27. `Collections.singletonList`

使用语法糖：

List<String> list = Collections.singletonList("item");

不使用语法糖：

List<String> list = new ArrayList<>();
list.add("item");

优势：创建不可变单元素集合，简化初始化代码。

28. 双冒号操作符（方法引用）

使用语法糖：
```
list.forEach(System.out::println);
```

不使用语法糖：

list.forEach(item -> System.out.println(item));

优势：进一步简化 Lambda 表达式，提高代码简洁性。

29. 字符串拼接使用 `+` 号

使用语法糖：
```
String result = "Hello " + name + "!";
```

不使用语法糖：

String result = new StringBuilder().append("Hello ").append(name).append("!").toString();

优势：编译器会将 + 号操作优化为 StringBuilder，简化代码。

30. 局部内部类

使用语法糖：

class Outer {
    void outerMethod() {
        class Inner {
            void innerMethod() {
                System.out.println("Inner");
            }
        }
        Inner inner = new Inner();
        inner.innerMethod();
    }
}

不使用语法糖：

class Outer {
    void outerMethod() {
        // 需要额外创建一个顶级类
    }
}

优势：简化内部类的使用场景，不需要显式创建顶级类。

31. `Pattern.compile` 静态工厂方法

使用语法糖：

Pattern pattern = Pattern.compile("\\d+");

不使用语法糖：
```
Pattern pattern = new Pattern("\\d+");
```
优势：使用静态工厂方法创建对象，简化实例化过程。

32. `Comparator.comparing` 静态方法

使用语法糖：

list.sort(Comparator.comparing(Person::getAge));

不使用语法糖：

list.sort(new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.getAge(), p2.getAge());
    }
});

优势：简化比较器的实现，使排序逻辑更直观。

33. 构造器中的 `this` 调用

使用语法糖：

public MyClass(int x) {
    this(x, 0);
}

public MyClass(int x, int y) {
    this.x = x;
    this.y = y;
}

不使用语法糖：

public MyClass(int x) {
    this.x = x;
    this.y = 0;
}

public MyClass(int x, int y) {
    this.x = x;
    this.y = y;
}

优势：通过调用另一个构造函数减少代码重复。

34. `Arrays.asList` 工厂方法

使用语法糖：

List<String> list = Arrays.asList("A", "B", "C");

不使用语法糖：
```
List<String> list = new
```

ArrayList<>();
list.add(“A”);
list.add(“B”);
list.add(“C”);


- **优势**：简化集合的初始化操作，提升代码可读性。

---

### 35. **`Collectors.toList`**

- **使用语法糖**：
```java
List<String> result = stream.collect(Collectors.toList());

不使用语法糖：

List<String> result = new ArrayList<>();
stream.forEach(result::add);

优势：简化流操作中的集合收集，代码更简洁。

36. `Optional.orElse`

使用语法糖：

String result = optionalString.orElse("default");

不使用语法糖：

String result = (optionalString != null) ? optionalString : "default";

优势：减少 null 检查的冗余代码。

37. 局部匿名类

使用语法糖：

Runnable runnable = () -> System.out.println("Running");

不使用语法糖：

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
};

优势：减少匿名类的冗余代码，提升简洁性。

38. `assert` 语句

使用语法糖：
```
assert condition : "Condition failed";
```

不使用语法糖：

if (!condition) {
    throw new AssertionError("Condition failed");
}

优势：简化条件检查，方便调试。

39. `Map.of` 工厂方法（Java 9）

使用语法糖：

Map<String, String> map = Map.of("key1", "value1", "key2", "value2");

不使用语法糖：

Map<String, String> map = new HashMap<>();
map.put("key1", "value1");
map.put("key2", "value2");

优势：快速创建不可变的 Map，简化初始化代码。

40. 静态内部类

使用语法糖：
```
static class Inner {
    // ...
}
```

不使用语法糖：

class Inner {
    // 静态上下文下无法使用
}

优势：允许类嵌套使用静态类，方便组织代码结构。

41. `Collectors.joining`

使用语法糖：

String result = list.stream().collect(Collectors.joining(", "));

不使用语法糖：

StringBuilder sb = new StringBuilder();
for (String s : list) {
    if (sb.length() > 0) sb.append(", ");
    sb.append(s);
}
String result = sb.toString();

优势：简化了字符串的拼接逻辑，代码更加简洁。

42. 多异常处理

使用语法糖：

try {
    // 可能抛出多种异常
} catch (IOException | SQLException e) {
    e.printStackTrace();
}

不使用语法糖：

try {
    // 可能抛出多种异常
} catch (IOException e) {
    e.printStackTrace();
} catch (SQLException e) {
    e.printStackTrace();
}

优势：简化了异常处理代码，减少了重复的 catch 块。

43. `Objects.equals`

使用语法糖：

if (Objects.equals(a, b)) {
    // ...
}

不使用语法糖：

if (a == b || (a != null && a.equals(b))) {
    // ...
}

优势：简化了对象比较操作，避免了显式 null 检查。

44. 匿名函数（Lambda 表达式）

使用语法糖：

Runnable r = () -> System.out.println("Hello");

不使用语法糖：

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

优势：减少匿名类的样板代码，提升代码简洁性。

45. `Function.identity`

使用语法糖：

Map<String, String> map = list.stream().collect(Collectors.toMap(Function.identity(), String::toUpperCase));

不使用语法糖：

Map<String, String> map = list.stream().collect(Collectors.toMap(s -> s, String::toUpperCase));

优势：提供了统一的自引用映射，减少代码冗余。

46. 局部变量类型推断（`var` 关键字，Java 10+）

使用语法糖：
```
var list = new ArrayList<String>();
```

不使用语法糖：

ArrayList<String> list = new ArrayList<String>();

优势：简化了局部变量的声明，编译器自动推断类型。

47. 类型推断（构造函数中）

使用语法糖：
```
List<String> list = new ArrayList<>();
```

不使用语法糖：

List<String> list = new ArrayList<String>();

优势：减少类型参数的重复声明。

48. 布尔表达式的简化

使用语法糖：
```
if (isAvailable) {
    // ...
}
```

不使用语法糖：

if (isAvailable == true) {
    // ...
}

优势：简化了布尔值的判断，代码更简洁。

49. 多行字符串（`text blocks`，Java 13+）

使用语法糖：

String text = """
              Hello,
              World!
              """;

不使用语法糖：

String text = "Hello,\n" +
              "World!";

优势：简化了多行字符串的定义，自动处理换行和缩进。

50. 多线程简化（`Executors` 工具类）

使用语法糖：

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task"));

不使用语法糖：

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Task");
    }
});
thread.start();

优势：使用 Executors 工具类简化了多线程的管理和创建。

总结

通过这些常用语法糖，Java 代码得到了极大的简化和优化，既提升了代码的可读性，也提高了开发效率。在实际开发中，合理使用这些语法糖可以有效减少样板代码，提升代码质量。

TE-茶叶蛋

关注

16
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

Java 常用语法糖及其对比总结

文章目录

前言

1. 增强的 for 循环

2. 泛型

3. 自动装箱/拆箱

4. var 关键字（Java 10）

5. try-with-resources

6. Lambda 表达式

7. Stream API

8. Optional

9. 方法引用

10. switch 支持 String

11. diamond 运算符（<>）

12. 菱形类型推断（Java 9+）

13. text blocks（Java 13）

14. 多重 catch 块

15. 默认方法和静态接口方法（Java 8）

16. final 关键字（局部变量和方法参数）

17. 私有构造方法防止实例化

18. 静态导入（static import）

19. instanceof 带类型转换（Java 16）

20. 菱形运算符结合泛型方法

21. 三目运算符（?:）

22. 数组初始化语法

23. forEach 方法（Java 8）

24. default 方法（Java 8）

25. 可变参数（varargs）

26. Objects.requireNonNull

27. Collections.singletonList

28. 双冒号操作符（方法引用）

29. 字符串拼接使用 + 号

30. 局部内部类

31. Pattern.compile 静态工厂方法

32. Comparator.comparing 静态方法

33. 构造器中的 this 调用

34. Arrays.asList 工厂方法

36. Optional.orElse

37. 局部匿名类

38. assert 语句

39. Map.of 工厂方法（Java 9）

40. 静态内部类

41. Collectors.joining

42. 多异常处理

43. Objects.equals

44. 匿名函数（Lambda 表达式）

45. Function.identity

46. 局部变量类型推断（var 关键字，Java 10+）

47. 类型推断（构造函数中）

48. 布尔表达式的简化

49. 多行字符串（text blocks，Java 13+）

50. 多线程简化（Executors 工具类）

总结

1. 增强的 `for` 循环

4. `var` 关键字（Java 10）

5. `try-with-resources`

8. `Optional`

10. `switch` 支持 `String`

11. `diamond` 运算符（`<>`）

13. `text blocks`（Java 13）

16. `final` 关键字（局部变量和方法参数）

18. 静态导入（`static import`）

19. `instanceof` 带类型转换（Java 16）

21. 三目运算符（`?:`）

23. `forEach` 方法（Java 8）

24. `default` 方法（Java 8）

25. 可变参数（`varargs`）

26. `Objects.requireNonNull`

27. `Collections.singletonList`

29. 字符串拼接使用 `+` 号

31. `Pattern.compile` 静态工厂方法

32. `Comparator.comparing` 静态方法

33. 构造器中的 `this` 调用

34. `Arrays.asList` 工厂方法

36. `Optional.orElse`

38. `assert` 语句

39. `Map.of` 工厂方法（Java 9）

41. `Collectors.joining`

43. `Objects.equals`

45. `Function.identity`

46. 局部变量类型推断（`var` 关键字，Java 10+）

49. 多行字符串（`text blocks`，Java 13+）

50. 多线程简化（`Executors` 工具类）