投稿
  1. 极客之音首页
  2. 其他分类
  3. 微信精选

Java语法tang讲解

小半 • • 微信精选 • 阅读 104

Java语法tang讲解

当谈到Java中的语法糖时，我们指的是一些在编译器中进行转换的语法结构，使代码更易读、更易写，但在底层仍然会被转换为普通的Java代码。下面详细介绍每个语法糖，并给出相应的代码示例：

1. 自动装箱和拆箱：

自动装箱和拆箱使得基本数据类型和对应的包装类型之间的转换更加方便。自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。

byteshortcharintlongfloatdoublebooleanByteShortCharacterIntegerLongFloatDoubleBoolean


Integer num = 10;

int value = num;

2. 增强的for循环：

增强的for循环提供了一种简洁的方式遍历数组或集合，不需要使用传统的索引方式。

int[] numbers = {1, 2, 3, 4, 5};

for (int num : numbers) {
    System.out.println(num);
}

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

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

以下代码：

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")) {

} 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);

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认识的语法。当我们把语法糖解糖之后，你就会发现其实我们日常使用的这些方便的语法，其实都是一些其他更简单的语法构成的。有了这些语法糖，我们在日常开发的时候可以大大提升效率，但是同时也要避免过渡使用。使用之前最好看看源码。了解原理，避免掉坑。

关注“夏壹分享”发送“资源”获取238本进阶书籍和大厂面试Java语法tang讲解


原文始发于微信公众号（夏壹分享）：Java语法tang讲解

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/155050.html

赞 (0)
小半的头像小半
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！