面试题Java基础面试题连环55问（2022版）

　　1。Java语言有哪些特点？
　　面向对象（封装，继承，多态）；
　　平台无关性，平台无关性的具体表现在于，Java是一次编写，到处运行（WriteOnce，RunanyWhere）的语言，因此采用Java语言编写的程序具有很好的可移植性，而保证这一点的正是Java的虚拟机机制。在引入虚拟机之后，Java语言在不同的平台上运行不需要重新编译。
　　可靠性、安全性；
　　支持多线程。C语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而Java语言却提供了多线程支持；
　　支持网络编程并且很方便。Java语言诞生本身就是为简化网络编程设计的，因此Java语言不仅支持网络编程而且很方便；
　　编译与解释并存；
　　2。Java和C有什么关系，它们有什么区别？
　　都是面向对象的语言，都支持封装、继承和多态；
　　C支持指针，而Java没有指针的概念；
　　C支持多继承，而Java不支持多重继承，但允许一个类实现多个接口；
　　Java自动进行无用内存回收操作，不再需要程序员进行手动删除，而C中必须由程序释放内存资源，这就增加了程序员的负担。
　　Java不支持操作符重载，操作符重载则被认为是C的突出特征；
　　Java是完全面向对象的语言，并且还取消了CC中的结构和联合，使编译程序更加简洁；
　　C和C不支持字符串变量，在C和C程序中使用Null终止符代表字符串的结束。在Java中字符串是用类对象（String和StringBuffer）来实现的；
　　goto语句是C和C的遗物，Java不提供goto语句，虽然Java指定goto作为关键字，但不支持它的使用，这使程序更简洁易读；
　　3。JVM、JRE和JDK的关系是什么？
　　JDK是（JavaDevelopmentKit）的缩写，它是功能齐全的JavaSDK。它拥有JRE所拥有的一切，还有编译器（javac）和工具（如javadoc和jdb）。它能够创建和编译程序。
　　JRE是JavaRuntimeEnvironment缩写，它是运行已编译Java程序所需的所有内容的集合，包括Java虚拟机（JVM），Java类库，java命令和其他的一些基础构件。但是，它不能用于创建新程序。
　　JDK包含JRE，JRE包含JVM。
　　4。什么是字节码？采用字节码的好处是什么？
　　这个问题，面试官可以扩展提问，Java是编译执行的语言，还是解释执行的语言？
　　Java之所以可以一次编译，到处运行，一是因为JVM针对各种操作系统、平台都进行了定制，二是因为无论在什么平台，都可以编译生成固定格式的字节码（。class文件）供JVM使用。因此，也可以看出字节码对于Java生态的重要性。
　　之所以被称之为字节码，是因为字节码文件由十六进制值组成，而JVM以两个十六进制值为一组，即以字节为单位进行读取。在Java中一般是用javac命令编译源代码为字节码文件，一个。java文件从编译到运行的示例如图所示。
　　Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。
　　5。OracleJDK和OpenJDK的区别是什么？
　　可能在看这个问题之前很多人和我一样并没有接触和使用过OpenJDK。下面通过我通过我收集到一些资料对你解答这个被很多人忽视的问题。
　　OracleJDK版本将每三年发布一次，而OpenJDK版本每三个月发布一次；
　　OpenJDK是一个参考模型并且是完全开源的，而OracleJDK是OpenJDK的一个实现，并不是完全开源的；
　　OracleJDK比OpenJDK更稳定。OpenJDK和OracleJDK的代码几乎相同，但OracleJDK有更多的类和一些错误修复。因此，如果您想开发企业商业软件，建议选择OracleJDK，因为它经过了彻底的测试和稳定。某些情况下，有些人提到在使用OpenJDK可能会遇到了许多应用程序崩溃的问题，但是，只需切换到OracleJDK就可以解决问题；
　　在响应性和JVM性能方面，OracleJDK与OpenJDK相比提供了更好的性能；
　　OracleJDK不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
　　OracleJDK根据二进制代码许可协议获得许可，而OpenJDK根据GPLv2许可获得许可。
　　6。Java有哪些数据类型？
　　Java语言的数据类型分为两种：基本数据类型和引用数据类型。
　　基本数据类型包括boolean（布尔型）、float（单精度浮点型）、char（字符型）、byte（字节型）、short（短整型）、int（整型）、long（长整型）和double（双精度浮点型）共8种，如下图所示。
　　引用数据类型建立在基本数据类型的基础上，包括数组、类和接口。引用数据类型是由用户自定义，用来限制其他数据的类型。另外，Java语言中不支持C中的指针类型、结构类型、联合类型和枚举类型。
　　7。switch是否能作用在byte上，是否能作用在long上，是否能作用在String上？
　　Java5以前switch（expr）中，expr只能是byte、short、char、int。
　　从Java5开始，Java中引入了枚举类型，expr也可以是enum类型。
　　从Java7开始，expr还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。
　　8。访问修饰符public、private、protected、以及不写（默认）时的区别？
　　Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
　　default（即默认，什么也不写）：在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
　　private：在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
　　public：对所有类可见。使用对象：类、接口、变量、方法
　　protected：对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。
　　9。break，continue，return的区别及作用？
　　break跳出总上一层循环，不再执行循环（结束当前的循环体）
　　continue跳出本次循环，继续执行下次循环（结束正在执行的循环进入下一个循环条件）
　　return程序返回，不再执行下面的代码（结束当前的方法直接返回）
　　10。final、finally、finalize的区别？
　　final用于修饰变量、方法和类。
　　final变量：被修饰的变量不可变，不可变分为引用不可变和对象不可变，final指的是引用不可变，final修饰的变量必须初始化，通常称被修饰的变量为常量。
　　final方法：被修饰的方法不允许任何子类重写，子类可以使用该方法。
　　final类：被修饰的类不能被继承，所有方法不能被重写。
　　finally作为异常处理的一部分，它只能在trycatch语句中，并且附带一个语句块表示这段语句最终一定被执行（无论是否抛出异常），经常被用在需要释放资源的情况下，System。exit（0）可以阻断finally执行。
　　finalize是在java。lang。Object里定义的方法，也就是说每一个对象都有这么个方法，这个方法在gc启动，该对象被回收的时候被调用。
　　一个对象的finalize方法只会被调用一次，finalize被调用不一定会立即回收该对象，所以有可能调用finalize后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会再次调用finalize了，进而产生问题，因此不推荐使用finalize方法。
　　11。为什么要用static关键字？
　　通常来说，用new创建类的对象时，数据存储空间才被分配，方法才供外界调用。但有时我们只想为特定域分配单一存储空间，不考虑要创建多少对象或者说根本就不创建任何对象，再就是我们想在没有创建对象的情况下也想调用方法。在这两种情况下，static关键字，满足了我们的需求。
　　12。static关键字是什么意思？Java中是否可以覆盖（override）一个private或者是static的方法？
　　static关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。
　　Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。
　　13。是否可以在static环境中访问非static变量？
　　static变量在Java中是属于类的，它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。
　　14。static静态方法能不能引用非静态资源？
　　不能，new的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。
　　15。static静态方法里面能不能引用静态资源？
　　可以，因为都是类初始化的时候加载的，大家相互都认识。
　　16。非静态方法里面能不能引用静态资源？
　　可以，非静态方法就是实例方法，那是new之后才产生的，那么属于类的内容它都认识。
　　17。java静态变量、代码块、和静态方法的执行顺序是什么？
　　基本上代码块分为三种：Static静态代码块、构造代码块、普通代码块
　　代码块执行顺序静态代码块构造代码块构造函数普通代码块
　　继承中代码块执行顺序：父类静态块子类静态块父类代码块父类构造器子类代码块子类构造器
　　18。面向对象和面向过程的区别？
　　面向过程：
　　优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源；比如单片机、嵌入式开发、LinuxUnix等一般采用面向过程开发，性能是最重要的因素。
　　缺点：没有面向对象易维护、易复用、易扩展。
　　面向对象：
　　优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
　　缺点：性能比面向过程低。
　　19。讲讲面向对象三大特性
　　封装。封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
　　继承。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
　　多态性。它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。
　　20。Java语言是如何实现多态的？
　　本质上多态分两种：
　　1、编译时多态（又称静态多态）
　　2、运行时多态（又称动态多态）
　　重载（overload）就是编译时多态的一个例子，编译时多态在编译时就已经确定，运行的时候调用的是确定的方法。
　　我们通常所说的多态指的都是运行时多态，也就是编译时不确定究竟调用哪个具体方法，一直延迟到运行时才能确定。这也是为什么有时候多态方法又被称为延迟方法的原因。
　　Java实现多态有3个必要条件：继承、重写和向上转型。只有满足这3个条件，开发人员才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而执行不同的行为。
　　继承：在多态中必须存在有继承关系的子类和父类。
　　重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
　　向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。
　　21。重载（Overload）和重写（Override）的区别是什么？
　　方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。
　　重写发生在子类与父类之间，重写方法返回值和形参都不能改变，与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分。即外壳不变，核心重写！
　　重载（overloading）是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。
　　无效的图片地址
　　22。重载的方法能否根据返回值类型进行区分？
　　不能根据返回值类型来区分重载的方法。因为调用时不指定类型信息，编译器不知道你要调用哪个函数。
　　floatmax（inta，intb）；
　　intmax（inta，intb）；
　　当调用max（1，2）；时无法确定调用的是哪个，单从这一点上来说，仅返回值类型不同的重载是不应该允许的。
　　23。构造器（constructor）是否可被重写（override）？
　　构造器不能被继承，因此不能被重写，但可以被重载。每一个类必须有自己的构造函数，负责构造自己这部分的构造。子类不会覆盖父类的构造函数，相反必须一开始调用父类的构造函数。
　　24。抽象类和接口的区别是什么？
　　语法层面上的区别：
　　抽象类可以提供成员方法的实现细节，而接口中只能存在publicabstract方法；
　　抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是publicstaticfinal类型的；
　　接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
　　一个类只能继承一个抽象类，而一个类却可以实现多个接口。
　　设计层面上的区别：
　　抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
　　设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。
　　25。抽象类能使用final修饰吗？
　　不能，定义抽象类就是让其他类继承的，如果定义为final该类就不能被继承，这样彼此就会产生矛盾，所以final不能修饰抽象类
　　26。java创建对象有哪几种方式？
　　java中提供了以下四种创建对象的方式：
　　new创建新对象
　　通过反射机制
　　采用clone机制
　　通过序列化机制
　　前两者都需要显式地调用构造方法。对于clone机制，需要注意浅拷贝和深拷贝的区别，对于序列化机制需要明确其实现原理，在java中序列化可以通过实现Externalizable或者Serializable来实现。
　　27。什么是不可变对象？好处是什么？
　　不可变对象指对象一旦被创建，状态就不能再改变，任何修改都会创建一个新的对象，如String、Integer及其它包装类。不可变对象最大的好处是线程安全。
　　28。能否创建一个包含可变对象的不可变对象？
　　当然可以，比如finalPerson〔〕personsnewPersion〔〕｛｝。persons是不可变对象的引用，但其数组中的Person实例却是可变的。这种情况下需要特别谨慎，不要共享可变对象的引用。这种情况下，如果数据需要变化时，就返回原对象的一个拷贝。
　　29。值传递和引用传递的区别的什么？为什么说Java中只有值传递？
　　值传递：指的是在方法调用时，传递的参数是按值的拷贝传递，传递的是值的拷贝，也就是说传递后就互不相关了。
　　引用传递：指的是在方法调用时，传递的参数是按引用进行传递，其实传递的是引用的地址，也就是变量所对应的内存空间的地址。传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。
　　基本类型作为参数被传递时肯定是值传递；引用类型作为参数被传递时也是值传递，只不过值为对应的引用。
　　30。和equals区别是什么？
　　常用于相同的基本数据类型之间的比较，也可用于相同类型的对象之间的比较；
　　如果比较的是基本数据类型，那么比较的是两个基本数据类型的值是否相等；
　　如果是比较的两个对象，那么比较的是两个对象的引用，也就是判断两个对象是否指向了同一块内存区域；
　　equals方法主要用于两个对象之间，检测一个对象是否等于另一个对象
　　看一看Object类中equals方法的源码：publicbooleanequals（Objectobj）｛return（thisobj）；｝
　　它的作用也是判断两个对象是否相等，般有两种使用情况：
　　情况1，类没有覆盖equals（）方法。则通过equals（）比较该类的两个对象时，等价于通过比较这两个对象。
　　情况2，类覆盖了equals（）方法。一般，我们都覆盖equals（）方法来两个对象的内容相等；若它们的内容相等，则返回true（即，认为这两个对象相等）。
　　java语言规范要求equals方法具有以下特性：
　　自反性。对于任意不为null的引用值x，x。equals（x）一定是true。
　　对称性）。对于任意不为null的引用值x和y，当且仅当x。equals（y）是true时，y。equals（x）也是true。
　　传递性。对于任意不为null的引用值x、y和z，如果x。equals（y）是true，同时y。equals（z）是true，那么x。equals（z）一定是true。
　　一致性。对于任意不为null的引用值x和y，如果用于equals比较的对象信息没有被修改的话，多次调用时x。equals（y）要么一致地返回true要么一致地返回false。
　　对于任意不为null的引用值x，x。equals（null）返回false。
　　31。介绍下hashCode（）？
　　hashCode（）的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode（）定义在JDK的Object。java中，这就意味着Java中的任何类都包含有hashCode（）函数。
　　散列表存储的是键值对（keyvalue），它的特点是：能根据键快速的检索出对应的值。这其中就利用到了散列码！（可以快速找到所需要的对象）
　　32。为什么要有hashCode？
　　以HashSet如何检查重复为例子来说明为什么要有hashCode：
　　当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他已经加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。
　　但是如果发现有相同hashcode值的对象，这时会调用equals（）方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了equals的次数，相应就大大提高了执行速度。
　　33。hashCode（），equals（）两种方法是什么关系？
　　Java对于eqauls（）方法和hashCode（）方法是这样规定的：
　　同一对象上多次调用hashCode（）方法，总是返回相同的整型值。
　　如果a。equals（b），则一定有a。hashCode（）一定等于b。hashCode（）。
　　如果！a。equals（b），则a。hashCode（）不一定等于b。hashCode（）。此时如果a。hashCode（）总是不等于b。hashCode（），会提高hashtables的性能。
　　a。hashCode（）b。hashCode（）则a。equals（b）可真可假
　　a。hashCode（）！b。hashCode（）则a。equals（b）为假。
　　上面结论简记：
　　如果两个对象equals，Java运行时环境会认为他们的hashCode一定相等。
　　如果两个对象不equals，他们的hashCode有可能相等。
　　如果两个对象hashCode相等，他们不一定equals。
　　如果两个对象hashCode不相等，他们一定不equals
　　补充：关于equals（）和hashCode（）的重要规范
　　规范1：若重写equals（）方法，有必要重写hashcode（）方法，确保通过equals（）方法判断结果为true的两个对象具备相等的hashcode（）方法返回值。说得简单点就是：如果两个对象相同，那么他们的hashCode应该相等。不过请注意：这个只是规范，如果非要写一个类让equals（）方法返回true而hashCode（）方法返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。
　　规范2：如果equals（）方法返回false，即两个对象不相同，并不要求对这两个对象调用hashCode（）方法得到两个不相同的数。说的简单点就是：如果两个对象不相同，他们的hashCode可能相同。
　　34。为什么重写equals方法必须重写hashcode方法？
　　断的时候先根据hashcode进行的判断，相同的情况下再根据equals（）方法进行判断。如果只重写了equals方法，而不重写hashcode的方法，会造成hashcode的值不同，而equals（）方法判断出来的结果为true。
　　在Java中的一些容器中，不允许有两个完全相同的对象，插入的时候，如果判断相同则会进行覆盖。这时候如果只重写了equals（）的方法，而不重写hashcode的方法，Object中hashcode是根据对象的存储地址转换而形成的一个哈希值。这时候就有可能因为没有重写hashcode方法，造成相同的对象散列到不同的位置而造成对象的不能覆盖的问题。
　　35。String，StringBuffer，StringBuilder的区别是什么？
　　1。可变与不可变。String类中使用字符数组保存字符串，因为有final修饰符，所以string对象是不可变的。对于已经存在的String对象的修改都是重新创建一个新的对象，然后把新的值保存进去。privatefinalcharvalue〔〕；
　　StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，这两种对象都是可变的。char〔〕value；
　　2。是否线程安全。
　　String中的对象是不可变的，也就可以理解为常量，显然线程安全。
　　StringBuilder是非线程安全的。
　　StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。OverridepublicsynchronizedStringBufferappend（Stringstr）｛toStringCachenull；super。append（str）；returnthis；｝
　　3。如果你只是在单线程中使用字符串缓冲区，那么StringBuilder的效率会更高些。值得注意的是StringBuilder是在JDK1。5版本中增加的。以前版本的JDK不能使用该类。
　　36。String为什么要设计成不可变的？
　　1。便于实现字符串池（Stringpool）
　　在Java中，由于会大量的使用String常量，如果每一次声明一个String都创建一个String对象，那将会造成极大的空间资源的浪费。Java提出了Stringpool的概念，在堆中开辟一块存储空间Stringpool，当初始化一个String变量时，如果该字符串已经存在了，就不会去创建一个新的字符串变量，而是会返回已经存在了的字符串的引用。StringaHelloworld！；StringbHelloworld！；
　　如果字符串是可变的，某一个字符串变量改变了其值，那么其指向的变量的值也会改变，Stringpool将不能够实现！
　　2。使多线程安全
　　在并发场景下，多个线程同时读一个资源，是安全的，不会引发竞争，但对资源进行写操作时是不安全的，不可变对象不能被写，所以保证了多线程的安全。
　　3。避免安全问题
　　在网络连接和数据库连接中字符串常常作为参数，例如，网络连接地址URL，文件路径path，反射机制所需要的String参数。其不可变性可以保证连接的安全性。如果字符串是可变的，黑客就有可能改变字符串指向对象的值，那么会引起很严重的安全问题。
　　4。加快字符串处理速度
　　由于String是不可变的，保证了hashcode的唯一性，于是在创建对象时其hashcode就可以放心的缓存了，不需要重新计算。这也就是Map喜欢将String作为Key的原因，处理速度要快过其它的键对象。所以HashMap中的键往往都使用String。
　　总体来说，String不可变的原因要包括设计考虑，效率优化，以及安全性这三大方面。
　　37。字符型常量和字符串常量的区别？
　　形式上：字符常量是单引号引起的一个字符，字符串常量是双引号引起的若干个字符；
　　含义上：字符常量相当于一个整型值（ASCII值），可以参加表达式运算；字符串常量代表一个地址值（该字符串在内存中存放位置，相当于对象；
　　占内存大小：字符常量只占2个字节；字符串常量占若干个字节（至少一个字符结束标志）（注意：char在Java中占两个字节）。
　　38。什么是字符串常量池？
　　java中常量池的概念主要有三个：全局字符串常量池，class文件常量池，运行时常量池。我们现在所说的就是全局字符串常量池，对这个想弄明白的同学可以看这篇Java中几种常量池的区分。
　　jvm为了提升性能和减少内存开销，避免字符的重复创建，其维护了一块特殊的内存空间，即字符串池，当需要使用字符串时，先去字符串池中查看该字符串是否已经存在，如果存在，则可以直接使用，如果不存在，初始化，并将该字符串放入字符串常量池中。
　　字符串常量池的位置也是随着jdk版本的不同而位置不同。在jdk6中，常量池的位置在永久代（方法区）中，此时常量池中存储的是对象。在jdk7中，常量池的位置在堆中，此时，常量池存储的就是引用了。在jdk8中，永久代（方法区）被元空间取代了。
　　39。Stringstraaa与StringstrnewString（aaa）一样吗？newString（aaa）；创建了几个字符串对象？
　　使用Stringaaaa；，程序运行时会在常量池中查找aaa字符串，若没有，会将aaa字符串放进常量池，再将其地址赋给a；若有，将找到的aaa字符串的地址赋给a。
　　使用StringbnewString（aaa）；，程序会在堆内存中开辟一片新空间存放新对象，同时会将aaa字符串放入常量池，相当于创建了两个对象，无论常量池中有没有aaa字符串，程序都会在堆内存中开辟一片新空间存放新对象。
　　具体分析，见以下代码：Testpublicvoidtest（）｛StringsnewString（2）；s。intern（）；Strings22；System。out。println（ss2）；Strings3newString（3）newString（3）；s3。intern（）；Strings433；System。out。println（s3s4）；｝
　　运行结果：jdk6falsefalsejdk7falsetrue
　　这段代码在jdk6中输出是falsefalse，但是在jdk7中输出的是falsetrue。我们通过图来一行行解释。
　　先来认识下intern（）函数：
　　intern函数的作用是将对应的符号常量进入特殊处理，在JDK1。6以前和JDK1。7以后有不同的处理；
　　在JDK1。6中，intern的处理是先判断字符串常量是否在字符串常量池中，如果存在直接返回该常量，如果没有找到，则将该字符串常量加入到字符串常量区，也就是在字符串常量区建立该常量；
　　在JDK1。7中，intern的处理是先判断字符串常量是否在字符串常量池中，如果存在直接返回该常量，如果没有找到，说明该字符串常量在堆中，则处理是把堆区该对象的引用加入到字符串常量池中，以后别人拿到的是该字符串常量的引用，实际存在堆中
　　JDK1。6
　　StringsnewString（2）；创建了两个对象，一个在堆中的StringObject对象，一个是在常量池中的2对象。
　　s。intern（）；在常量池中寻找与s变量内容相同的对象，发现已经存在内容相同对象2，返回对象2的地址。
　　Strings22；使用字面量创建，在常量池寻找是否有相同内容的对象，发现有，返回对象2的地址。
　　System。out。println（ss2）；从上面可以分析出，s变量和s2变量地址指向的是不同的对象，所以返回false
　　Strings3newString（3）newString（3）；创建了两个对象，一个在堆中的StringObject对象，一个是在常量池中的3对象。中间还有2个匿名的newString（3）我们不去讨论它们。
　　s3。intern（）；在常量池中寻找与s3变量内容相同的对象，没有发现33对象，在常量池中创建33对象，返回33对象的地址。
　　Strings433；使用字面量创建，在常量池寻找是否有相同内容的对象，发现有，返回对象33的地址。
　　System。out。println（s3s4）；从上面可以分析出，s3变量和s4变量地址指向的是不同的对象，所以返回false
　　JDK1。7
　　StringsnewString（2）；创建了两个对象，一个在堆中的StringObject对象，一个是在堆中的2对象，并在常量池中保存2对象的引用地址。
　　s。intern（）；在常量池中寻找与s变量内容相同的对象，发现已经存在内容相同对象2，返回对象2的引用地址。
　　Strings22；使用字面量创建，在常量池寻找是否有相同内容的对象，发现有，返回对象2的引用地址。
　　System。out。println（ss2）；从上面可以分析出，s变量和s2变量地址指向的是不同的对象，所以返回false
　　Strings3newString（3）newString（3）；创建了两个对象，一个在堆中的StringObject对象，一个是在堆中的3对象，并在常量池中保存3对象的引用地址。中间还有2个匿名的newString（3）我们不去讨论它们。
　　s3。intern（）；在常量池中寻找与s3变量内容相同的对象，没有发现33对象，将s3对应的StringObject对象的地址保存到常量池中，返回StringObject对象的地址。
　　Strings433；使用字面量创建，在常量池寻找是否有相同内容的对象，发现有，返回其地址，也就是StringObject对象的引用地址。
　　System。out。println（s3s4）；从上面可以分析出，s3变量和s4变量地址指向的是相同的对象，所以返回true。
　　40。String是最基本的数据类型吗？
　　不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitivetype），剩下的都是引用类型（referencetype），Java5以后引入的枚举类型也算是一种比较特殊的引用类型。
　　41。String有哪些特性？
　　不变性：String是只读字符串，是一个典型的immutable对象，对它进行任何操作，其实都是创建一个新的对象，再把引用指向该对象。不变模式的主要作用在于当一个对象需要被多线程共享并频繁访问时，可以保证数据的一致性；
　　常量池优化：String对象创建之后，会在字符串常量池中进行缓存，如果下次创建同样的对象时，会直接返回缓存的引用；
　　final：使用final来定义String类，表示String类不能被继承，提高了系统的安全性。
　　42。在使用HashMap的时候，用String做key有什么好处？
　　HashMap内部实现是通过key的hashcode来确定value的存储位置，因为字符串是不可变的，所以当创建字符串时，它的hashcode被缓存下来，不需要再次计算，所以相比于其他对象更快。
　　43。包装类型是什么？基本类型和包装类型有什么区别？
　　Java为每一个基本数据类型都引入了对应的包装类型（wrapperclass），int的包装类就是Integer，从Java5开始引入了自动装箱拆箱机制，把基本类型转换成包装类型的过程叫做装箱（boxing）；反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing），使得二者可以相互转换。
　　Java为每个原始类型提供了包装类型：
　　原始类型：boolean，char，byte，short，int，long，float，double
　　包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
　　基本类型和包装类型的区别主要有以下几点：
　　包装类型可以为null，而基本类型不可以。它使得包装类型可以应用于POJO中，而基本类型则不行。那为什么POJO的属性必须要用包装类型呢？《阿里巴巴Java开发手册》上有详细的说明，数据库的查询结果可能是null，如果使用基本类型的话，因为要自动拆箱（将包装类型转为基本类型，比如说把Integer对象转换成int值），就会抛出NullPointerException的异常。
　　包装类型可用于泛型，而基本类型不可以。泛型不能使用基本类型，因为使用基本类型时会编译出错。ListintlistnewArrayList（）；提示Syntaxerror，insertDimensionstocompleteReferenceTypeListIntegerlistnewArrayList（）；
　　因为泛型在编译时会进行类型擦除，最后只保留原始类型，而原始类型只能是Object类及其子类基本类型是个特例。
　　基本类型比包装类型更高效。基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用。很显然，相比较于基本类型而言，包装类型需要占用更多的内存空间。
　　44。解释一下自动装箱和自动拆箱？
　　自动装箱：将基本数据类型重新转化为对象publicclassTest｛publicstaticvoidmain（String〔〕args）｛声明一个Integer对象，用到了自动的装箱：解析为：IntegernumInteger。valueOf（9）；Integernum9；｝｝
　　9是属于基本数据类型的，原则上它是不能直接赋值给一个对象Integer的。但jdk1。5开始引入了自动装箱拆箱机制，就可以进行这样的声明，自动将基本数据类型转化为对应的封装类型，成为一个对象以后就可以调用对象所声明的所有的方法。
　　自动拆箱：将对象重新转化为基本数据类型
　　publicclassTest｛publicclassTest｛publicstaticvoidmain（String〔〕args）｛声明一个Integer对象Integernum9；进行计算时隐含的有自动拆箱System。out。print（num）；｝｝
　　因为对象时不能直接进行运算的，而是要转化为基本数据类型后才能进行加减乘除。
　　45。int和Integer有什么区别？
　　Integer是int的包装类；int是基本数据类型；
　　Integer变量必须实例化后才能使用；int变量不需要；
　　Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值；
　　Integer的默认值是null；int的默认值是0。
　　46。两个new生成的Integer变量的对比
　　由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。IntegerinewInteger（10000）；IntegerjnewInteger（10000）；System。out。print（ij）；false
　　47。Integer变量和int变量的对比
　　Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）inta10000；IntegerbnewInteger（10000）；Integerc10000；System。out。println（ab）；trueSystem。out。println（ac）；true
　　48。非new生成的Integer变量和newInteger（）生成变量的对比
　　非new生成的Integer变量和newInteger（）生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而newInteger（）生成的变量指向堆中新建的对象，两者在内存中的地址不同）IntegerbnewInteger（10000）；Integerc10000；System。out。println（bc）；false
　　49。两个非new生成的Integer对象的对比
　　对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为falseIntegeri100；Integerj100；System。out。print（ij）；trueIntegeri128；Integerj128；System。out。print（ij）；false
　　当值在128127之间时，java会进行自动装箱，然后会对值进行缓存，如果下次再有相同的值，会直接在缓存中取出使用。缓存是通过Integer的内部类IntegerCache来完成的。当值超出此范围，会在堆中new出一个对象来存储。
　　给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，源码如下：publicstaticIntegervalueOf（Strings，intradix）throwsNumberFormatException｛returnInteger。valueOf（parseInt（s，radix））；｝（1）在128127之内：静态常量池中cache数组是staticfinal类型，cache数组对象会被存储于静态常量池中。cache数组里面的元素却不是staticfinal类型，而是cache〔k〕newInteger（j），那么这些元素是存储于堆中，只是cache数组对象存储的是指向了堆中的Integer对象（引用地址）（2）在128127之外：新建一个Integer对象，并返回。publicstaticIntegervalueOf（inti）｛assertIntegerCache。high127；if（iIntegerCache。lowiIntegerCache。high）｛returnIntegerCache。cache〔i（IntegerCache。low）〕；｝returnnewInteger（i）；｝
　　IntegerCache是Integer的内部类，源码如下：缓存支持自动装箱的对象标识语义128和127（含）。缓存在第一次使用时初始化。缓存的大小可以由XX：AutoBoxCacheMaxsize选项控制。在VM初始化期间，java。lang。Integer。IntegerCache。high属性可以设置并保存在私有系统属性中privatestaticclassIntegerCache｛staticfinalintlow128；staticfinalinthigh；staticfinalIntegercache〔〕；static｛highvaluemaybeconfiguredbypropertyinth127；StringintegerCacheHighPropValuesun。misc。VM。getSavedProperty（java。lang。Integer。IntegerCache。high）；if（integerCacheHighPropValue！null）｛intiparseInt（integerCacheHighPropValue）；iMath。max（i，127）；MaximumarraysizeisInteger。MAXVALUEhMath。min（i，Integer。MAXVALUE（low）1）；｝highh；cachenewInteger〔（highlow）1〕；intjlow；for（intk0；kcache。length；k）｛cache〔k〕newInteger（j）；创建一个对象｝｝privateIntegerCache（）｛｝｝
　　50。什么是反射？
　　反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
　　51。反射机制的优缺点有哪些？
　　优点：能够运行时动态获取类的实例，提高灵活性；可与动态编译结合Class。forName（com。mysql。jdbc。Driver。class）；，加载MySQL的驱动类。
　　缺点：使用反射性能较低，需要解析字节码，将内存中的对象进行解析。其解决方案是：通过setAccessible（true）关闭JDK的安全检查来提升反射速度；多次创建一个类的实例时，有缓存会快很多；ReflflectASM工具类，通过字节码生成的方式加快反射速度。
　　需要学习更多Java面试资料关注博主，私聊博主免费获取