自己整理面试题

1．现有3ml， 5ml的杯子各一个,如何拼出 4ml的水容量。

分两种：4 = 3+1 或者 4 = 5-1

第一种方法：4 = 3+1
将3ml的水杯装满，倒入5ml的杯子中，再重复一遍，最后3ml的杯子里剩下1ml的水，把5ml杯子里的水倒掉，将那1ml倒进5ml的杯子，再将3ml的杯子装满，倒进5ml的杯子中，这样1+3=4；
第二种方法： 4 = 5-1
先将5ml的水倒入3ml的杯中，5ml杯中剩余2ml,将3ml杯中的水倒掉，将5ml杯中的水（现在是2ml）倒入3ml的杯中，（那么3ml杯中有2ml的水），再将5ml的杯子装满，把水倒入3ml的杯中装满，这时5ml杯中的水就是4ml,这样5-1=4.

2．介绍一下JVM的构成,并简单说明 java 源文件、字节码和二进制机器码之间的关系。

JVM 整体组成可分为以下四个部分：

1. 类加载器（ClassLoader）
2. 运行时数据区（Runtime Data Area）
3. 执行引擎（Execution Engine）
4. 本地库接口（Native Interface）

各个组成部分的用途：

程序在执行之前先要把java代码转换成字节码（class文件），jvm首先需要把字节码通过一定的方式 类加载器（ClassLoader） 把文件加载到内存中 运行时数据区（Runtime Data Area） ，而字节码文件是jvm的一套指令集规范，并不能直接交个底层操作系统去执行，因此需要特定的命令解析器 执行引擎（Execution Engine） 将字节码翻译成底层系统指令再交由CPU去执行，而这个过程中需要调用其他语言的接口 本地库接口（Native Interface） 来实现整个程序的功能，这就是这4个主要组成部分的职责与功能。

而我们通常所说的jvm组成指的是运行时数据区（Runtime Data Area），因为通常需要程序员调试分析的区域就是“运行时数据区”，或者更具体的来说就是“运行时数据区”里面的Heap（堆）模块，那接下来我们来看运行时数据区（Runtime Data Area）是由哪些模块组成的。

Java严格说来是“半解释半编译”型的语言

Java代码首先由javac编译器编译成字节码(ByteCode)。字节码文件中JVM指令(也称字节码指令)是JVM唯一能够识别的指令，JVM执行JVM指令时，通过JVM解释器逐条读取字节码文件中JVM指令解释为机器码执行。当某一方法调用次数达到即时编译定义的阈值时，就会触发即时编译器JIT进行优化生成机器码。

字节码文件和JVM指令的规范由JVM规范定义，JVM在不同的硬件平台上需要有不同实现，以达到所谓“一次编写，到处运行”的目标。

3．简述runnable和 callable有什么区别?

Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值，支持泛型

Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息

4.请解释HTTP 请求的GET 与POST 方式的区别。

参考链接（一定要看！）：https://www.cnblogs.com/logsharing/p/8448446.html

GET和POST是什么？HTTP协议中的两种发送请求的方法。

HTTP是什么？HTTP是基于TCP/IP的关于数据如何在万维网中如何通信的协议。

HTTP的底层是TCP/IP。所以GET和POST的底层也是TCP/IP，也就是说，GET/POST都是TCP链接。GET和POST能做的事情是一样一样的。你要给GET加上request body，给POST带上url参数，技术上是完全行的通的。

GET和POST还有一个重大区别，简单的说：

GET产生一个TCP数据包；POST产生两个TCP数据包。

因为POST需要两步，时间上消耗的要多一点，看起来GET比POST更有效。因此Yahoo团队有推荐用GET替换POST来优化网站性能。但这是一个坑！跳入需谨慎。为什么？

1. GET与POST都有自己的语义，不能随便混用。

2. 据研究，在网络环境好的情况下，发一次包的时间和发两次包的时间差别基本可以无视。而在网络环境差的情况下，两次包的TCP在验证数据包完整性上，有非常大的优点。

3. 并不是所有浏览器都会在POST中发送两次包，Firefox就只发送一次。

5.简述单例模式的特点或优劣，并补全以下代码实现线程安全的单例模式。

单例模式的特点：

单例类只有一个实例、单例类必须自己创建自己的唯一实例、单例类必须给所有其他对象提供这一个实例。

单例的四大原则：构造函数私有化、以静态方法或枚举返回实例、确保实例只有一个，尤其是在多线程环境、确保反序列化时不会重新构建对象

分为饿汉式、懒汉式

饿汉式：

public class Singleton1 {
    /**
     * 私有构造
     */
    private Singleton1(){
        System.out.println("构造函数 Singleton1");
    }

    /**
     * 初始化实例对象
     */
    private static Singleton1 single = new Singleton1();

    /**
     * 静态工厂方法，返回实例对象
     *
     * @return
     */
    public static Singleton1 getInstance() {
        System.out.println("getInstance");
        return single;
    }

    public static void main(String[] args) {
        System.out.println("初始化");
        Singleton1 instance = Singleton1.getInstance();
    }
}

饿汉式存在的问题：

​ 在没有使用这个对象的情况下就加载到内存是一种很大的浪费。针对这种情况，有一种新的思想提出——延迟加载，也就是所谓的懒汉式。

懒汉式：

该示例在调用Singleton2.getInstance()时才会创建对象，起到了延迟加载的作用。但在多线程环境下会产生多个 Singleton 对象，存在线程安全问题。

public class Singleton2 {
    /**
     * 私有构造
     */
    private Singleton2() {
        System.out.println("构造函数 Singleton2");
    }

    /**
     * 初始值为 null
     */
    private static Singleton2 single = null;

    /**
     * 静态工厂方法
     *
     * @return 单例对象
     */
    public static Singleton2 getInstance() {
        if (single == null) {
            System.out.println("getInstance");
            single = new Singleton2();
        }
        return single;
    }

    public static void main(String[] args) {
        System.out.println("初始化");
        Singleton2 instance = Singleton2.getInstance();
    }
}

懒汉式（解决线程安全问题）

public class Singleton3 {

    /**
     * 私有构造
     */
    private Singleton3() {
    }

    /**
     * 初始值为 null
     */
    private static Singleton3 single = null;

    /**
     * 使用synchronized解决线程安全问题
     *
     * @return
     */
    public static synchronized Singleton3 getInstance() {
        if (single == null) {
            single = new Singleton3();
        }
        return single;
    }
}

6.请按照情况说明如下语句创建了几个对象?

String str = new String(“abc”);

答案：两个或一个

如果代码是这样的：

String str2 = new String("abc");  

并且 abc 字符串之前没有用过，这毫无疑问创建了两个对象，一个是new String 创建的一个新的对象，一个是常量“abc”对象的内容创建出的一个新的String对象。

但是如果代码是这样子的：

String str1 = "abc";  
  
String str2 = new String("abc");  

此时就创建一个对象，而abc 则是从字符串常量缓冲区中取出来的

总结：

String str = new String(“abc”); 首先要看常量池里是否有“abc”这个字符串，如果有，则创建一个，如果没有，则创建两个。
我们可以把上面这行代码分成String str、 = 、 “abc” 和 new String() 四部分来看待。String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；= 是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String(“abc”)了。那么，new String(“abc”)为什么又能被看成"abc"和new String()呢？
我们来看一下被我们调用了的String的构造器：
public String(String original) { //other code … }

大家都知道，我们常用的创建一个类的实例（对象）的方法有以下两种:
一，使用new创建对象。
二、调用Class类的newInstance方法，利用反射机制创建对象。
我们正是使用new调用了String类的上面那个构造器方法创建了一个对象，并将它的引用赋值给了str变量。同时我们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是"abc"。由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。

我们来看以下两个例子加深理解：
String str1 = “abc”; String str2 = “ab” + “c”; str1 == str2是true吗？
答案：是。因为String str2 = “ab” + “c” 会查找常量池中时候存在内容为"abc"字符串对象，如存在则直接让str2引用该对象，显然String str1 = "abc"的时候，上面说了，会在常量池中创建"abc"对象，所以str1引用该对象，str2也引用该对象，所以 str == str2

String str1 = “abc”; String str2 = “ab”; String str3 = str2 + “c”; str1==str3是false吗？
答案：是。因为String str3 = str2 + "c"涉及到变量（不全是常量）的相加，所以会生成新的对象，其内部实现是先new一个StringBuilder，然后 append(str2),append(“c”);然后让str3引用toString()返回的对象

原文链接：https://blog.csdn.net/qq_36470686/article/details/83444483

7. int和Integer的区别。并说明如下语句的输出结果

   Integer i = 100;

   Integer j = 100;

   System.out.println(i == j); // true

   lnteger m =128;

   lnteger n =128;

   System.out.println(m == n); // false

1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用，而int变量不需要
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4、Integer的默认值是null，int的默认值是0

延伸：
关于Integer和int的比较
1、由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //false

2、Integer变量和int变量比较时，只要两个变量的值是相等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);
int j = 100；
System.out.print(i == j); //true

3、非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为 ①当变量值在-128~127之间时，非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同；②当变量值在-128~127之间时，非new生成Integer变量时，java API中最终会按照new Integer(i)进行处理（参考下面第4条），最终两个Interger的地址同样是不相同的）

Integer i = new Integer(100);
Integer j = 100;
System.out.print(i == j); //false

4、对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true
Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

对于第4条的原因：
java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；，而java API中对Integer类型的valueOf的定义如下：

public static Integer valueOf(int i){
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high){
        return IntegerCache.cache[i + (-IntegerCache.low)];
    }
    return new Integer(i);
}

java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了