24W字Java经典面试题总结（附答案）_霸王茶姬java面试题-CSDN博客

JVM（Java Virtual Mechinal），Java虚拟机，是JRE的一部分。它是整个Java实现跨平台的核心，负责解释执行字节码文件，是可运行Java字节码文件的虚拟计算机。所有平台上的JVM向编译器提供相同的接口，而编译器只需要面向虚拟机，生成虚拟机能识别的代码，然后由虚拟机来解释执行。当使用Java编译器编译Java程序时，生成的是与平台无关的字节码，这些字节码只面向JVM。也就是说

JVM是运行Java字节码的虚拟机。

不同平台的JVM是不同的，但是他们都提供了相同的接口。JVM是Java程序跨平台的关键部分，只要为不同平台实现了相同的虚拟机，编译后的Java字节码就可以在该平台上运行。

为什么要采用字节码：

在 Java 中，JVM 可以理解的代码就叫做字节码（即Java源代码经过虚拟机编译器编译后扩展名为.class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。

什么是跨平台：

所谓跨平台性，是指java语言编写的程序，一次编译后，可以在多个系统平台上运行。

实现原理：Java程序是通过java虚拟机在系统平台上运行的，只要该系统可以安装相应的java虚拟机，该系统就可以运行java程序。

Java 程序从源代码到运行需要三步：

4. 总结

1. JDK 用于开发，JRE 用于运行java程序；如果只是运行Java程序，可以只安装JRE，无序安装JDK。

2. JDk包含JRE，JDK 和 JRE 中都包含 JVM。

3. JVM 是 Java 编程语言的核心并且具有平台独立性。

4. Oracle JDK 和 OpenJDK 的对比

Oracle JDK版本将每三年发布一次，而OpenJDK版本每三个月发布一次；
OpenJDK 是一个参考模型并且是完全开源的，而Oracle JDK是OpenJDK的一个实现，并不是完全开源的；
Oracle JDK 比 OpenJDK 更稳定。OpenJDK和Oracle JDK的代码几乎相同，但Oracle JDK有更多的类和一些错误修复。因此，如果您想开发企业/商业软件，我建议您选择Oracle JDK，因为它经过了彻底的测试和稳定。某些情况下，有些人提到在使用OpenJDK 可能会遇到了许多应用程序崩溃的问题，但是，只需切换到Oracle JDK就可以解决问题；
在响应性和JVM性能方面，Oracle JDK与OpenJDK相比提供了更好的性能；
Oracle JDK不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
Oracle JDK根据二进制代码许可协议获得许可，而OpenJDK根据GPL v2许可获得许可。

5. Java有哪些数据类型

Java中有 8 种基本数据类型，分别为：

6 种数字类型（四个整数形，两个浮点型）：byte、short、int、long、float、double
1 种字符类型：char
1 种布尔型：boolean。

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。

int：

int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。

long：

注意：Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。 "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。

double：

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。

char：

char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为 0）；
最大值是 \uffff（即为 65535）；
char 数据类型可以储存任何字符；
例子：char letter = 'A';（单引号）

boolean：

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。

这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、 Character、Boolean

6. Java中引用数据类型有哪些，它们与基本数据类型有什么区别？

引用数据类型分3种：类，接口，数组；

简单来说,只要不是基本数据类型.都是引用数据类型。那他们有什么不同呢？

1、从概念方面来说

1,基本数据类型:变量名指向具体的数值

2,引用数据类型:变量名不是指向具体的数值,而是指向存数据的内存地址,.也及时hash值

2、从内存的构建方面来说(内存中,有堆内存和栈内存两者)

1,基本数据类型:被创建时,在栈内存中会被划分出一定的内存,并将数值存储在该内存中.

2,引用数据类型:被创建时,首先会在栈内存中分配一块空间,然后在堆内存中也会分配一块具体的空间用来存储数据的具体信息,即hash值,然后由栈中引用指向堆中的对象地址.

举个例子

//基本数据类型作为方法参数被调用
public class Main{
  public static void main(String[] args){
    //基本数据类型
    int i = 1;
    int j = 1;
    double d = 1.2;

    //引用数据类型
    String str = "Hello";
    String str1= "Hello";
  }
}

由上图可知，基本数据类型中会存在两个相同的1，而引用型类型就不会存在相同的数据。

假如"hello"的引用地址是xxxxx1，声明str变量并其赋值"hello"实际上就是让str变量引用了"hello"的内存地址，这个内存地址就存储在堆内存中，是不会改变的，当再次声明变量str1也是赋值为"hello"时，此时就会在堆内存中查询是否有"hello"这个地址，如果堆内存中已经存在这个地址了，就不会再次创建了，而是让str1变量也指向xxxxx1这个地址，如果没有的话，就会重新创建一个地址给str1变量。

7. 从使用方面来说

1,基本数据类型:判断数据是否相等，用==和!=判断。

2,引用数据类型:判断数据是否相等，用equals()方法,==和!=是比较数值的。而equals()方法是比较内存地址的。

补充：数据类型选择的原则

如果要表示整数就使用int，表示小数就使用double；
如果要描述日期时间数字或者表示文件（或内存）大小用long；
如果要实现内容传递或者编码转换使用byte；
如果要实现逻辑的控制，可以使用booleam；
如果要使用中文，使用char避免中文乱码；
如果按照保存范围：byte < int < long < double

8. Java中的自动装箱与拆箱

什么是自动装箱拆箱？

从下面的代码中就可以看到装箱和拆箱的过程

//自动装箱
Integer total = 99;

//自定拆箱
int totalprim = total;

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

在Java SE5之前，自动装箱要这样写：Integer i = new` `Integer( 10``);

对于Java的自动装箱和拆箱，我们看看源码编译后的class文件，其实装箱调用包装类的valueOf方法，拆箱调用的是Integer.Value方法，下面就是变编译后的代码：

......

Java并发编程

1. 多线程有什么用？

一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓"知其然知其所以然"，"会用"只是"知其然"，"为什么用"才是"知其所以然"，只有达到"知其然知其所以然"的程度才可以说是把一个知识点运用自如。OK，下面说说我对这个问题的看法：

（1）、发挥多核CPU的优势

随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的，4核、8核甚至16核的也都不少见，如果是单线程的程序，那么在双核CPU上就浪费了50%，在4核CPU上就浪费了75%。单核CPU上所谓的"多线程"那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，看着像多个线程"同时"运行罢了。多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用CPU的目的。

（2）、防止阻塞

从程序运行效率的角度来看，单核CPU不但不会发挥出多线程的优势，反而会因为在单核CPU上运行多线程导致线程上下文的切换，而降低程序整体的效率。但是单核CPU我们还是要应用多线程，就是为了防止阻塞。试想，如果单核CPU使用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。

（3）、便于建模

这是另外一个没有这么明显的优点了。假设有一个大的任务A，单线程编程，那么就要考虑很多，建立整个程序模型比较麻烦。但是如果把这个大的任务A分解成几个小任务，任务B、任务C、任务D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。

2. 多线程和单线程的区别和联系？

1、在单核 CPU 中，将 CPU 分为很小的时间片，在每一时刻只能有一个线程在执行，是一种微观上轮流占用 CPU 的机制。

2、多线程会存在线程上下文切换，会导致程序执行速度变慢，即采用一个拥有两个线程的进程执行所需要的时间比一个线程的进程执行两次所需要的时间要多一些。

结论：即采用多线程不会提高程序的执行速度，反而会降低速度，但是对于用户来说，可以减少用户的响应时间。

3. 简述线程、程序、进程的基本概念。以及他们之间关系是什么?

线程

与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

程序

是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。

进程

是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

4. 线程的创建方式

方法一：继承Thread类，作为线程对象存在（继承Thread对象）

public class CreatThreadDemo1 extends Thread{
  /**
  * 构造方法： 继承父类方法的Thread(String name)；方法
  * @param name
  */
  public CreatThreadDemo1(String name){
    super(name);
  }
  @Override
  public void run() {
    while (!interrupted()){
      System.out.println(getName()+"线程执行了...");
      try {
        Thread.sleep(200);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
  public static void main(String[] args) {
    CreatThreadDemo1 d1 = new CreatThreadDemo1("first");
    CreatThreadDemo1 d2 = new CreatThreadDemo1("second");
    d1.start();
    d2.start();
    d1.interrupt(); //中断第一个线程
  }
}

常规方法，不多做介绍了，interrupted方法，是来判断该线程是否被中断。（终止线程不允许用stop方法，该方法不会施放占用的资源。所以我们在设计程序的时候，要按照中断线程的思维去设计，就像上面的代码一样）。

让线程等待的方法

Thread.sleep(200); //线程休息2ms
Object.wait()； //让线程进入等待，直到调用Object的notify或者notifyAll时，线程停止休眠

方法二：实现runnable接口，作为线程任务存在

public class CreatThreadDemo2 implements Runnable {
  @Override
  public void run() {
    while (true){
      System.out.println("线程执行了...");
    }
  }
  public static void main(String[] args) {
    //将线程任务传给线程对象
    Thread thread = new Thread(new CreatThreadDemo2());
    //启动线程
    thread.start();
  }
}

Runnable 只是来修饰线程所执行的任务，它不是一个线程对象。想要启动Runnable对象，必须将它放到一个线程对象里。

方法三：匿名内部类创建线程对象

public class CreatThreadDemo3 extends Thread{
  public static void main(String[] args) {
    //创建无参线程对象
    new Thread(){
      @Override
      public void run() {
        System.out.println("线程执行了...");
      }
    }.start();
    //创建带线程任务的线程对象
    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("线程执行了...");
      }
    }).start();
    //创建带线程任务并且重写run方法的线程对象
    new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("runnable run 线程执行了...");
      }
    }){
      @Override
      public void run() {
        System.out.println("override run 线程执行了...");
      }
    }.start();
  }
}

创建带线程任务并且重写run方法的线程对象中，为什么只运行了Thread的run方法。我们看看Thread类的源码，

我们可以看到Thread实现了Runnable接口，而Runnable接口里有一个run方法。

所以，我们最终调用的重写的方法应该是Thread类的run方法。而不是Runnable接口的run方法。

方法四：创建带返回值的线程

public class CreatThreadDemo4 implements Callable {
  public static void main(String[] args) throws ExecutionException,InterruptedException {
    CreatThreadDemo4 demo4 = new CreatThreadDemo4();
    FutureTask<Integer> task = new FutureTask<Integer>(demo4); //FutureTask最终实现的是runnable接口
    Thread thread = new Thread(task);
    thread.start();
    System.out.println("我可以在这里做点别的业务逻辑...因为FutureTask是提前完成任务");
    //拿出线程执行的返回值
    Integer result = task.get();
    System.out.println("线程中运算的结果为:"+result);
  }
  //重写Callable接口的call方法
  @Override
  public Object call() throws Exception {
    int result = 1;
    System.out.println("业务逻辑计算中...");
    Thread.sleep(3000);
    return result;
  }
}

Callable接口介绍：

public interface Callable<V> {
  /**
  * Computes a result, or throws an exception if unable to do so.
  *
  * @return computed result
  * @throws Exception if unable to compute a result
  */
  V call() throws Exception;
}

返回指定泛型的call方法。然后调用FutureTask对象的get方法得道call方法的返回值。

方法五：定时器Timer

public class CreatThreadDemo5 {
  public static void main(String[] args) {
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
      @Override
      public void run() {
        System.out.println("定时器线程执行了...");
      }
    },0,1000); //延迟0，周期1s
  }
}

方法六：线程池创建线程

public class CreatThreadDemo6 {
  public static void main(String[] args) {
    //创建一个具有10个线程的线程池
    ExecutorService threadPool = Executors.newFixedThreadPool(10);
    long threadpoolUseTime = System.currentTimeMillis();
    for (int i = 0;i<10;i++){
      threadPool.execute(new Runnable() {
        @Override
        public void run() {
          System.out.println(Thread.currentThread().getName()+"线程执行了...");
        }
      });
    }
    long threadpoolUseTime1 = System.currentTimeMillis();
    System.out.println("多线程用时"+(threadpoolUseTime1-threadpoolUseTime));
    //销毁线程池
    threadPool.shutdown();
    threadpoolUseTime = System.currentTimeMillis();
  }
}

方法七：利用java8新特性 stream 实现并发

5. 线程有哪些基本状态?

Java 线程在运行的生命周期中的指定时刻只可能处于下面6种不同状态的其中一个状态（图源《Java 并发编程艺术》

线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4节）：

操作系统隐藏 Java虚拟机（JVM）中的 RUNNABLE 和 RUNNING 状态，它只能看到RUNNABLE 状态（图源：HowToDoInJava：Java Thread Life Cycle and Thread States），所以 Java 系统一般将这两个状态统称为 RUNNABLE（运行中）状态。

操作系统隐藏 Java虚拟机（JVM）中的 RUNNABLE 和 RUNNING 状态，它只能看到RUNNABLE状态（图源：HowToDoInJava：），所以 Java 系统一般将这两个状态统称为 RUNNABLE（运行中）状态。

当线程执行 wait() 方法之后，线程进入 WAITING（等待）状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 TIME_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制，比如通过 sleep（long millis）方法或 wait（long millis）方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 BLOCKED（阻塞）状态。线程在执行 Runnable的 run() 方法之后将会进入到 TERMINATED（终止）状态。

6. 如何停止一个正在运行的线程

1、使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

2、使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。

3、使用interrupt方法中断线程。

class MyThread extends Thread {
  volatile boolean stop = false;
  public void run() {
    while (!stop) {
      System.out.println(getName() + " is running");
      try {
        sleep(1000);
      } catch (InterruptedException e) {
        System.out.println("week up from blcok...");
        stop = true; // 在异常处理代码中修改共享变量的状态
      }
    }
    System.out.println(getName() + " is exiting...");
  }
}
class InterruptThreadDemo3 {
  public static void main(String[] args) throws InterruptedException {
    MyThread m1 = new MyThread();
    System.out.println("Starting thread...");
    m1.start();
    Thread.sleep(3000);
    System.out.println("Interrupt thread...: " + m1.getName());
    m1.stop = true; // 设置共享变量为true
    m1.interrupt(); // 阻塞时退出阻塞状态
    Thread.sleep(3000); // 主线程休眠3秒以便观察线程m1的中断情况
    System.out.println("Stopping application...");
  }
}

因内容较多只展示部分内容，完整面试题以备好：