【Java核心技术卷】Java常见的12个语法糖

最新推荐文章于 2022-08-24 16:42:48 发布
最新推荐文章于 2022-08-24 16:42:48 发布
阅读量1.6k 收藏 4
点赞数 2
文章标签： Java
原文链接：www.baidu.com
版权

转自 https://blog.csdn.net/coder_what/article/details/96310967
附 Java中常用的反编译工具

文章目录

switch

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

编译后的代码

public class tesst {
    public static void main(String[] args) {
        String string;
        String string2 = string = "world";
        int n = -1;
        switch (string2.hashCode()) {
            case 99162322: {
                if (!string2.equals("hello")) break;
                n = 0;
                break;
            }
            case 113318802: {
                if (!string2.equals("world")) break;
                n = 1;
            }
        }
        switch (n) {
            case 0: {
                System.out.println(string);
                break;
            }
            case 1: {
                System.out.println(string);
                break;
            }
        }
    }
}

这样我们可以看出来，字符串需要先进行hash，然后为了防止hash碰撞，又加了equals

之前阿里妹在公众号上发了五道题，其中有一个是这样的：

public class SwitchTest {
    public static void main(String[] args) {
        String param = null;
        switch (param) {
            case "null":
                System.out.println("null");
                break;
            default:
                System.out.println("default");
        }
    }
}

这个题有三种选项，一种是输出null，一种是走default，最后一种是报错。

通过语法糖我们可以发现，switch中比较的是hashCode的值，而null.hashCode()自然会爆出空指针异常
``

forEach

原来的代码

public class ForEach {
    public static void main(String[] args) {
        String[] s = {"fxxk","suger","fxxk","java"};
        for (String s1 : s) {
            System.out.println(s1);
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

编译后的代码

public class ForEach{
    public ForEach(){
    }

    public static void main(String args[]){
        String s[] = {
            "fxxk", "suger", "fxxk", "java"
        };
        String args1[] = s;
        int j = args1.length;
        for(int k = 0; k < j; k++){
            String s1 = args1[k];
            System.out.println(s1);
        }

        List list = new ArrayList();
        for(int i = 0; i < 10; i++)
            list.add(Integer.valueOf(i));

        Integer integer;
        for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(integer))
            
            integer = (Integer)iterator.next();
    }
}

可见，通过集合类是通过迭代器来实现了增强for循环，String通过普通的for循环来增强for循环。同时，因为其用了迭代器，我们需要注意，在foreach的时候只能遍历，不能修改。否则会爆出java.util.ConcurrentModificationException异常

lambda

原始代码

import java.util.ArrayList;
import java.util.List;
public class Lambda {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        list.forEach(System.out::println);
    }
}

编译后代码

import java.io.PrintStream;
import java.lang.invoke.LambdaMetafactory;
import java.util.ArrayList;
import java.util.function.Consumer;

public class Lambda {
    public static void main(String[] arrstring) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for (int i = 0; i < 10; ++i) {
            arrayList.add(i);
        }
        
        PrintStream printStream = System.out;
        printStream.getClass();
        
        arrayList.forEach(
            (Consumer<Integer>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, println(java.lang.Object ), (Ljava/lang/Integer;)V)((PrintStream)printStream));
    }

}

我们可以看出lambda和内部类的不同之处，内部类是生成了多个类文件，而lambda则是在一个类文件中，最多生成多个方法而已

if

原始代码

    public static void main(String[] args) {
        if (true){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
        if (false){
            System.out.println("false");
        }else{
            System.out.println(false);
        }
    }

编译过的文件

    public static void main(String args[])
    {
        System.out.println("true");
        System.out.println(false);
    }

enum

原始代码

public enum EnumClass {
    SPRING,SUMMER,FALL,WINTER;
}

编译后的代码

public final class EnumClass extends Enum
{

    public static EnumClass[] values()
    {
        return (EnumClass[])$VALUES.clone();
    }

    public static EnumClass valueOf(String name)
    {
        return (EnumClass)Enum.valueOf(suger/EnumClass, name);
    }

    private EnumClass(String s, int i)
    {
        super(s, i);
    }

    public static final EnumClass SPRING;
    public static final EnumClass SUMMER;
    public static final EnumClass FALL;
    public static final EnumClass WINTER;
    private static final EnumClass $VALUES[];

    static 
    {
        SPRING = new EnumClass("SPRING", 0);
        SUMMER = new EnumClass("SUMMER", 1);
        FALL = new EnumClass("FALL", 2);
        WINTER = new EnumClass("WINTER", 3);
        $VALUES = (new EnumClass[] {
            SPRING, SUMMER, FALL, WINTER
        });
    }
}

我们可以看出，枚举是继承了Enum类的，同时他也是final，即不可继承的。

tryWithResource

源代码

public class TryWith {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new                   FileReader("d:\\TryWith.jad"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

编译后的代码

public class TryWith
{
    public TryWith()
    {
    }
    public static void main(String args[])
    {
        try
        {
            BufferedReader br = new BufferedReader(new FileReader("d:TryWith.jad"));
            String line;
            try
            {
                while((line = br.readLine()) != null) 
                    System.out.println(line);
            }
            catch(Throwable throwable)
            {
                try
                {
                    br.close();
                }
                catch(Throwable throwable1)
                {
                    throwable.addSuppressed(throwable1);
                }
                throw throwable;
            }
            br.close();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

我们可以看到，是编译器帮我们把资源关闭了

assert

原始代码

public class Assert {
    public static void main(String[] args) {
        int a = 1;
        assert a > 0;
        System.out.println(a);
    }
}

编译代码

public class Assert
{

    public Assert()
    {
    }

    public static void main(String args[])
    {
        int a = 1;
        if(!$assertionsDisabled && a <= 0)
        {
            throw new AssertionError();
        } else
        {
            System.out.println(a);
            return;
        }
    }

    static final boolean $assertionsDisabled = !suger/Assert.desiredAssertionStatus();

}

我们可以看到，断言通过if语句来执行

变长参数

原始代码

public class Long {
    public static void main(String... args) {
        String[] zi = {"i","am","zi","10ng"};
        ma(zi);
    }

    private static void ma(String... args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

编译之后

public class Long{
    public Long(){
    }

    public static transient void main(String args[]){
        String zi[] = {"i", "am", "zi", "10ng"};
        ma(zi);
    }

    private static transient void ma(String args[]){
        String as[] = args;
        int i = as.length;
        for(int j = 0; j < i; j++){
            String arg = as[j];
            System.out.println(arg);
        }
    }

自动装拆箱

原始代码

    public static void main(String[] args) {
        int a = 1;
        Integer b;
        b  = a;
        a = b;
    }

编译之后

    public static void main(String args[])
    {
        int a = 1;
        Integer b = Integer.valueOf(a);
        a = b.intValue();
    }

同时我们需要知道，在JDK5之后，Integer的操作中引入了一个新功能来节省内存和提高性能。即，整型对象通过使用相同的对象引用实现了缓存和重用。适用于整数值区间-128 至 +127。

泛型

源代码

public class Generic extends Pair<String>{
    private String first;
    @Override
    public void setFirst(String first) {
        this.first = first;
    }
}
class Pair<T>{
    private T first;
    private T second;

    Pair() {
    }
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() {
        return first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}

编译后的代码

public class Generic extends Pair{
    private String first;
	public Generic()    {
    }
    public void setFirst(String first)    {
        this.first = first;
    }
    public volatile void setFirst(Object obj)   {
        setFirst((String)obj);
    }
    public volatile void setSecond(Object obj)    {
        super.setSecond(obj);
    }
    public volatile Object getSecond()    {
        return super.getSecond();
    }
    public volatile Object getFirst()    {
        return super.getFirst();
    }
}
class Pair{
    Pair(){
    }
    public Pair(Object first, Object second)    {
        this.first = first;
        this.second = second;
    }
    public Object getFirst()    {
        return first;
    }
    public void setFirst(Object first)    {
        this.first = first;
    }
    public Object getSecond()    {
        return second;
    }
    public void setSecond(Object second)   {
        this.second = second;
    }
    private Object first;
    private Object second;
}

注意此处继承之后的桥接方法

同时，我们需要知道因为类型擦除而出现的错误

内部类

这个参考我的文章【Java核心技术卷】深入理解Java的内部类

多态

原始代码

class GrandFather{
    private int a;
    GrandFather() {
        a = 10;
    }
    public GrandFather method() {
        System.out.println("--------调用GrandFather method()方法");
        return new GrandFather();
    }
}
//父类
class Father extends GrandFather {
    private int b;
    Father() {
        b = 20;
    }
    @Override
    public Father method() {
        System.out.println("--------调用Father method()方法");
        return new Father();
    }
}

编译器编译过后的Father类：

class Father extends GrandFather
{
	private int b;
    Father(){
        b = 20;
    }
    public Father method(){
        System.out.println("--------\u8C03\u7528Father method()\u65B9\u6CD5");
        return new Father();
    }
    public volatile GrandFather method(){
        return method();
    }
}
沉晓
关注
浅析java常见语法糖
默默草
07-09 477
a
谈一谈JAVA里有哪些语法糖
重口味码农
09-24 1367
谈一谈JAVA里的语法糖 上周在听大牛分享JVM编译优化时，提到了在编译阶段会进行的一个步骤：解语法糖。他提出了一个问题是：JAVA里有哪些语法糖，听到这个问题，似乎很容易回答，因为我们都知道java有很多语法糖，但话到嘴边，也就只能想起字符串拼接和foreach来，果然，没有经过系统的梳理，一些听起来简单的知识点也会难倒你，所以我来梳理一下，看java里到底有哪些语法糖。 概述 在搜狗百科中，语...
怎么才能学好Java编程 常见的语法糖都有哪些
qq_43444478的博客
06-17 185
怎么才能学好Java编程？常见的语法糖都有哪些？语法糖，是由英国计算机科学家彼得·约翰·兰达(Peter J. Landin)发明的一个术语，简单来说就是对现有语法的一个封装。使用语法糖能够增加程序的可读性，减少程序代码出错的机会。作为一种与平台无关的高级编程语言，Java中也含有语法糖，这些语法糖并不被虚拟机所支持，在编译成字节码阶段会自动转换成简单常用的语法。下面就给大家介绍几个常见的语法糖。...
Java中有哪些语法糖？
weixin_30918633的博客
01-01 87
不要你写汇编，Java句句是糖 不能同意上面的这句话，要说为什么，首先要定义下面要讲的“语法糖”。 语法糖指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，并没有给语言添加什么新东西，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。语法糖_百度百科 从上面可以看出，就Java语言而言，语法糖并没有给class级别的代码新增其他特性，而...
大家都喜欢吃糖，你知道java有哪些语法糖吗？
qq_31564573的博客
12-03 151
语法糖或许能提升效率，或许能提升严谨性，或许减少出错的机会，容易让我们产生依赖，所以要看清程序代码的真实面目。
Java核心技术+卷1+基础知识+原书第10版-中文版扫描-带书签已OCR
12-20
### Java核心技术卷1基础知识 #### 一、Java编程语言概述 - **历史背景**：Java由Sun Microsystems公司于1995年推出，旨在为嵌入式设备和消费电子产品提供一个平台。随着互联网的发展，Java逐渐成为企业级应用开发...
coreJava:Java核心技术卷
05-09
《Java核心技术卷》是Java开发领域的一本经典著作，涵盖了Java编程的基础到高级主题，是学习和提升Java技能的重要资源。在这个压缩包“coreJava-master”中，我们可能找到了一个包含源代码、示例和练习的项目，用于...
java核心技术卷1
09-26
根据提供的文件信息，“Java核心技术卷1”主要涵盖了Java的基础知识，并基于原书第9版进行了讲解。接下来将从几个方面详细展开这些知识点。 ### Java语言基础 #### 1. Java概述 - **定义与特点**：Java是一种面向...
《Java 核心技术 卷I 》第12版，涵盖Java17新特性（英文版）
最新发布
01-25
《Java核心技术 卷I 》第12版是Java编程领域的一本权威指南，全面涵盖了Java 17的最新特性。这本书旨在帮助开发者深入理解Java语言的核心概念、语法和高级特性，通过大量的实例来教授如何有效地进行Java开发。 第一...
java核心技术卷1卷2
07-31
java核心技术卷1，2.zip　　
Java的语法糖
孙平平的博客
08-31 2048
Java的语法糖 语法糖 语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。 解语法糖 Java中最常用的语法糖主要是泛型、变长数组、自动...
语法糖java_Java编程常见的语法糖有哪些？
weixin_28916817的博客
02-20 51
自动装箱与拆箱、变长参数自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。一般来说，装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的xxxValue方法实现的。变长参数特性是在JDK1.5中引入的，使用变长参数有两个条件，一是变长的那一部分...
Java语法糖
zhaohong_bo的专栏
04-10 285
先Mark，需要后续补齐、 参考： https://www.cnblogs.com/qingshanli/p/9375040.html
什么是语法糖？Java中有哪些语法糖？
飞跃
08-24 387
什么是语法糖？Java中有哪些语法糖？
三种java语法糖_java中的12个语法糖
weixin_34446948的博客
03-01 234
01 switch 支持 String 与枚举从 Java 7 开始，Java 语言中的语法糖在逐渐丰富，其中一个比较重要的就是 Java 7 中 switch 开始支持 String。在开始 coding 之前先科普下，Java 中的 swith 自身原本就支持基本类型。比如 int、char 等。对于 int 类型，直接进行数值的比较。对于 char 类型则是比较其 ascii 码。所以，对于...
java-12 个语法糖
嘻哈熊的专栏
03-01 259
原文地址 mp.weixin.qq.com 本文从 Java 编译原理角度，深入字节码及 class 文件，抽丝剥茧，了解 Java 中的语法糖原理及用法，帮助大家在学会如何使用 Java 语法糖的同时，了解这些语法糖背后的原理 语法糖 语法糖（Syntactic Sugar），也称糖衣语法，是由英国计算机学家 Peter.J.Landin 发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。简而言之，语法糖让程序更加简洁，有更高的可读性。 有意思的是.
JAVA-12 个语法糖
嘻哈熊的专栏
08-02 415
前面介绍了 12 种 Java 中常用的语法糖。所谓语法糖就是提供给开发人员便于开发的一种语法而已。但是这种语法只有开发人员认识。要想被执行，需要进行解糖，即转成 JVM 认识的语法。当我们把语法糖解糖之后，你就会发现其实我们日常使用的这些方便的语法，其实都是一些其他更简单的语法构成的。有了这些语法糖，我们在日常开发的时候可以大大提升效率，但是同时也要避免过渡使用。使用之前最好了解下原理，避免掉坑。END。...
Java 的这12个语法糖，有点甜
热门推荐
LoveSummer
06-23 1万+
我们在日常开发中经常会使用到诸如泛型、自动拆箱和装箱、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等，我们只觉得用的很爽，因为这些特性能够帮助我们减轻开发工作量；但我们未曾认真研究过这些特性的本质是什么，那么这篇文章，cxuan 就来为你揭开这些特性背后的真相。在聊之前我们需要先了解一下 的概念：，也叫做糖衣语法，是英国科学家发明的一个术语，通常来说使用语法糖能够增加程序的，从而减少程序代码出错的机会，真是又香又甜。语法糖指的是计算机语言中添加的某种语法，这
Java核心技术卷2：第9版高级特性详解
《Java核心技术（卷2）：高级特性（原书第9版）》是由美国计算机科学家Cay S. Horstmann和Gary Cornell合著的经典著作，该书作为Java核心技术系列的一部分，深入探讨了Java语言的高级特性和复杂应用。本书是针对Java...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值