【Java工程师玩家手册】2021应届生JAVA工程师精选基础面试题

开始面试：

1、什么是Java?

答：Java是面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承和指针的概念。Java具有两个特点：①功能强大和②简单易用。

2、Java三大版本是什么？

答：Java SE:标准版。它允许开发和部署在桌面、服务器、嵌入式环境、和实时环境中使用的Java应用程序。其中包含了支持Web服务开发的类，并为Java EE和Java ME提供了基础。

       Java EE:企业版。它帮助开发和部署企业级的服务器端Java应用程序。其可以用来实现企业级的面向服务体系结构和Web2.0应用程序。

       Java ME:微型版。它为在移动设备和嵌入式设备上运行的应用程序提供环境。基于Java ME规范的应用程序只需编写一次，就可以用于许多设备。

3、JVM、JRE、JDK的关系？

答：JVM是Java虚拟机，Java程序需要运行在虚拟机上，不同的平台下载对应的虚拟机。所以Java语言具有跨平台性。

       JRE包括Java虚拟机和java程序所需要的核心类库。其构成了Java程序的运行环境。核心类库主要是java.long包。

       JDK是Java开发工具，其中包括了JRE。所以如果安装了JDK无需再安装JRE。开发工具包括：编译工具、打包工具等。

4、Java语言有哪些特点？

答：①简单易学②面向对象（封装、继承、多态）③平台无关性④支持网络编程⑤支持多线程⑥健壮性（Java语言的强类型机制、异常处理、垃圾处理机制等）⑦安全性

5、什么是字节码？采用字节码的最大好处是什么？

答：字节码：Java源代码经过虚拟机编译器编译后产生的文件（.class文件），其面向虚拟机。

       字节码的好处：字节码解决了传统解释型语言执行效率低的问题，又保留了解释型语言可移植的特点。

6、Java的编译器和解释器是如何并存的？

答：Java编译程序只需要面向虚拟机，生成虚拟机能理解的代码即可。然后解释器将虚拟机代码转换成特定系统的识别的机器码执行。这种虚拟机能理解的编译后代码叫字节码（.class文件）。Java源程序经过编译器编译后变成字节码，字节码被虚拟机解释执行；虚拟机把字节码传输给解释器；解释器将其翻译成特定系统的机器码，在特定机器执行。

7、什么是Java的主类？应用程序和小程序有哪些不同？

答：一个程序中可以有多个类，但只能有一个类是主类。在Java应用程序中，主类是包含main()方法的类。应用程序中的主类不一定要求是public类，但小程序中必须是public类。主类是Java程序执行的入口。简单说应用程序是从main()方法进入的，而小程序没有main()方法，主要是嵌在浏览器页面上运行。

8、Java和C++的区别？

答：①都是面向对象的语言，都支持封装、继承和多态。

       ②Java不提供指针来直接访问内存，程序更加安全。

       ③Java是单继承多实现，但C++支持多继承。

       ④Java有自动内存管理机制，无需手动释放内存。

9、Java有哪些数据类型？

答：①基础数据类型

      数值型：整数类型—>byte、short、int、long

                     浮点类型—>float、double

      字符型：char

      布尔型：boolean

②引用数据类型

  类(class)

  接口(interface)

  数组([])

10、switch是否可以作用于byte、long、String上？

答：在Java 5以前，switch参数只能是byte、short、int、char。从Java 7开始，可以是字符串String类型。但long不行。

11、用最有效率的方法计算2乘以8？

答：2<<3做位运算。左移一位相当于乘以2，左移三位相当于乘以8。

12、Math.round(11.5)等于多少？Math.round(-11.5)等于多少？

答：Math.round(11.5)等于12，Math.round(-11.5)等于-11。四舍五入的原理是参数上加0.5然后向下取整。

13、float f = 3.4;是否正确？

答：错误，正确写法float f = 3.4f;因为浮点型默认为double型，需要强转 float f = (float)3.4;

14、short s1 = 1; s1 = s1 + 1;正确吗？short s1 = 1; s1+= 1;正确吗？

答：s1+1为一个int类型的数值，因为小范围数值类型的数与大范围数值类型的数进行运算的结果为大范围数值类型的数。而s1为short型，此时需要强转。所以错误。

可以正确编译，因为s1+=1;相当于s1 = (short)(s1+1);其中隐含了强制转换类型。

15、Java语言采用何种编码方案？有何特点？

答：Java采用Unicode编码标准，它为每一个字符制定了唯一的数值。有跨平台性的特点。

16、Java注释

答：①单行注释：//注释

       ②多行注释:/*注释*/

       ③文档注释:/**注释**/

17、访问修饰符public,private,protected以及不写时的区别？

答：①public权限可以访问当前类、同包、子类、其他包。

       ②protected权限可以访问当前类、同包、子类。

       ③default权限可以访问当前类、同包。

       ④private权限可以访问当前类。

Java默认权限（不写权限修饰符）：private

18、&和&&的区别？

答：&与运算有两种：①按位与②逻辑与

 &&短路与运算是逻辑与运算，当运算符左右两端的布尔值都是true，整个表达式的值才问true。但短路与的特别之处为，如果左边的表达式为false，则不再继续执行右边的表达式。或运算亦是如此。

19、final有什么用？finally有什么用？finalize有什么用？

答：final是修饰符的一种。finally是一个关键字。finalize是一个方法。

       当final修饰变量属性，该变量不能被重新赋值或引用。

       当final修饰方法时，该方法不能被重写覆盖，但可以被重载。

       当final修饰类时，该类不能被继承。

       finally用于try-catch语句中，在处理异常时，通常将一定要执行的代码放入finally代码块中。

       finalize方法用于垃圾回收。当我们调用System.gc;方法时，垃圾回收器调用finalize();方法来回收垃圾。

20、this关键字的用法？

答：this是本类的对象，相当于指向此对象本身的一个指针。

       ①当方法的形参与成员变量重名时，可以用this.来进行区分。

       ②用this( )或this(实参)来引用本类的无参构造方法和有参构造方法。

21、super关键字的用法？

答：super关键字可以理解为指向自己最近的一个父类的指针。

①普通的直接引用，用super.来引用父类的成员

②子类中成员变量或方法与父类中的同名时，用super来进行区分。

③用super()或super(实参)来引用父类的无参构造方法和有参构造方法。

22、this和super相同与不同之处？能同时出现吗？为什么？

答：不同之处：

①super在子类中调用父类的成员或构造方法，this在本类内调用本类的成员或构造方法。

②尽管可以用this调用构造器，但只能调用一个。

③this类似一个指向本对象的指针，super是一个关键字。

相同之处：

①super和this均需放在构造方法内的第一行。

注意：this和super不能同时出现在一个构造方法中。

因为：通俗理解this和super都要定义在第一行所以只能有一个。

探讨本质，因为子类继承了父类的属性和方法，所以在子类初始化前要先初始化父类的属性和方法，所以super要放在第一句。而this()用于调用本类的其他构造方法，其他构造方法中必然存在super语句。所以此时就不能重复使用super关键字了。实例化一个对象却运行两次super是不安全的。this放在第一行是因为，当前构造函数可以会用到this调用的成员。

23、static存在的主要意义？

答：①static的主要意义在于创建独立于对象的变量和方法。以致于即使没有创建对象，也能使用属性和调用方法。

       ②static关键字可以形成静态代码块来优化程序：static块可以置于类中的任何地方，但是会被优先顺序执行，且只在类加载的时候执行一次。可以将一些只需要执行一次的操作放在            static代码中来进行。

24、static有什么独特之处吗？

答：①被static修饰的成员独立于对象，属于类且被类的实例所共享。

       ②static修饰的成员只会初始化一次，但可以再次赋值。

       ③static变量值是在类加载的时候分配内存，之后创建对象的时候不会被重新分配内存空间。

       ④被static修饰的变量或者方法是优先于对象存在的。

25、static的应用场景？

答：如果某个成员是被该类所有对象共享的，就应该被静态化。

26、使用static关键字有什么注意事项吗？

答：①静态只能访问静态。

       ②非静态既能访问非静态也可以反问静态。

27、break、continue、return的区别及作用？

答：①break:结束当前的循环

       ②continue:跳出本次循环直接进入下次循环

       ③return:程序返回，不再继续执行之后的代码。

28、如何跳出多重嵌套循环？

答：语句块与break搭配跳出多重嵌套：

 

29、面向对象和面向过程的区别？

答：①面向过程

          优点：性能比面向对象高。

          缺点：不易维护、复用、扩展。

       ②面向对象

          优点：易维护、复用、扩展。

          缺点：性能比面向过程低。

注意：面向过程是具体化的，流程化的；解决一个问题要一步步连续的实现。而面向对象是模型化的，按照图纸解决问题。但面向对象的底层是面向过程的，把面向过程抽象成类进行封装，就成为了面向对象。

30、面向对象的特性是什么？有什么需要注意的？

答：①抽象：将一类对象的共同特征总结出来构造成类的过程，包括属性抽象和行为抽象。抽象不关注属性和行为的具体细节。

       ②封装：封装是把一个成员私有化隐藏其细节，同时提供接口用于外界的访问的方法。

       ③继承：Java支持单继承，子类可以增加新的属性和方法并完全的继承了父类的属性和方法。

       ④多态：有时程序中定义的引用所指向的实例无法确定，只有在运行期间才能确定。如声明一个动物发出叫声的方法，可以通过传入参数来指定发出何种动物的叫声。在方法定义时            并不知道会传入什么动物类型，所以我们将形参的类型定义为Animal，在Java中父类引用可以指向子类类型，所以在运行时可以传入Cat、Dog等子类类型的实参。如此可以实现              一个方法可适用于多种状态类型。

  注意事项：

  ①继承中子类拥有父类非private的属性和方法。子类可以拥有特有方法和属性。子类可以重写覆盖父类的方法

  ②多态有两种形式可以实现：继承类（多个子类对同一方法的重写）或实现接口（多个类实现接口的同一方法）。

  ③方法重载体现编译时的多态性。方法重写体现运行时的多态性。

31、多态实现的条件？

答：实现多态的条件是：继承、重写、向上转型。

32、多态的实现遵循原则是？

答：重写的方法被谁调用取决于引用指向的对象的类型而不是引用的类型且这个重写的方法必须在超类中定义过。

33、面向对象五大基本原则是什么？

答：①单一职责原则SRP：类的功能要单一

       ②开发封闭原则OCP：模块对于拓展是开放的，对修改是封闭的。

       ③里式替换原则LSP：子类可以替换父类出现在父类能过出现的任何地方。

       ④依赖倒置原则DIP：高层次的模块不应该依赖低层次的模块，他们都应该依赖于抽象，抽象不应该依赖于具体实现。

       ⑤接口分离原则ISP：多个特定接口比一个通用接口更有效率。

34、抽象类和接口对比

答：抽象类是用来捕捉子类的通用特性的，接口是极端的抽象类，是抽象方法的集合。从设计层面上讲，接口是对类的抽象，而接口是对行为的抽象。

   ①相同点：接口和抽象类都不能实例化，都位于继承和实现的顶端，被其他类继承和实现。接口和抽象类的抽象方法必须由子类实现。

   ②不同点：抽象类用abstract关键字声明，接口用interface关键字声明。抽象类的子类用extends关键字来继承，接口的实现类用implements关键字来实现。抽象类可以有构造器，接口        不能有构造器。

抽象类中方法可以是非抽象的，接口中的方法默认为public abstract的。一个类最多只能继承一个抽象类但能实现多个接口。抽象类的字段声明是任意的，接口默认为static final的。

35、怎么选择接口和抽象类呢？

答：我们遵循这样一个原则：

①行为模型应该总是通过接口而不是抽象类定义，所以我们通常是优先选用接口。

②当要为子类提供通用的属性和功能时可以选择抽象类。

36、普通类和抽象类有哪些区别？

答：普通类不能包含抽象方法，抽象类可以包含抽象方法。抽象类不能实例化，可以通过子类继承实例化，普通类可以直接实例化。

37、抽象类能使用final修饰吗?

答：不能，定义抽象类就是让子类来继承的。

38、创建一对象用什么关键字？对象实例与对象引用有什么不同？

答：new关键字来创建对象，对象引用指向对象实例，对象引用存放在栈中，而对象实例存放在堆中。一个对象引用可以指向0或1个对象（一根缰绳可以牵马也可以不牵马，但不能牵多匹马），一个对象可以有n个引用指向它（一匹马可以配有多条缰绳）。

39、成员变量和局部变量的区别有哪些？

答：①变量：变量是内存中的一块区域。

       ②成员变量：在方法外部、类的内部声明的变量。

       ③局部变量：在方法内或方法参数列表中声明的变量。

成员变量和局部变量的区别：

①作用域：成员变量对整个类有效，局部变量在方法语句体内有效。

②存储位置：成员变量随着对象的创建而存在，随着对象消失而消失，存储在堆内存中。局部变量：在方法被调用，存储在栈内存中，当方法调用完，语句结束后自动释放。

③生命周期：成员变量随着对象的创建而存在，随对象的消失而消失。局部变量当方法调用完自动释放。

④初始值：成员变量有默认初始值，局部变量使用前必须初始化。

⑤使用原则：使用变量需要遵循就近原则，首先在局部范围寻找，没有则在成员范围寻找。

40、一个不做事且没有参数的构造方法的作用？

答：执行子类的构造方法之前，如果没有用super()来调用父类有参构造方法则会调用父类的无参构造方法。如果父类中已经定义了有参构造方法，却没有无参构造。那么如果子类中没有调用父类的有参构造方法就会在编译时发生错误。

41、在调用子类构造方法之前会默认调用父类的无参构造，目的是？

答：因为子类对象可能会用到父类的成员，所以要调用父类无参构造帮助子类做初始化工作。

42、一个类的构造方法的作用是什么？若一个类没有声明构造方法，该程序能正确执行吗？

答：构造方法作用是完成对象的初始化工作。一个类如果没有声明构造方法也会有默认的无参构造方法。

43、构造方法有哪些特性？

答：①构造方法名和类名相同。

       ②方法没有返回值，但不能用void关键字声明

       ③用new关键字生成类的对象时自动执行，无需调用方法。

44、静态变量和实例变量的区别？

答：静态变量：静态变量属于类，在内存中有且只有一份，只会被实例化一次。

实例变量：实例变量属于对象，在内存中，创建几个对象就有几份对应的实例变量。

45、静态变量的特别之处？

答：static关键字修饰的变量称为静态变量，静态变量被所有对象所共享，在内存中只有一个副本，当它在类初次加载时就被优先初始化。我们可以用静态变量的自加来计算构造方法被调用了多少次。而非静态变量无法实现，因为其是属于对象的，没个对象都要对应的一份非静态变量。

46、静态方法和实例方法有何不同？

答：①调用静态方法时，用类名.方法名的形式（本类中直接用方法名调用）或对象.方法名的形式（这种形式不同的对象调用的是同一个方法）。调用静态方法是无需创建对象的。

       ②静态方法在访问本来成员时，只能访问静态成员，不允许访问实例成员和实例方法。

47、在一个静态方法内调用一个非静态成员为什么是非法的？

答：因为静态方法属于类而非静态成员属于对象。对应成员存储的内存空间也是不同的。

48、什么是内部类？

答：一个类定义在另外一个类的内部，这就是内部类。内部类本身也是类的一个属性。

49、内部类的分类？

答：①成员内部类②局部内部类③匿名内部类④静态内部类

①成员内部类：

成员位置上的非静态类，就是成员内部类。

成员内部类可以访问外部类所有的变量和方法。

成员方法的调用形式：对象.方法名;

创建成员内部类的方式：

②局部内部类

定义在方法中的内部类。局部内部类相似与局部变量，因此局部内部类不允许使用访问权限修饰符，局部内部类中不能定义static成员。

局部内部类可以访问外部类的所有成员。局部内部类只在当前方法中有效，要在方法内实例化。

③匿名内部类

匿名内部类是没有名字的内部类。

注意：匿名内部类必须继承抽象类或实现接口。

           匿名内部类不能定义任何静态成员和方法。

           当所在的方法的形参需要被匿名内部类使用时，形参必须被声明为final常量。

④静态内部类：

静态内部类能访问外部的所有静态变量，但不能访问外部的非静态变量。

静态属性的调用方法是：类名.属性名;

静态内部类实例化方式：new 外部类.静态内部类( );

50、内部类的优点？

答：①一个内部类对象可以访问创建它的外部类对象的内容。

       ②内部类不为同一包的其他类所见，具有很好的封装性。

       ③内部类有效实现了“多继承”

       ④匿名内部类可以很方便的定义回调。

51、内部类的应用场景？

答：①多算法场合

       ②解决一些非面向对象的语句

       ③当某个类除了它的外部类，不再被其他类使用的时候。

52、局部内部类和匿名内部类访问局部变量的时候，为什么？

答：局部变量是直接存储在栈中的，当方法执行结束后，非final的局部变量就会被销毁，而局部内部类对局部变量的引用却依然存在。常量是不会被销毁的，所以final可以确保局部内部类使用的变量和外层的局部变量区分开。

53、看程序写出运行结果

public class Outer {
    private int age = 12;

    class Inner {
       private int age = 13;
       public void print() {
        int age = 14;
        System.out.print(age);
           System.out.print(this.age);
            System.out.print(Outer.this.age);
        }
    }

    public static void main(String[] args) {
      Outer.Inner in = new Outer().new Inner();
      in.print();
    }

答：age是局部变量，根据就近原则，age=14；this.age是当前内部类的对象所对应的成员变量age，this.age=13；Outer.this.age是Outer外部类的对象所对应成员变量age，Outer.this.age=12。

输出结果为：141312

54、构造器可以被重写吗？

答：构造器可以被重载但不能被重写。

55、重载和重写的区别。重载的方法能否根据返回类型进行区分？

答：重载：发生在同一个类中，方法名称相同但参数个数、次序、类型不同。重载对返回值类型没有要求，可以相同也可以不同，所以不能根据返回类型进行区分，要根据参数列表进行区分；但如果参数的个数、类型、次序都相同，方法名也相同仅返回值不同，是无法构成重载的。

重写：发生在父子类中，方法名、参数列表、返回类型相同，抛出的异常小于等于父类所抛出的异常，访问修饰符大于等于父类方法的权限。

56、==和equals的区别是？

答：①==：对于基本类型做值比较，对于引用数据类型比较内存地址。

       ②equals()：当没有被重写时，与==作用相同。String类和Integer类重写了之后作内容比较，若内容相同，则返回true。

注意：String直接赋值是在常量池中创建对象，是一个常量，其可以当做基本数据类型看待。

57、hashCode和equals

答：hashCode()的作用是获取哈希码，返回一个int整数。哈希码的作用是确定对象在哈希表中的位置，相当于对象的地址。当你把对象加入HashSet时，HashSet会根据对象的hashCode值来判断对象加入的位置，同时会与其他已经加入的对象的hashCode值作比较，如果发现有相同的hashCode值的对象，这是会调用equals方法来检查两个对象是否相等，如果两个对象相等，HashSet就不会让其加入操作成功。

   两个对象相等，hashCode一定相等。

   两个对象相等，对两个对象分别调用equals方法都返回true。

   两个对象有相同的hashCode值，它们也不一定相等。

58、为什么哈希码相同了还有可能是不同对象？为什么经过比较哈希码之后还有再次借助equals方法判断？

答：①按照Object类的hashCode方法，是不可能返回两个相同的哈希码的。Object类的hashCode方法返回的哈希码具有唯一性。

       ②我们重写了hashCode方法，目的是为了：某属性相同的不同对象在调用其hashCode方法后，返回的是相同的哈希码（地址）。

       ③但是我们在重写时，无法避免一个bug：有一些属性不同的对象，也会返回相同的哈希码（重码现象）。

       ④为了解决重码的问题，在哈希码相同的时候，再调用equals方法比较两个对象的对应属性是不是真正相同，这样确保了万无一失。

59、对象的相当和引用的相等，两者有什么不同？

答：对象的相等，是比较内存中存放的内容是否相等；引用的相等，是比较他们指向的堆地址是否相等。

60、当一个对象被当做参数传递到一个方法后，此方法可改变该对象的属性，并返回变化后的结果，那么这里是值传递还是引用传递。

答：Java语言的方法调用只支持参数的值传递；当一个对象实例作为一个参数被传递到方法中时，参数就是对象引用的值。对象的属性可以在被调用的过程中被改变，对象引用的改变是不会造成影响的，所以是值传递。

61、关于Java的值传递？

答：按值调用表示方法接收的是调用者提供的值，而按引用调用表示方法接收的是调用者提供的变量地址。

在Java中：

①对于基本类型数据是值传递（方法操作的是拷贝的内容）

②对于引用类型数据是值传递（方法操作的是拷贝的地址）

可能有人会觉得Java对于对象采用的是引用调用，其实不是。

③举例

方法并没有改变存储在遍历s1和s2中的对象引用。这个方法交换的是两个引用的拷贝。

④总结

一个方法不能修改一个基本数据类型的参数。假设把基本数据类型的参数比作一个苹果，方法是吃苹果。那么调用方法后吃掉的是苹果的副本，原本的苹果还在。

一个方法可以改变一个对象参数的状态。假设把引用比作遥控器，对象比作电视。那么对象引用参数的传递，相当于复制了遥控器，调用该方法一样可以遥控对应的电视。

一个方法不能让对象参数引用一个新的对象。还是和上面提及的一样的假设，如果有两个遥控器和对应的两台电视。现在把两个遥控器当做参数传入方法，其实传递的是两个遥控器的副本。方法的功能是交换两个遥控器遥控的对象。在方法内，两个副本是可以遥控到对方的电视的，但方法执行完后，栈内的局部变量被释放，两个拷贝的遥控器随之消失。再次调用遥控器，还是遥控以前的电视。

62、JDK中常用的包有哪些？

答：①java.lang:基础类包

       ②java.io:输入输出类包

       ③java.net:网络类包

       ④java.util:系统辅助类工具包

       ⑤java.sql:数据库类包

63、import java和javax有什么区别？

答：最初，Java API所必需的标准包是java开头的包，javax是扩展包；如今，javax也成为了标准API的一部分。

64、java中IO流分为几种？

答：①按照流的流向划分为输入流和输出流

       ②按操作单元划分为字节流和字符流

       ③按流的角色划分为节点流和处理流

注：Java IO流的40多个类都是从如下4个抽象类中派生的：

①inputStream/Reader:输入流的基类；前者字节流，后者字符流

②outputStream/writer:输出流基类；前者字节流，后者字符流

65、Files的常用方法有哪些？

答：①Files.exists();//检测文件路径是否存在。

       ②Files.createFile();//创建文件。

       ③Files.createDirectory;//创建文件夹（目录）。

       ④Files.delete();//删除文件或目录。

       ⑤Files.copy();//赋值文件。

       ⑥Files.move();//移动文件。

       ⑦Files.size();//查看文件个数。

       ⑧Files.read();//读取文件。

       ⑨Files.write();//写入文件。

66、什么是反射机制？

答：反射机制是在运行状态中的动态获取信息以及动态调用方法的机制：对于任意一个类，都能知道这个类的所有属性和方法；对于如何一个对象，都能调用它的任意一个属性和方法。

67、反射机制的优缺点？

答：优点：运行期类型的判断，可以动态加载类，提供代码灵活度。

缺点：反射相当于一系列解释操作，通知JVM要做的事情，性能比直接的Java代码要差。

68、获得反射的方法是？

答：

69、字符型常量和字符串常量的区别？

答：①形式上：字符常量是单引号引起的一个字符，字符串常量是双引号引起的若干个字符。

       ②含义上：字符常量相当于一个ASCⅡ值，可以参加表达式运算。字符串常量则代表一个地址值。

       ③占内存大小：char类型值最多占用4byte:32位。而字符串常量占若干个字节（至少有一个字符结束标志）。

70、什么是字符串常量池？

答：字符串常量池位于堆内存中，专门用来储存字符串常量的空间。在创建字符串时，JVM会先检查字符串常量池，如果该字符串已经存在于其中，则返回它的引用；如果不存在则实例化一个字符串放入池中，返回其引用。

71、String是基本数据类型吗？

答：不是，String是引用数据类型；String底层是char类型的数组。

72、String类型有哪些特性？

答：①不变性：String是只读不可变字符串，对它进行任何操作其实都是创建一个新的对象，再把引用再指向这个新的对象。

       ②常量池优化：String对象创建之后，会在字符串常量池中进行缓存，如果下次创建同样的对象，会直接返回缓存的引用。

       ③final：如果用final来定义String类，表示String类不能被继承，提供了系统的安全性。

73、String为什么是不可变的？

答：String底层利用了final修饰的char类型数组存储字符。

但String不可以变不代表引用不能变：

74、是否可以继承String类？

答：不可以，其被默认final修饰。

75、String str = “i”;与String str = new String(“i”);一样吗？

答：不一样，因为内存分配的方式不一样。第一种方式会存储在常量池中，第二种方式会对象存储在堆空间中，参数存储在常量池中

76、String str = new String(“xyz”);创建了几个对象？

答：两个对象，一个常量池的xzy值，一个是堆空间中new创建的新对象。

77、如何将字符串反转？

答：使用StringBuffer类中的普通方法reverse()；

78、数组有length()方法吗？String类有吗？

答：

如图可知：数组有length属性，String类有length方法。

79、String类有哪些常用的方法？

答：①indexOf();//返回指定字符的索引。

       ②charAt();//根据索引返回字符值。

       ③repalce();//字符串替换。

       ④trim();//去除字符串两端的空格。

       ⑤split();//分割字符串，返回分割后的字符串。

       ⑥getBytes();//返回字符串的byte(字节）类型数组。

       ⑦equals();//字符串的比较。

       ⑧toLowerCase();//将字符串转成小写字母。

       ⑨toUpperCase();//将字符串转成大写字母。

       ⑩subString();//截取字符串；

80、在使用HashMap的时候，用String做Key的好处？

答：HashMap内部实现是通过key的hashCode来确定value的存储位置。因为字符串的不可变且在常量池中唯一存在的，所以更适合作为Key。

81、String和StringBuffer、StringBuilder的区别？

答：①可变性：String类使用final修饰的字符数组来实现保存字符串，所以对象是不可变的。StringBuffer、StringBuilder都继承AbstractStringBuilder类，在此类中也使用字符数组保存字符串，但是没有final修饰，都是可变的。

       ②线程安全性：String对象不可变，相当于常量，是线程安全的。而StringBuffer对方法增加了同步锁，也是安全的。StringBuilder对象可变，没有对方法进行同步锁，是非线程安全的。

       ③性能：每次对String对象进行改变，都会生成一个新的对象，然后将引用指向新的对象，StringBuffer类是对对象本身进行操作，性能更强。而StringBuilder是非线性安全的，相对StringBuffer类，其性能较强。

       ④总结：如果要操作少量数据用String

                     如果要单线程操作大量数据用StringBuilder

                     如果要多线程操作大量数据用StringBuffer

82、解释自动装箱和自动拆箱？

答：自动装箱：自动将基本数据类型用它们对应的引用包装类型包装起来。

       自动拆箱：自动将引用包装类型转换为基本数据类型。

83、Integer a =1与Integer b = 1相等吗？

答：①==：对于基本类型做值比较，对于引用数据类型比较内存地址。

       ②equals()：当没有被重写时，与==作用相同。String类和Integer类重写了之后作内容比较，若内容相同，则返回true。

注意：String直接赋值是在常量池中创建对象，是一个常量，其可以当做基本数据类型看待。