Java基础常见知识ampampamp面试题总结（中）

　　面向对象基础面向对象和面向过程的区别
　　两者的主要区别在于解决问题的方式不同：面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。
　　另外，面向对象开发的程序一般更易维护、易复用、易扩展。成员变量与局部变量的区别语法形式：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被public，private，static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；但是，成员变量和局部变量都能被final所修饰。存储方式：从变量在内存中的存储方式来看，如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。生存时间：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。默认值：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外：被final修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。创建一个对象用什么运算符？对象实体与对象引用有何不同？
　　new运算符，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。
　　一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）；一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）。对象的相等和引用相等的区别对象的相等一般比较的是内存中存放的内容是否相等。引用相等一般比较的是他们指向的内存地址是否相等。类的构造方法的作用是什么？
　　构造方法是一种特殊的方法，主要作用是完成对象的初始化工作。如果一个类没有声明构造方法，该程序能正确执行吗？
　　如果一个类没有声明构造方法，也可以执行！因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java就不会再添加默认的无参数的构造方法了，我们一直在不知不觉地使用构造方法，这也是为什么我们在创建对象的时候后面要加一个括号（因为要调用无参的构造方法）。如果我们重载了有参的构造方法，记得都要把无参的构造方法也写出来（无论是否用到），因为这可以帮助我们在创建对象的时候少踩坑。构造方法有哪些特点？是否可被override？
　　构造方法特点如下：名字与类名相同。没有返回值，但不能用void声明构造函数。生成类的对象时自动执行，无需调用。
　　构造方法不能被override（重写），但是可以overload（重载），所以你可以看到一个类中有多个构造函数的情况。面向对象三大特征封装
　　封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息（也就是属性），但是可以通过遥控器（方法）来控制空调。如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。就好像如果没有空调遥控器，那么我们就无法操控空凋制冷，空调本身就没有意义了（当然现在还有很多其他方法，这里只是为了举例子）。publicclassStudent｛privateintid；id属性私有化privateStringname；name属性私有化获取id的方法publicintgetId（）｛returnid；｝设置id的方法publicvoidsetId（intid）｛this。idid；｝获取name的方法publicStringgetName（）｛returnname；｝设置name的方法publicvoidsetName（Stringname）｛this。namename；｝｝继承
　　不同类型的对象，相互之间经常有一定数量的共同点。例如，小明同学、小红同学、小李同学，都共享学生的特性（班级、学号等）。同时，每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好，小红的性格惹人喜爱；小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间，提高我们的开发效率。
　　关于继承如下3点请记住：子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。子类可以拥有自己属性和方法，即子类可以对父类进行扩展。子类可以用自己的方式实现父类的方法。（以后介绍）。多态
　　多态，顾名思义，表示一个对象具有多种的状态，具体表现为父类的引用指向子类的实例。
　　多态的特点：对象类型和引用类型之间具有继承（类）实现（接口）的关系；引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；多态不能调用只在子类存在但在父类不存在的方法；如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。接口和抽象类有什么共同点和区别？
　　共同点：都不能被实例化。都可以包含抽象方法。都可以有默认实现的方法（Java8可以用default关键字在接口中定义默认方法）。
　　区别：接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系（比如说我们抽象了一个发送短信的抽象类，）。一个类只能继承一个类，但是可以实现多个接口。接口中的成员变量只能是publicstaticfinal类型的，不能被修改且必须有初始值，而抽象类的成员变量默认default，可在子类中被重新定义，也可被重新赋值。深拷贝和浅拷贝区别了解吗？什么是引用拷贝？
　　关于深拷贝和浅拷贝区别，我这里先给结论：浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。
　　上面的结论没有完全理解的话也没关系，我们来看一个具体的案例！
　　浅拷贝
　　浅拷贝的示例代码如下，我们这里实现了Cloneable接口，并重写了clone（）方法。
　　clone（）方法的实现很简单，直接调用的是父类Object的clone（）方法。publicclassAddressimplementsCloneable｛privateStringname；省略构造函数、GetterSetter方法OverridepublicAddressclone（）｛try｛return（Address）super。clone（）；｝catch（CloneNotSupportedExceptione）｛thrownewAssertionError（）；｝｝｝publicclassPersonimplementsCloneable｛privateAddressaddress；省略构造函数、GetterSetter方法OverridepublicPersonclone（）｛try｛Personperson（Person）super。clone（）；returnperson；｝catch（CloneNotSupportedExceptione）｛thrownewAssertionError（）；｝｝｝
　　测试：Personperson1newPerson（newAddress（武汉））；Personperson1Copyperson1。clone（）；trueSystem。out。println（person1。getAddress（）person1Copy。getAddress（））；
　　从输出结构就可以看出，person1的克隆对象和person1使用的仍然是同一个Address对象。
　　深拷贝
　　这里我们简单对Person类的clone（）方法进行修改，连带着要把Person对象内部的Address对象一起复制。OverridepublicPersonclone（）｛try｛Personperson（Person）super。clone（）；person。setAddress（person。getAddress（）。clone（））；returnperson；｝catch（CloneNotSupportedExceptione）｛thrownewAssertionError（）；｝｝
　　测试：Personperson1newPerson（newAddress（武汉））；Personperson1Copyperson1。clone（）；falseSystem。out。println（person1。getAddress（）person1Copy。getAddress（））；
　　从输出结构就可以看出，虽然person1的克隆对象和person1包含的Address对象已经是不同的了。
　　那什么是引用拷贝呢？简单来说，引用拷贝就是两个不同的引用指向同一个对象。
　　我专门画了一张图来描述浅拷贝、深拷贝、引用拷贝：
　　Java常见类ObjectObject类的常见方法有哪些？
　　Object类是一个特殊的类，是所有类的父类。它主要提供了以下11个方法：native方法，用于返回当前运行时对象的Class对象，使用了final关键字修饰，故不允许子类重写。publicfinalnativeClasslt；？getClass（）native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap。publicnativeinthashCode（）用于比较2个对象的内存地址是否相等，String类对该方法进行了重写以用于比较字符串的值是否相等。publicbooleanequals（Objectobj）naitive方法，用于创建并返回当前对象的一份拷贝。protectednativeObjectclone（）throwsCloneNotSupportedException返回类的名字实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法。publicStringtoString（）native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程（监视器相当于就是锁的概念）。如果有多个线程在等待只会任意唤醒一个。publicfinalnativevoidnotify（）native方法，并且不能重写。跟notify一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。publicfinalnativevoidnotifyAll（）native方法，并且不能重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁，timeout是等待时间。publicfinalnativevoidwait（longtimeout）throwsInterruptedException多了nanos参数，这个参数表示额外时间（以毫微秒为单位，范围是0999999）。所以超时的时间还需要加上nanos毫秒publicfinalvoidwait（longtimeout，intnanos）throwsInterruptedException跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念publicfinalvoidwait（）throwsInterruptedException实例被垃圾回收器回收的时候触发的操作protectedvoidfinalize（）throwsThrowable｛｝和equals（）的区别
　　对于基本类型和引用类型的作用效果是不同的：对于基本数据类型来说，比较的是值。对于引用数据类型来说，比较的是对象的内存地址。
　　因为Java只有值传递，所以，对于来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。
　　equals（）不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。equals（）方法存在于Object类中，而Object类是所有类的直接或间接父类，因此所有的类都有equals（）方法。
　　Object类equals（）方法：publicbooleanequals（Objectobj）｛return（thisobj）；｝
　　equals（）方法存在两种使用情况：类没有重写equals（）方法：通过equals（）比较该类的两个对象时，等价于通过比较这两个对象，使用的默认是Object类equals（）方法。类重写了equals（）方法：一般我们都重写equals（）方法来比较两个对象中的属性是否相等；若它们的属性相等，则返回true（即，认为这两个对象相等）。
　　举个例子（这里只是为了举例。实际上，你按照下面这种写法的话，像IDEA这种比较智能的IDE都会提示你将换成equals（））：StringanewString（ab）；a为一个引用StringbnewString（ab）；b为另一个引用，对象的内容一样Stringaaab；放在常量池中Stringbbab；从常量池中查找System。out。println（aabb）；trueSystem。out。println（ab）；falseSystem。out。println（a。equals（b））；trueSystem。out。println（4242。0）；true
　　String中的equals方法是被重写过的，因为Object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。
　　当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。
　　String类equals（）方法：publicbooleanequals（ObjectanObject）｛if（thisanObject）｛returntrue；｝if（anObjectinstanceofString）｛StringanotherString（String）anObject；intnvalue。length；if（nanotherString。value。length）｛charv1〔〕value；charv2〔〕anotherString。value；inti0；while（n！0）｛if（v1〔i〕！v2〔i〕）returnfalse；i；｝returntrue；｝｝returnfalse；｝hashCode（）有什么用？
　　hashCode（）的作用是获取哈希码（int整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。
　　hashCode（）定义在JDK的Object类中，这就意味着Java中的任何类都包含有hashCode（）函数。另外需要注意的是：Object的hashCode（）方法是本地方法，也就是用C语言或C实现的，该方法通常用来将对象的内存地址转换为整数之后返回。publicnativeinthashCode（）；
　　散列表存储的是键值对（keyvalue），它的特点是：能根据键快速的检索出对应的值。这其中就利用到了散列码！（可以快速找到所需要的对象）为什么要有hashCode？
　　我们以HashSet如何检查重复为例子来说明为什么要有hashCode？
　　下面这段内容摘自我的Java启蒙书《HeadFirstJava》：
　　当你把对象加入HashSet时，HashSet会先计算对象的hashCode值来判断对象加入的位置，同时也会与其他已经加入的对象的hashCode值作比较，如果没有相符的hashCode，HashSet会假设对象没有重复出现。但是如果发现有相同hashCode值的对象，这时会调用equals（）方法来检查hashCode相等的对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了equals的次数，相应就大大提高了执行速度。
　　其实，hashCode（）和equals（）都是用于比较两个对象是否相等。
　　那为什么JDK还要同时提供这两个方法呢？
　　这是因为在一些容器（比如HashMap、HashSet）中，有了hashCode（）之后，判断元素是否在对应容器中的效率会更高（参考添加元素进HashSet的过程）！
　　我们在前面也提到了添加元素进HashSet的过程，如果HashSet在对比的时候，同样的hashCode有多个对象，它会继续使用equals（）来判断是否真的相同。也就是说hashCode帮助我们大大缩小了查找成本。
　　那为什么不只提供hashCode（）方法呢？
　　这是因为两个对象的hashCode值相等并不代表两个对象就相等。
　　那为什么两个对象有相同的hashCode值，它们也不一定是相等的？
　　因为hashCode（）所使用的哈希算法也许刚好会让多个对象传回相同的哈希值。越糟糕的哈希算法越容易碰撞，但这也与数据值域分布的特性有关（所谓哈希碰撞也就是指的是不同的对象得到相同的hashCode）。
　　总结下来就是：如果两个对象的hashCode值相等，那这两个对象不一定相等（哈希碰撞）。如果两个对象的hashCode值相等并且equals（）方法也返回true，我们才认为这两个对象相等。如果两个对象的hashCode值不相等，我们就可以直接认为这两个对象不相等。
　　相信大家看了我前面对hashCode（）和equals（）的介绍之后，下面这个问题已经难不倒你们了。为什么重写equals（）时必须重写hashCode（）方法？
　　因为两个相等的对象的hashCode值必须是相等。也就是说如果equals方法判断两个对象是相等的，那这两个对象的hashCode值也要相等。
　　如果重写equals（）时没有重写hashCode（）方法的话就可能会导致equals方法判断是相等的两个对象，hashCode值却不相等。
　　思考：重写equals（）时没有重写hashCode（）方法的话，使用HashMap可能会出现什么问题。
　　总结：equals方法判断两个对象是相等的，那这两个对象的hashCode值也要相等。两个对象有相同的hashCode值，他们也不一定是相等的（哈希碰撞）。
　　更多关于hashCode（）和equals（）的内容可以查看：JavahashCode（）和equals（）的若干问题解答openinnewwindowStringString、StringBuffer、StringBuilder的区别？
　　可变性
　　String是不可变的（后面会详细分析原因）。
　　StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，不过没有使用final和private关键字修饰，最关键的是这个AbstractStringBuilder类还提供了很多修改字符串的方法比如append方法。abstractclassAbstractStringBuilderimplementsAppendable，CharSequence｛char〔〕value；publicAbstractStringBuilderappend（Stringstr）｛if（strnull）returnappendNull（）；intlenstr。length（）；ensureCapacityInternal（countlen）；str。getChars（0，len，value，count）；countlen；returnthis；｝。。。｝
　　线程安全性
　　String中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
　　性能
　　每次对String类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StringBuilder相比使用StringBuffer仅能获得1015左右的性能提升，但却要冒多线程不安全的风险。
　　对于三者使用的总结：操作少量的数据：适用String单线程操作字符串缓冲区下操作大量数据：适用StringBuilder多线程操作字符串缓冲区下操作大量数据：适用StringBufferString为什么是不可变的？
　　String类中使用final关键字修饰字符数组来保存字符串，所以String对象是不可变的。publicfinalclassStringimplementsjava。io。Serializable，ComparableString，CharSequence｛privatefinalcharvalue〔〕；。。。｝修正：我们知道被final关键字修饰的类不能被继承，修饰的方法不能被重写，修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。因此，final关键字修饰的数组保存字符串并不是String不可变的根本原因，因为这个数组保存的字符串是可变的（final修饰引用类型变量的情况）。
　　String真正不可变有下面几点原因：
　　保存字符串的数组被final修饰且为私有的，并且String类没有提供暴露修改这个字符串的方法。String类被final修饰导致其不能被继承，进而避免了子类破坏String不可变。
　　相关阅读：如何理解String类型值的不可变？知乎提问openinnewwindow
　　补充（来自issue675openinnewwindow）：在Java9之后，String、StringBuilder与StringBuffer的实现改用byte数组存储字符串。
　　publicfinalclassStringimplementsjava。io。Serializable，Comparable，CharSequence｛Stable注解表示变量最多被修改一次，称为稳定的。Stableprivatefinalbyte〔〕value；｝abstractclassAbstractStringBuilderimplementsAppendable，CharSequence｛byte〔〕value；｝
　　Java9为何要将String的底层实现由char〔〕改成了byte〔〕？
　　新版的String其实支持两个编码方案：Latin1和UTF16。如果字符串中包含的汉字没有超过Latin1可表示范围内的字符，那就会使用Latin1作为编码方案。Latin1编码方案下，byte占一个字节（8位），char占用2个字节（16），byte相较char节省一半的内存空间。
　　JDK官方就说了绝大部分字符串对象只包含Latin1可表示的字符。
　　如果字符串中包含的汉字超过Latin1可表示范围内的字符，byte和char所占用的空间是一样的。
　　这是官方的介绍：https：openjdk。java。netjeps254。字符串拼接用还是StringBuilder？
　　Java语言本身并不支持运算符重载，和是专门为String类重载过的运算符，也是Java中仅有的两个重载过的元素符。Stringstr1he；Stringstr2llo；Stringstr3world；Stringstr4str1str2str3；
　　上面的代码对应的字节码如下：
　　可以看出，字符串对象通过的字符串拼接方式，实际上是通过StringBuilder调用append（）方法实现的，拼接完成之后调用toString（）得到一个String对象。
　　不过，在循环内使用进行字符串的拼接的话，存在比较明显的缺陷：编译器不会创建单个StringBuilder以复用，会导致创建过多的StringBuilder对象。String〔〕arr｛he，llo，world｝；Strings；for（inti0；iarr。length；i）｛sarr〔i〕；｝System。out。println（s）；
　　StringBuilder对象是在循环内部被创建的，这意味着每循环一次就会创建一个StringBuilder对象。
　　如果直接使用StringBuilder对象进行字符串拼接的话，就不会存在这个问题了。String〔〕arr｛he，llo，world｝；StringBuildersnewStringBuilder（）；for（Stringvalue：arr）｛s。append（value）；｝System。out。println（s）；
　　如果你使用IDEA的话，IDEA自带的代码检查机制也会提示你修改代码。Stringequals（）和Objectequals（）有何区别？
　　String中的equals方法是被重写过的，比较的是String字符串的值是否相等。Object的equals方法是比较的对象的内存地址。字符串常量池的作用了解吗？
　　字符串常量池是JVM为了提升性能和减少内存消耗针对字符串（String类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。在堆中创建字符串对象ab将字符串对象ab的引用保存在字符串常量池中Stringaaab；直接返回字符串常量池中字符串对象ab的引用Stringbbab；System。out。println（aabb）；true
　　更多关于字符串常量池的介绍可以看一下Java内存区域详解openinnewwindow这篇文章。Strings1newString（abc）；这句话创建了几个字符串对象？
　　会创建1或2个字符串对象。
　　1、如果字符串常量池中不存在字符串对象abc的引用，那么会在堆中创建2个字符串对象abc。
　　示例代码（JDK1。8）：Strings1newString（abc）；
　　对应的字节码：
　　ldc命令用于判断字符串常量池中是否保存了对应的字符串对象的引用，如果保存了的话直接返回，如果没有保存的话，会在堆中创建对应的字符串对象并将该字符串对象的引用保存到字符串常量池中。
　　2、如果字符串常量池中已存在字符串对象abc的引用，则只会在堆中创建1个字符串对象abc。
　　示例代码（JDK1。8）：字符串常量池中已存在字符串对象abc的引用Strings1abc；下面这段代码只会在堆中创建1个字符串对象abcStrings2newString（abc）；
　　对应的字节码：
　　这里就不对上面的字节码进行详细注释了，7这个位置的ldc命令不会在堆中创建新的字符串对象abc，这是因为0这个位置已经执行了一次ldc命令，已经在堆中创建过一次字符串对象abc了。7这个位置执行ldc命令会直接返回字符串常量池中字符串对象abc对应的引用。intern方法有什么作用？
　　String。intern（）是一个native（本地）方法，其作用是将指定的字符串对象的引用保存在字符串常量池中，可以简单分为两种情况：如果字符串常量池中保存了对应的字符串对象的引用，就直接返回该引用。如果字符串常量池中没有保存了对应的字符串对象的引用，那就在常量池中创建一个指向该字符串对象的引用并返回。
　　示例代码（JDK1。8）：在堆中创建字符串对象Java将字符串对象Java的引用保存在字符串常量池中Strings1Java；直接返回字符串常量池中字符串对象Java对应的引用Strings2s1。intern（）；会在堆中在单独创建一个字符串对象Strings3newString（Java）；直接返回字符串常量池中字符串对象Java对应的引用Strings4s3。intern（）；s1和s2指向的是堆中的同一个对象System。out。println（s1s2）；trues3和s4指向的是堆中不同的对象System。out。println（s3s4）；falses1和s4指向的是堆中的同一个对象System。out。println（s1s4）；trueString类型的变量和常量做运算时发生了什么？
　　先来看字符串不加final关键字拼接的情况（JDK1。8）：Stringstr1str；Stringstr2ing；Stringstr3string；Stringstr4str1str2；Stringstr5string；System。out。println（str3str4）；falseSystem。out。println（str3str5）；trueSystem。out。println（str4str5）；false
　　注意：比较String字符串的值是否相等，可以使用equals（）方法。String中的equals方法是被重写过的。Object的equals方法是比较的对象的内存地址，而String的equals方法比较的是字符串的值是否相等。如果你使用比较两个字符串是否相等的话，IDEA还是提示你使用equals（）方法替换。
　　对于编译期可以确定值的字符串，也就是常量字符串，jvm会将其存入字符串常量池。并且，字符串常量拼接得到的字符串常量在编译阶段就已经被存放字符串常量池，这个得益于编译器的优化。
　　在编译过程中，Javac编译器（下文中统称为编译器）会进行一个叫做常量折叠（ConstantFolding）的代码优化。《深入理解Java虚拟机》中是也有介绍到：
　　常量折叠会把常量表达式的值求出来作为常量嵌在最终生成的代码中，这是Javac编译器会对源代码做的极少量优化措施之一（代码优化几乎都在即时编译器中进行）。
　　对于Stringstr3string；编译器会给你优化成Stringstr3string；。
　　并不是所有的常量都会进行折叠，只有编译器在程序编译期就可以确定值的常量才可以：基本数据类型（byte、boolean、short、char、int、float、long、double）以及字符串常量。final修饰的基本数据类型和字符串变量字符串通过拼接得到的字符串、基本数据类型之间算数运算（加减乘除）、基本数据类型的位运算（、、）
　　引用的值在程序编译期是无法确定的，编译器无法对其进行优化。
　　对象引用和的字符串拼接方式，实际上是通过StringBuilder调用append（）方法实现的，拼接完成之后调用toString（）得到一个String对象。Stringstr4newStringBuilder（）。append（str1）。append（str2）。toString（）；
　　我们在平时写代码的时候，尽量避免多个字符串对象拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用StringBuilder或者StringBuffer。
　　不过，字符串使用final关键字声明之后，可以让编译器当做常量来处理。
　　示例代码：finalStringstr1str；finalStringstr2ing；下面两个表达式其实是等价的Stringcstring；常量池中的对象Stringdstr1str2；常量池中的对象System。out。println（cd）；true
　　被final关键字修改之后的String会被编译器当做常量来处理，编译器在程序编译期就可以确定它的值，其效果就相当于访问常量。
　　如果，编译器在运行时才能知道其确切值的话，就无法对其优化。
　　示例代码（str2在运行时才能确定其值）：finalStringstr1str；finalStringstr2getStr（）；Stringcstring；常量池中的对象Stringdstr1str2；在堆上创建的新的对象System。out。println（cd）；falsepublicstaticStringgetStr（）｛returning；｝