java面试全解.png

基础

String原理解析

java 底层实际上是一个字符数组：
image.png
给定两个数组，编写一个函数来计算它们的交集。
示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

答案

  1. class Solution {
  2.     public int[] intersection(int[] nums1, int[] nums2) {
  3.         Set<Integer> set = Arrays.stream(nums1).distinct().boxed().collect(Collectors.toSet());
  4.         return Arrays.stream(nums2).distinct().filter(set::contains).toArray();
  5.     }
  6. }

异常处理

  1. 自定义异常
  2. 运行是异常

    JDK 8 日期跟时间以及 Stream

    在线文档： https://www.matools.com/api/java8

java8日期

LocalDate:
LocalDateTime:

面试官:String，StringBuffer，StringBuilder的区别

  • 线程安全：String、 StringBuffer

image.png
因为String字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享
image.png

  • 线程不安全： StringBuilder

因为StringBuilder的方法都是没有加Synchronized同步锁的，所以线程不安全
image.png

  • 执行效率**： StringBuilder > StringBuffer > String**
  • 存储空间：
    • String的值是不可变的，每次对String的操作都会生成新的String对象，效率低，耗费大量内存空间，从而会引起GC。
    • StringBuilder、StringBuffer 都是可变的。
  • 使用场景：
    • 操作少量的数据使用String；
    • 单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
    • 多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

HashMap

思考角度：
存储结构
默认容量
装载因子
hashcode/equals
1.7和1.8版本变化

  • 存储结构：
    • 数组+链表+红黑树（JDK8）
  • 默认容量： 16
  • 装载因子： 0.75
  • key可以为null;
  • HashCode ： 计算键的hashcode作为存储键信息的数组下标用于查找键对象的存储位置。
  • equse： HashMap使用equse()判断当前的键是否与表中存在的键相同（hashCode相同equse不一定相同，equse相同hashcode一定相同）。补充说一句：“两个不同的键值对，哈希值相等”，这就是哈希冲突。（若要判断两个对象是否相等，除了要覆盖equals()之外，也要覆盖hashCode()函数。否则，equals()无效。 ）

为何要设计出迭代器

迭代器本质是一种设计模式，为了解决 为不同的集合类提供 **统一的遍历操作接口**。

java单击并发控制

  • 基础：
    • 同步方法： synchronized
    • 同步块： synchronized
  • 进阶：
    • 重入锁 ReentrantLock

多线程创建的方式

Thread 、 Runnable 、 Callable

  • 继承Thread类创建线程，重写run()方法
    • 只能单继承，。多次调用start()会抛异常IllegalThreadStateException
  • 实现Runnable接口创建线程
    • 多实现
  • 实现Callable接口通过FutureTask包装器来创建Thread线程

  • 使用ExecutorService、Callable、Future实现有返回结果的线程

    Thread 、 Runnable 、 Callable 实现的区别

    第一种实现方式：继承Thread

  • 特点： 只能实现单继承、 启动调用start()方法。

    1. public class ThreadTest {
    2.   public static void main(String[] args) {
    3.       System.out.println("主线程开始");
    5.       ExtendThread t = new ExtendThread();
    6.       //调用start()方法 结果是两个线程同时运行：
    7.       // 当前线程（从调用返回到<code> start </ code>方法）
    8.       // 和另一个线程（执行其* <code> run </ code>方法）
    9.       t.start();
    10.       //重复调用会抛异常：IllegalThreadStateException
    11.       // t.start();
    12.       System.out.println("主线程结束");
    13.   }
    14. }
    15. //继承Thread，重新run()方法
    16. class ExtendThread extends Thread {
    17.   @Override
    18.   public void run() {
    19.       for (int i = 0; i < 10; i++) {
    20.           System.out.println(i);
    21.       }
    22.   }
    23. }

    正常运行结果：
    image.png
    连续两次调用start()方法：
    image.png

  • 休眠 Thread.sleep(1) ;

  • Thread类— 常用API方法：image.pngimage.pngimage.png

第二种实现方法：实现Runnbale接口 （内部只有一个run()方法）

  • 优点：
    • 除非程序员打算修改或增强类的基本行为，否则不应将类归为子类 ，即采用继承Thread类的方式。
    • java类单继承多实现。 如果一个子类以及继承了另外的一个父类， 就不能在继承Thread类了。
    • Runnable接口只有一个run()方法。
    • Thread类实现了Runnable接口。
    • 便于多个线程共享资源；

  • 使用Runnbale实现代码： ```java public class RunnableTest{

    public static void main(String[] args){

    1.   System.out.println("主线程开始");
    2.   ThreadTestA test = new ThreadTestA();
    3.   //创建线程
    4.   Thread t = new Thread(test);
    5.   //启动线程
    6.   t.start();
    8.   System.out.println("主线程结束");

    } }

/**

  • 继承Runnable 重写run方法 */ class ThreadTestA implements Runnable {

    @Override public void run() {

    1.  for (int i = 0; i < 10; i++) {
    2.      System.out.println(i);
    3.  }

    } } ``` 运行结果：
    image.png

怎么防止前端重复提交

  • 前端生成唯一ID，后端通过唯一索引（这个用的比较多）
  • 前端控制：
    • 提交按钮后屏蔽提交按钮（js控制）
  • 后端控制：
    • 利用Session防止表单重复提交

SpringAOP的原理 **

spring实现AOP的思路很简单:

  • 通过预编译方式和运行期动态代理方式实现程序功能的统一维护的一种技术
  • 主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等等
  • AOP实现方式
    • 预编译：AspectJ
    • 运行期动态代理（JDK动态代理、CGLib动态代理）：SpringAOP、JbossAOP
  • AOP几个相关概念

面向切面的核心思想就是，让核心的业务逻辑代码，不需要去管理一些通用的逻辑，比如说事务，安全等这方面的共同逻辑,解耦业务逻辑和通用逻辑

批量往mysql导入1000万数据有什么方法 ？

  1. show global variables like 'max_allowed_packet' ;

image.png
减少IO次数 —> SQL写法优化 —> 合理设置批量大小 —> 尽量顺序插入

  • 一条SQL语句插入多条数据；
  • 在事物中进行插入处理，切记不要一条数据提交一下，要分批处理；
  • 数据有序插入，是为了减少索引的维护压力；

例如：

  1. 批量插入：

    1. <insert id="insertPrBulkDetails">
    2.      <if test="@org.apache.commons.collections.CollectionUtils@isNotEmpty(details)">
    3.          INSERT INTO `t_eshop_pr_bulk_detail`
    4.           (
    5.          `id`,
    6.          `fk_pr_id`,
    7.          `pms_material_code`,
    8.          `pms_material_name`,
    9.          `type_code`,
    10.          `type_name`,
    11.          `sub_type_code`,
    12.          `sub_type_name`,
    13.          `min_type_code`
    14.          )
    15.          VALUES
    16.          <foreach collection="details" item="item"  separator="," >
    17.              (
    18.              #{item.id},
    19.              #{item.fkPrId},
    20.              #{item.pmsMaterialCode},
    21.              #{item.pmsMaterialName},
    22.              #{item.typeCode},
    23.              #{item.typeName},
    24.              #{item.subTypeCode},
    25.              #{item.subTypeName},
    26.              #{item.minTypeCode}
    27.               )
    28.          </foreach>
    29.      </if>
    30.  </insert>

  2. 事物插入： ```sql

START TRANSACTION;
INSERT INTO XXX表(gmt_create,gmt_modified,字段A,字段B,字段C) VALUES (NOW(),NOW(),#vals[].字段A#,#字段B[].字段C#), (NOW(),NOW(),#vals[].字段A#,#字段B[].字段C#), (NOW(),NOW(),#vals[].字段A#,#字段B[].字段C#); INSERT INTO XXX表(gmt_create,gmt_modified,字段A,字段B,字段C) VALUES (NOW(),NOW(),#vals[].字段A#,#字段B[].字段C#), (NOW(),NOW(),#vals[].字段A#,#字段B[].字段C#), (NOW(),NOW(),#vals[].字段A#,#字段B[].字段C#); COMMIT;

  2. ---
  4. <a name="6HjK7"></a>
  5. ## Array和排序算法 
  7. <a name="ZFhlO"></a>
  8. # 类
  9. <a name="m3CvV"></a>
  10. ## 深克隆/浅克隆
  11. <a name="2UJaH"></a>
  12. ## 序列化/反序列化
  13. <a name="mEuB5"></a>
  14. ## 枚举类
  15. <a name="VnhpO"></a>
  16. ## 抽象类
  18. <a name="7yTe6"></a>
  19. # 集合
  20. <a name="LSOTJ"></a>
  21. ## Vector/ArrayList
  22. <a name="ZCRSV"></a>
  23. ## 双向链表
  24. <a name="PszO4"></a>
  25. ## HashMap
  26. <a name="ioCzj"></a>
  27. ## 数据结构
  28. <a name="k8qFJ"></a>
  29. ### 常见的数据结构：
  31. - 数组（查询效率高）
  32. - 栈（last in first out）: 典型的撤回操作，括号匹配
  33. - 队列（first in first out）：
  34. - 链表（插入快）
  35.    - 单向链表：
  36.    - 双向链表：
  37. - 图（graph）
  38.    - 遍历图的两种算法：
  39.       - 广度优先搜索
  40.       - 深度优先搜索
  41. - 树（Tree）：被广泛应用在人工智能和一些复杂的算法当中，用来提供搞笑的存储结构；
  42.    - N 叉树
  43.    - 平衡树
  44.    - 二叉树
  45.    - 二叉查找树
  46.    - 平衡二叉树
  47.    - 红黑树
  48. - 前缀树：
  50. 与树类似，用于处理字符串相关的问题是非常高效。他可以实现快速检索，常用语字段中的单词查找，搜索引擎的自动补全等。
  52. - 哈希表：
  54. 将某个对象变换成唯一标识符，改标识符通常用一个短的随机字母和数字组成的字符串来代表。hash哈希可以用来实现各种数据结构，其中最常用的就是哈希表（hash table）
  56.    - hash table通常由数组实现。
  57.       - 指标： 哈希函数、 哈希表的大小、 哈希冲突的处理方式
  58. <a name="x1Kl3"></a>
  59. ### 常见的相关面试题：
  61. 1. 数组：
  62.    1. 查找数组中第二小的元素：
  63. ```java
  64. public class SecondSmallest {
  65.     static Integer get2Smallest(int[] arr){
  66.         //int[] arr = {5,6,41,5,3,1}
  68.         //定义最小跟第二小变量
  69.         int first, second, arr_size= arr.length;
  71.         if (arr_size < 2)
  72.         {
  73.             System.out.println(" Invalid Input ");
  74.             return null;
  75.         }
  77.         //定义第一跟第二是最大的数
  78.         first = second = Integer.MAX_VALUE;
  79.         for (int i = 0; i < arr.length; i++) {
  81.             if(arr[i] < first){
  82.                 second = first;
  83.                 first = arr[i];
  84.             }
  86.             else if(arr[i] > first && arr[i] < second) {
  87.                 second = arr[i];
  88.             }
  89.         }
  91.         //如果第二小等于 int 的最大值，报错
  92.         if(second == Integer.MAX_VALUE){
  93.             System.out.println("There is no second");
  94.             return null;
  95.         }
  97.         return second;
  99.     }
  101.     public static void main(String[] args) {
  102.         int[] arr = {5,6,41,5,3,1};
  103.         Integer secondSmallest = get2Smallest(arr);
  105.         System.out.println("The SecondSmallest is :"+ secondSmallest);
  106.     }
  107. }

泛型

迭代器

阻塞队列

延迟队列

常用算法

冒泡排序法

快速排序

二分法

选择排序

插入排序

归并排序

堆排序

基数排序

常用设计模式

单例模式

工厂模式

抽象模式

原型模式

观察者模式

代理模式

迭代器模式

适配器模式

线程安全

死锁*

JUC

CAS/ ABA

Lock*

synchronized *

乐观锁、公平锁、独占锁、自旋锁

ThreadLocal

线程池

推荐线程池 ThreadPoolExecutor

固定线程池 FixedThreadPool

缓存线程池 CachedThreadPool

单线程池 SingleThreadExecutor

定时线程池 ScheduledThreadPool

JDK8 新增线程池 WorkStealingPool

JVM *

内存结构

垃圾算法

虚拟机分类

运行机制

配置调优

反射跟动态代理

反射

JDK动态代理

CGLIB 代理

热门框架

Spring

SpringMVC

MyBatis

SpringBoot

数据库

MySQL

Redis