Java 经典面试题详解，突围金九银十面试季（附详细答案）

前言：



想在面试、工作中脱颖而出？想在最短的时间内快速掌握 Java 的核心基础知识点？想要成为一位优秀的 Java 工程师？本篇文章能助你一臂之力！



金九银十，目前正值招聘求职旺季，很多同学对一些新技术名词都能侃侃而谈，但对一些核心原理理解的不够透彻，特别是对 Java的一些核心基础知识点掌握的不够，例如JVM、常用的算法和数据结构等。正所谓万丈高楼平地起，只有把基础掌握的牢固，才能走的更远，面对不断更新的技术才能快速掌握，同时在面试、工作中也更能脱颖而出！





1.Java 自动装箱与拆箱



装箱就是自动将基本数据类型转换为包装器类型（int–>Integer）；调用方法：Integer 的 valueOf(int) 方法



拆箱就是自动将包装器类型转换为基本数据类型（Integer–>int）。调用方法：Integer 的 intValue 方法



在 Java SE5 之前，如果要生成一个数值为 10 的 Integer 对象，必须这样进行：



Integer i = new Integer(10);
1



而在从 Java SE5 开始就提供了自动装箱的特性，如果要生成一个数值为 10 的 Integer 对象，只需要这



样就可以了：



Integer i = 10;
1



2.重载和重写的区别



重写(Override)



从字面上看，重写就是 重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。



public class Father {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Son s = new Son();
        s.sayHello();
    }
    public void sayHello() {
        System.out.println("Hello");
    }
}
class Son extends Father{
    @Override
    public void sayHello() {
        // TODO Auto-generated method stub
        System.out.println("hello by ");
    }
}
1234567891011121314151617



重写 总结：



（1）发生在父类与子类之间



（2）方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同



（3）访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)



（4）重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常



重载（Overload）



在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）



则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来



判断重载。



public static void main(String[] args) {
    // TODO Auto-generated method stub
    Father s = new Father();
    s.sayHello();
    s.sayHello("wintershii");
}
public void sayHello() {
    System.out.println("Hello");
}
public void sayHello(String name) {
    System.out.println("Hello" + " " + name);
}
}
12345678910111213



重载 总结：



（1）重载 Overload 是一个类中多态性的一种表现



（2）重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)



（3）重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准



下方面试题我只挑选了几个比较好的，剩余的实在是太多了写不完，都整理成笔记了，想要笔记的可以点击下方群号领取。另外本人整理收藏了20年多家公司面试知识点整理 ，以及各种Java核心知识点免费分享给大家，下方只是部分截图 有需要资料的话也可以添加vx：bjmsb10 领取 暗号infoq。



3.equals 与==的区别



== ：



== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。



（1）比较的是操作符两端的操作数是否是同一个对象。



（2）两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。



（3）比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为 true，如：



int a=10 与 long b=10L 与 double c=10.0 都是相同的（为 true），因为他们都指向地址为 10 的堆。



equals：



equals 用来比较的是两个对象的内容是否相等，由于所有的类都是继承自 java.lang.Object 类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是 Object 类中的方法，而 Object 中的 equals 方法返回的却是==的判断。



总结：



所有比较是否相等时，都是用 equals 并且在对常量相比较时，把常量写在前面，因为使用 object 的 equals object 可能为 null 则空指针在阿里的代码规范中只使用 equals ，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来排查老代码使用“==”，替换成 equals



4. Hashcode 的作用



java 的集合有两类，一类是 List，还有一类是 Set。前者有序可重复，后者无序不重复。当我们在 set 中插入的时候怎么判断是否已经存在该元素呢，可以通过 equals 方法。但是如果元素太多，用这样的方法就会比较满。



于是有人发明了哈希算法来提高集合中查找元素的效率。 这种方式将集合分成若干个存储区域，每个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储的那个区域。



hashCode 方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的 hashCode 方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的 equals 方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用 equals 方法的次数就大大降低了，几乎只需要一两次。



5.String、String StringBuffer 和 StringBuilder 的区别是什么?



String 是只读字符串，它并不是基本数据类型，而是一个对象。从底层源码来看是一个final 类型的字符数组，所引用的字符串不能被改变，一经定义，无法再增删改。每次对 String 的操作都会生成新的 String 对象。



private final char value[];
1



每次+操作 ： 隐式在堆上 new 了一个跟原字符串相同的 StringBuilder 对象，再调用 append 方法 拼接+后面的字符。



StringBuffer 和 StringBuilder 他们两都继承了 AbstractStringBuilder 抽象类，从 AbstractStringBuilder 抽象类中我们可以看到。



/**
* The value is used for character storage.
*/
char[] value;
1234



他们的底层都是可变的字符数组，所以在进行频繁的字符串操作时，建议使用 StringBuffer 和 StringBuilder 来进行操作。 另外 StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。



6.ArrayList 和 linkedList 的区别



Array（数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。



Array 获取数据的时间复杂度是 O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据,(因为删除数据以后, 需要把后面所有的数据前移)



缺点: 数组初始化必须指定初始化的长度, 否则报错



例如:



int[] a = new int[4];
//推介使用 int[] 这种方式初始化
int c[] = {23,43,56,78};
//长度：4，索引范围：[0,3]
1234



List—是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式，它继承 Collection。



List 有两个重要的实现类：ArrayList 和 LinkedList



ArrayList: 可以看作是能够自动增长容量的数组



ArrayList 的 toArray 方法返回一个数组



ArrayList 的 asList 方法返回一个列表



ArrayList 底层的实现是 Array, 数组扩容实现



LinkList 是一个双链表,在添加和删除元素时具有比 ArrayList 更好的性能.但在 get 与 set 方面弱于



ArrayList.当然,这些对比都是指数据量很大或者操作很频繁。



7.HashMap 和 HashTable 的区别



（1）两者父类不同



HashMap 是继承自 AbstractMap 类，而 Hashtable 是继承自 Dictionary 类。不过它们都实现了同时实现了 map、Cloneable（可复制）、Serializable（可序列化）这三个接口。



（2）对外提供的接口不同



Hashtable 比 HashMap 多提供了 elments() 和 contains() 两个方法。



elments() 方法继承自 Hashtable 的父类 Dictionnary。elements() 方法用于返回此 Hashtable 中的 value 的枚举。



contains()方法判断该 Hashtable 是否包含传入的 value。它的作用与 containsValue()一致。事实上，contansValue() 就只是调用了一下 contains() 方法。



（3）对 null 的支持不同



Hashtable：key 和 value 都不能为 null。



HashMap：key 可以为 null，但是这样的 key 只能有一个，因为必须保证 key 的唯一性；可以有多个 key 值对应的 value 为 null。



（4）安全性不同



HashMap 是线程不安全的，在多线程并发的环境下，可能会产生死锁等问题，因此需要开发人员自己处理多线程的安全问题。



Hashtable 是线程安全的，它的每个方法上都有 synchronized 关键字，因此可直接用于多线程中。虽然 HashMap 是线程不安全的，但是它的效率远远高于 Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。当需要多线程操作的时候可以使用线程安全的 ConcurrentHashMap。



ConcurrentHashMap 虽然也是线程安全的，但是它的效率比 Hashtable 要高好多倍。因为



ConcurrentHashMap 使用了分段锁，并不对整个数据进行锁定。



（5）计算 hash 值的方法不同



8.Collection 包结构，与 Collections 的区别



Collection 是集合类的上级接口，子接口有 Set、List、LinkedList、ArrayList、Vector、Stack、Set；Collections 是集合类的一个帮助类， 它包含有各种有关集合操作的静态多态方法，用于实现对各种集合的搜索、排序、线程安全化等操作。此类不能实例化，就像一个工具类，服务于 Java 的 Collection 框架。



9.Java 的四种引用，强弱软虚



强引用



强引用是平常中使用最多的引用，强引用在程序内存不足（OOM）的时候也不会被回收，使用方式：



String str = new String("str");
1



软引用



软引用在程序内存不足时，会被回收，使用方式：



// 注意：wrf 这个引用也是强引用，它是指向 SoftReference 这个对象的，
// 这里的软引用指的是指向 new String("str")的引用，也就是 SoftReference 类中 T
SoftReference<String> wrf = new SoftReference<String>(new String("str"));
123



可用场景： 创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM 就会回收早先创建的对象。



弱引用



弱引用就是只要 JVM 垃圾回收器发现了它，就会将之回收，使用方式：



WeakReference<String> wrf = new WeakReference<String>(str);
1



可用场景： Java 源码中的 java.util.WeakHashMap 中的 key 就是使用弱引用，我的理解就是，一旦我不需要某个引用，JVM 会自动帮我处理它，这样我就不需要做其它操作。



虚引用



虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入 ReferenceQueue 中。注意哦，其它引用是被 JVM 回收后才被传入 ReferenceQueue 中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有 ReferenceQueue，使用



例子：



PhantomReference<String> prf = new PhantomReference<String>(new
String("str"), new ReferenceQueue<>());
12



可用场景： 对象销毁前的一些操作，比如说资源释放等。** Object.finalize()虽然也可以做这类动作，但是这个方式即不安全又低效。



10.a=a+b 与 a+=b 有什么区别吗?



操作符会进行隐式自动类型转换,此处 a+=b 隐式的将加操作的结果类型强制转换为持有结果的类型,



byte a = 127;
byte b = 127;
b = a + b;
// 报编译错误:cannot convert from int to byte
b += a;
12345



以下代码是否有错,有的话怎么改？



short s1= 1;
s1 = s1 + 1;
12



有错误.short 类型在进行运算时会自动提升为 int 类型,也就是说 s1+1 的运算结果是 int 类型,而 s1 是 short 类型,此时编译器会报错.



正确写法：



short s1= 1;
s1 += 1;
12



+=操作符会对右边的表达式结果强转匹配左边的数据类型,所以没错.



11.try catch finally，try 里有 return，finally 还执行么？



执行，并且finally 的执行早于 try 里面的 return



结论：



（1）不管有木有出现异常，finally 块中代码都会执行；



（2）当 try 和 catch 中有 return 时，finally 仍然会执行；



（3）finally 是在 return 后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally 中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally 执行前确定的；



（4）finally 中最好不要包含 return，否则程序会提前退出，返回值不是 try 或 catch 中保存的返回值。、



12.Java 线程实现/创建方式



继承 Thread 类



Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线程，并执行 run()方法。



 public class MyThread extends Thread { 
         public void run() { 
             System.out.println("MyThread.run()"); 
         } 
    } 
        MyThread myThread1 = new MyThread(); 
        myThread1.start();
1234567



实现 Runnable 接口



如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，可以实现一个Runnable 接口。



public class MyThread extends OtherClass implements Runnable { 
        public void run() { 
             System.out.println("MyThread.run()"); 
         } 
    } 
    //启动 MyThread
    MyThread myThread = new MyThread(); 
    Thread thread = new Thread(myThread); 
    thread.start(); 
    target.run()
    public void run() { 
     if (target != null) { 
     target.run(); 
     } 
    }
123456789101112131415



13.线程池原理



线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。主要特点为：线程复用；控制最大并发数；管理线程。



线程复用 一个 Thread 的类都有一个 start 方法。 当调用 start 启动线程时 Java 虚拟机会调用该类的 run 方法。 那么该类的 run() 方法中就是调用了 Runnable 对象的 run() 方法。 我们可以继承重写 Thread 类，在其 start 方法中添加不断循环调用传递过来的 Runnable 对象。 这就是线程池的实现原理。循环方法中不断获取 Runnable 是用 Queue 实现的，在获取下一个 Runnable 之前可以是阻塞的。



线程池的组成 一般的线程池主要分为以下 4 个组成部分：



（1）线程池管理器：用于创建并管理线程池。 （2）工作线程：线程池中的线程。 （3）任务接口：每个任务必须实现的接口，用于工作线程调度其运行。 （4）任务队列：用于存放待处理的任务，提供一种缓冲机制。



Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable 和 Future、FutureTask 这几个类。



ThreadPoolExecutor 的构造方法如下：



public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);
123



corePoolSize：指定了线程池中的线程数量。



maximumPoolSize：指定了线程池中的最大线程数量。



keepAliveTime：当前线程池数量超过 corePoolSize 时，多余的空闲线程的存活时间，即多次时间内会被销毁。



unit：keepAliveTime 的单位。



workQueue：任务队列，被提交但尚未被执行的任务。



threadFactory：线程工厂，用于创建线程，一般用默认的即可。



handler：拒绝策略，当任务太多来不及处理，如何拒绝任务。



拒绝策略 线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。



JDK 内置的拒绝策略如下：



AbortPolicy ： 直接抛出异常，阻止系统正常运行。



CallerRunsPolicy ： 只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极有可能会急剧下降。



DiscardOldestPolicy ： 丢弃最老的一个请求，也就是即将被执行的一个任务，并尝试再次提交当前任务。



DiscardPolicy ： 该策略默默地丢弃无法处理的任务，不予任何处理。如果允许任务丢失，这是最好的一种方案。



以上内置拒绝策略均实现了 RejectedExecutionHandler 接口，若以上策略仍无法满足实际需要，完全可以自己扩展 RejectedExecutionHandler 接口。



Java 线程池工作过程 （1）线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。



（2）当调用 execute() 方法添加一个任务时，线程池会做如下判断：



a) 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务； b) 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列； c) 如果这时候队列满了，而且正在运行的线程数量小maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务； d) 如果队列满了，而且正在运行的线程数量大于或等maximumPoolSize，那么线程池会抛出异常 RejectExecutionException。



（3）当一个线程完成任务时，它会从队列中取下一个任务来执行。



（4）当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。



14.Java 常用算法



1. 快速排序算法

快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。



 public void sort(int[] a,int low,int high){
         int start = low;
         int end = high;
         int key = a[low]; 
         while(end>start){
         //从后往前比较
         while(end>start&&a[end]>=key) 
        //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
         end--;
         if(a[end]<=key){
             int temp = a[end];
             a[end] = a[start];
             a[start] = temp;
         }
         //从前往后比较
         while(end>start&&a[start]<=key)
        //如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
         start++;
         if(a[start]>=key){
             int temp = a[start];
             a[start] = a[end];
             a[end] = temp;
         }
         //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
     }
         //递归
        if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
         if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1 到最后一个
         }
 }
123456789101112131415161718192021222324252627282930



2 .冒泡排序算法

（1）比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。



（2）这样对数组的第 0 个数据到 N-1 个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1 个位置。



（3）N=N-1，如果 N 不为 0 就重复前面二步，否则排序完成。



public static void bubbleSort1(int [] a, int n){
         int i, j;
         for(i=0; i<n; i++){//表示 n 次排序过程。
             for(j=1; j<n-i; j++){
                 if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
                //交换 a[j-1]和 a[j]
                int temp;
                temp = a[j-1];
                a[j-1] = a[j];
                a[j]=temp;
                }
            }
         }
    }
1234567891011121314



15.Spring Beans



什么是Spring beans？



Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 的形式定义。



一个 Spring Bean 定义 包含什么？



一个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。



如何给Spring 容器提供配置元数据？Spring有几种配置方式



这里有三种重要的方法给Spring 容器提供配置元数据。



XML配置文件。

基于注解的配置。

基于java的配置。



Spring配置文件包含了哪些信息



Spring配置文件是个XML 文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用。



Spring基于xml注入bean的几种方式



Set方法注入；

构造器注入：①通过index设置参数的位置；②通过type设置参数类型；

静态工厂注入；

实例工厂；



总结：



互联网大厂比较喜欢的人才特点：对技术有热情，强硬的技术基础实力；主动，善于团队协作，善于总结思考。无论是哪家公司，都很重视高并发高可用技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。其实我写了这么多，只是我自己的总结，并不一定适用于所有人，相信经过一些面试，大家都会有这些感触。



另外想要面试答案的小伙伴请点击添加vx：bjmsb10，暗号infoq自行领取，本人还整理收藏了20年多家公司面试知识点以及各种技术点整理 下面有部分截图希望能对大家有所帮助。