汇总大厂-校招/社招 Java面试题

如需下载整套资料。链接放在最后了啦！

String对象中的replace和replaceAll的区别？

replace方法：支持字符和字符串的替换。

public String replace(char oldChar, char newChar)
 
public String replace(CharSequence target, CharSequence replacement)

replaceAll方法：基于正则表达式的字符串替换。

public String replaceAll(String regex, String replacement)

测试代码：

String str = "Hello Java. Java is a language.";
System.out.println(str.replace("Java.", "c++"));//打印 Hello c++ Java is a language.
System.out.println(str.replaceAll("Java.", "c++"));//打印 Hello c++ c++is a language.

打印结果：

Hello c++ Java is a language.
Hello c++ c++is a language.

​​​​​​​

Java接口方法的修饰符可以是()

答案：C

分析：

• 接口中的访问权限修饰符只能是 public 或 default
• 接口中的方法必须要实现类实现，所以不能使用 final
• 接口中所有的方法默认都是 abstract，通常 abstract 省略不写

什么是Linux?

• Linux 是一种基于 UNIX 的操作系统，最初是由 Linus Torvalds 引入的
• 它基于 Linux 内核，可以运行在由 Intel，MIPS，HP，IBM，SPARC 和 Motorola 制造的不同硬件平台上
• Linux 另一个受欢迎的元素是它的吉祥物，一个名叫 Tux 的企鹅形象

java中操作字符串都有哪些类？它们之间有什么区别？

Java 中，常用的对字符串操作的类有 String、StringBuffer、StringBuilder

• String : final 修饰，String 类的方法都是返回 new String。即对 String 对象的任何改变都不影响到原对象，对字符串的修改操作都会生成新的对象。
• StringBuffer : 对字符串的操作的方法都加了synchronized，保证线程安全。
• StringBuilder : 不保证线程安全，在方法体内需要进行字符串的修改操作，可以 new StringBuilder 对象，调用 StringBuilder 对象的 append()、replace()、delete() 等方法修改字符串。

Java 程序中怎么保证多线程的运行安全？

线程的安全性问题体现在：

• 原子性：一个或者多个操作在 CPU 执行的过程中不被中断的特性
• 可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到
• 有序性：程序执行的顺序按照代码的先后顺序执行

导致原因：

• 缓存导致的可见性问题
• 线程切换带来的原子性问题
• 编译优化带来的有序性问题

解决办法：

• JDK Atomic开头的原子类、synchronized、LOCK，可以解决原子性问题
• synchronized、volatile、LOCK，可以解决可见性问题
• Happens-Before 规则可以解决有序性问题

如何防止表单重复提交？

网络延迟时重复点击提交按钮，会发生重复提交表单的问题。

解决办法:

• 数据库主键唯一
• 提交成功后页面重定向
• 按钮提交后隐藏或不可再点击
• 后台生成页面 token，页面表单提交携带 token，后台进行校验

为什么Redis所有数据放到内存中？

• Redis 为了达到最快的读写速度将数据都读到内存中，并通过异步的方式将数据写入磁盘，所以 Redis 具有高速读写和数据持久化的特征
• 如果程序直接与磁盘交互，磁盘 IO 速度会严重影响 Redis 的性能
• 内存的硬件成本降低，使得 Redis 更受欢迎

continue语句的作用

• 结束本次循环，循环体后续的语句不执行
• 继续进行循环条件的判断，进行下一次循环体语句的执行

List、Set、Sorted Set最多能存放多少元素？

官方 FAQ 上说明，理论上 List、Set、Sorted Set 可以放 2 的 32 次方个元素

谈谈双亲委派模型

Parents Delegation Model，这里的 Parents 翻译成双亲有点不妥，类加载向上传递的过程中只有单亲；parents 更多的是多级向上的意思。

除了顶层的启动类加载器，其他的类加载器在加载之前，都会委派给它的父加载器进行加载，一层层向上传递，直到所有父类加载器都无法加载，自己才会加载该类。

双亲委派模型，更好地解决了各个类加载器协作时基础类的一致性问题，避免类的重复加载；防止核心API库被随意篡改。

JDK 9 之前

• 启动类加载器（Bootstrp ClassLoader），加载 /lib/rt.jar、-Xbootclasspath
• 扩展类加载器（Extension ClassLoader）sun.misc.Launcher$ExtClassLoader，加载 /lib/ext、java.ext.dirs
• 应用程序类加载器（Application ClassLoader，sun.misc.Launcher$AppClassLoader），加载 CLASSPTH、-classpath、-cp、Manifest
• 自定义类加载器

JDK 9 开始 Extension ClassLoader 被 Platform ClassLoader 取代，启动类加载器、平台类加载器、应用程序类加载器全都继承于 jdk.internal.loader.BuiltinClassLoader

类加载代码逻辑

protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
  // 首先，检查请求的类是否已经被加载过了
  Class c = findLoadedClass(name);
  if (c == null) {
    try {
      if (parent != null) {
        c = parent.loadClass(name, false);
      } else {
        c = findBootstrapClassOrNull(name);
      }
    } catch (ClassNotFoundException e) {
      // 如果父类加载器抛出ClassNotFoundException
      // 说明父类加载器无法完成加载请求
    }
    if (c == null) {
      // 在父类加载器无法加载时
      // 再调用本身的findClass方法来进行类加载
      c = findClass(name);
    }
  }
  if (resolve) {
    resolveClass(c);
  }
  return c;
}

Dubbo的安全调用

• Dubbo 和 Zookeeper 基本都是部署在内网，不对外网开放
• Zookeeper 的注册可以添加用户权限认证
• Dubbo 通过 Token 令牌防止用户绕过注册中心直连
• 在注册中心上管理授权
• 增加对接口参数校验
• 提供IP、服务黑白名单，来控制服务所允许的调用方

Java中有几种基本数据类型？它们分别占多大字节？

基本数据类型

• byte：1个字节，8位
• short：2个字节，16位
• int：4个字节，32位
• long：8个字节，64位
• float：4个字节，32位
• double：8个字节，64位
• boolean：官方文档未明确定义，依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1位，但是实际中会考虑计算机高效存储因素
• char：2个字节，16位

补充说明：字节的英文是 byte，位的英文是 bit

详细说明可以参考：

• https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

可重入锁与不可重入锁之间的区别与性能差异？

可重入锁

指在同一个线程在外层方法获取锁的时候，进入内层方法会自动获取锁。

为了避免死锁的发生，JDK 中基本都是可重入锁。

下面我们来测试一下 synchronized 和 java.util.concurrent.lock.ReentrantLock 锁的可重入性

• 测试 synchronized 加锁 可重入性

  package constxiong.concurrency.a019;

  /**

  • 测试 synchronized 加锁 可重入性

  • @author ConstXiong

  • @date 2019-09-20 15:55:27
    */
    public class TestSynchronizedReentrant {

    public static void main(String[] args) {
    new Thread(new SynchronizedReentrant()).start();
    }

  }

  class SynchronizedReentrant implements Runnable {

  private final Object obj = new Object();
  
  /**
   * 方法1，调用方法2
   */
  public void method1() {
      synchronized (obj) {
          System.out.println(Thread.currentThread().getName() + " method1()");
          method2();
      }
  }
  
  /**
   * 方法2，打印前获取 obj 锁
   * 如果同一线程，锁不可重入的话，method2 需要等待 method1 释放 obj 锁
   */
  public void method2() {
      synchronized (obj) {
          System.out.println(Thread.currentThread().getName() + " method2()");
      }
  }
  
  @Override
  public void run() {
      //线程启动 执行方法1
      method1();
  }
  

  }

打印结果：

Thread-0 method1()
Thread-0 method2()

• 测试 ReentrantLock 的可重入性

  package constxiong.concurrency.a019;

  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;

  /**

  • 测试 ReentrantLock 的可重入性

  • @author ConstXiong

  • @date 2019-09-20 16:24:52
    */
    public class TestLockReentrant {

    public static void main(String[] args) {
    new Thread(new LockReentrant()).start();
    }

  }

  class LockReentrant implements Runnable {

  private final Lock lock = new ReentrantLock();
  
  /**
   * 方法1，调用方法2
   */
  public void method1() {
      lock.lock();
      try {
          System.out.println(Thread.currentThread().getName() + " method1()");
          method2();
      } finally {
          lock.unlock();
      }
  }
  
  /**
   * 方法2，打印前获取 obj 锁
   * 如果同一线程，锁不可重入的话，method2 需要等待 method1 释放 obj 锁
   */
  public void method2() {
      lock.lock();
      try {
          System.out.println(Thread.currentThread().getName() + " method2()");
      } finally {
          lock.unlock();
      }
  }
  
  @Override
  public void run() {
      //线程启动 执行方法1
      method1();
  }
  

  }

打印结果：

Thread-0 method1()
Thread-0 method2()

测试不可重入锁

我在 JDK 中没找到不可重入锁，所以考虑自己实现一下。两种方式：通过 synchronized wait notify 实现；通过 CAS + 自旋方式实现

1） synchronized wait notify 方式实现

package constxiong.concurrency.a019;


/**
 * 不可重入锁，通过 synchronized wait notify 实现
 * @author ConstXiong
 * @date 2019-09-20 16:53:34
 */
public class NonReentrantLockByWait {

    //是否被锁
    private volatile boolean locked = false;
    
    //加锁
    public synchronized void lock() {
        //当某个线程获取锁成功，其他线程进入等待状态
        while (locked) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //加锁成功，locked 设置为 true
        locked = true;
    }
    
    //释放锁
    public synchronized void unlock() {
        locked = false;
        notify();
    }

}

2） 通过 CAS + 自旋 方式实现

package constxiong.concurrency.a019;

import java.util.concurrent.atomic.AtomicReference;


/**
 * 不可重入锁，通过 CAS + 自旋 实现
 * @author ConstXiong
 * @date 2019-09-20 16:53:34
 */
public class NonReentrantLockByCAS {
    
    private AtomicReference lockedThread = new AtomicReference();

    public void lock() {
        Thread t = Thread.currentThread();
        //当 lockedThread 持有引用变量为 null 时，设置 lockedThread 持有引用为 当前线程变量
        while (!lockedThread.compareAndSet(null, t)) {
            //自旋，空循环，等到锁被释放
        }
    }
    
    public void unlock() {
        //如果是本线程锁定的，可以成功释放锁
        lockedThread.compareAndSet(Thread.currentThread(), null);
    }
}

测试类

package constxiong.concurrency.a019;

/**
 * 测试不可重入锁
 * @author ConstXiong
 * @date 2019-09-20 18:08:55
 */
public class TestLockNonReentrant{

    public static void main(String[] args) {
        new Thread(new LockNonReentrant()).start();
    }

}


class LockNonReentrant implements Runnable {
    
//    private final NonReentrantLockByWait lock = new NonReentrantLockByWait();
    private final NonReentrantLockByCAS lock = new NonReentrantLockByCAS();
    
    /**
     * 方法1，调用方法2
     */
    public void method1() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " method1()");
            method2();
        } finally {
            lock.unlock();
        }
    }
    
    /**
     * 方法2，打印前获取 obj 锁
     * 如果同一线程，锁不可重入的话，method2 需要等待 method1 释放 obj 锁
     */
    public void method2() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " method2()");
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        //线程启动 执行方法1
        method1();
    }
}

测试结果，都是在 method1，调用 method2 的时候，导致了死锁，线程一直等待或者自旋下去。

参考：

• http://ifeve.com/java_lock_see4/

输入流和输出流的区别

• 输入输出的方向是针对程序而言，向程序中读入数据，就是输入流；从程序中向外写出数据，就是输出流
• 从磁盘、网络、键盘读到内存，就是输入流，用 InputStream 或 Reader
• 写到磁盘、网络、屏幕，都是输出流，用 OuputStream 或 Writer

Javascript正则表达式使用方式有哪些？

一、字面量的形式

var expression = /pattern/flags;
flags参数
i：忽略大小写
g：全局匹配
gi：全局匹配+忽略大小写

二、使用 RegExp 对象

var reg = new RegExp(expression, destStr);
RegExp.$1 是 RegExp 的一个属性,指的是与正则表达式匹配的第一个子匹配(以括号为标志)字符串。以此类推，RegExp.2, RegExp.3, ..RegExp.$99总共可以有99个匹配

• test()方法：测试正则是否匹配字符串

  正则.test(字符串)
  如：
  /^\d/.test(‘1a’)
  new RegExp(“1a”, ‘i’).test(‘1a1a’)

• search()方法：在字符串搜索符合正则的内容，搜索到就返回出现的位置，搜索失败就返回 -1

  字符串.search(正则)
  如：
  ‘1a1a’.search(/^\d/); //返回0

• match()方法：

  stringObject.match(searchvalue)
  stringObject.match(regexp)
  如：
  ‘1a1a’.match(/^\d/); //返回[“1”, index: 0, input: “1a1a”, groups: undefined]

• replace()方法：

  replace([RegExp|String],[String|Function])
  如：
  ‘1a1a’.replace(/^\d/, 2); //返回"2a1a"

• exec()方法：捕获组，仅 RegExp 对象可用

  如：
  ar r = new RegExp(“(1a)”, ‘i’); r.exec(‘1a1a’); RegExp.$1;

如何避免sql注入？

1、概念

SQL 注入（SQL Injection），是 Web 开发中最常见的一种安全漏洞。

可以用它来从数据库获取敏感信息、利用数据库的特性执行添加用户、导出文件等一系列恶意操作，甚至有可能获取数据库乃至系统用户最高权限。

**2、造成 SQL 注入的原因 **

程序没有有效过滤用户的输入，使攻击者成功的向服务器提交恶意的 SQL 脚本，程序在接收后错误的将攻击者的输入作为 SQL 语句的一部分执行，导致原始的查询逻辑被改变，执行了攻击者精心构造的恶意 SQL 语句。

如 从用户表根据用户名 ConstXiong 和密码 123 查用户信息

select * from user where username = 'ConstXiong' and password = '123'

恶意修改用户名参数 ConstXiong -> ConstXiong’ or 1=1 –

select * from user where username = 'ConstXiong' or 1=1 --' and password = '123'

![Image 1][]![Image 1][]

SQL 中 – 是注释标记，如果上面这个 SQL 被执行，就可以让攻击者在不知道任何用户名和密码的情况下成功登录。

3、预防 SQL 注入攻击的方法

• 严格限制 Web 应用的数据库的操作权限，给连接数据库的用户提供满足需要的最低权限，最大限度的减少注入攻击对数据库的危害
• 校验参数的数据格式是否合法（可以使用正则或特殊字符的判断）
• 对进入数据库的特殊字符进行转义处理，或编码转换
• 预编译 SQL（Java 中使用 PreparedStatement），参数化查询方式，避免 SQL 拼接
• 发布前，利用工具进行 SQL 注入检测
• 报错信息不要包含 SQL 信息输出到 Web 页面

[Image 1]:

什么是触发器，MySQL都有哪些触发器？

触发器是指一段代码，当触发某个事件时，自动执行这些代码

MySQL 数据库中有六种触发器：

• Before Insert
• After Insert
• Before Update
• After Update
• Before Delete
• After Delete

使用场景：

• 可以通过数据库中的相关表实现级联更改
• 实时监控表中字段的更改做出相应处理

注意：滥用会造成数据库及应用程序的维护困难

并发编程的缺点？

1. Java 中的线程对应是操作系统级别的线程，线程数量控制不好，频繁的创建、销毁线程和线程间的切换，比较消耗内存和时间。
2. 容易带来线程安全问题。如线程的可见性、有序性、原子性问题，会导致程序出现的结果与预期结果不一致。
3. 多线程容易造成死锁、活锁、线程饥饿等问题。此类问题往往只能通过手动停止线程、甚至是进程才能解决，影响严重。
4. 对编程人员的技术要求较高，编写出正确的并发程序并不容易。
5. 并发程序易出问题，且难调试和排查；问题常常诡异地出现，又诡异地消失。

jsp的4种作用域？

• page (当前页面作用域)：相当于 Java 关键字中 this。在这个作用域中存放的属性值，只能在当前页面中取出。对应 PageContext 类
• request (请求作用域)：范围是从请求创建到请求消亡这段时间，一个请求可以涉及的多个页面。jsp:forward 和 jsp:include 跳转到其他页面，也在作用域范围。对应 ServletRequest 类
• session (会话作用域)：范围是一段客户端和服务端持续连接的时间，用户在会话有效期内多次请求所涉及的页面。session 会话器，服务端为第一次建立连接的客户端分配一段有效期内的属性内存空间。对应 HttpSession 类
• application (全局作用域)：范围是服务端Web应用启动到停止，整个Web应用中所有请求所涉及的页面。当服务器开启时，会创建一个公共内存区域，任何客户端都可以在这个公共内存区域存取值。对应 ServletContext 类

什么是 happens-before 原则？

Java 中 happens-before 原则，是在 JSR-133 中提出的。

原文摘要：

• Each action in a thread happens-before every subsequent action in that thread.
• An unlock on a monitor happens-before every subsequent lock on that monitor.
• A write to a volatile field happens-before every subsequent read of that volatile.
• A call to start() on a thread happens-before any actions in the started thread.
• All actions in a thread happen-before any other thread successfully returns from a join() on that thread.
• If an action a happens-before an action b, and b happens before an action c, then a happensbefore c.
• the completion of an object’s constructor happens-before the execution of its finalize method (in the formal sense of happens-before).

翻译过来加上自己的理解就是：

• 程序次序规则：在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。(这里涉及到 CPU 指令重排，所以需要加入内存屏障保证有序性)
• 管程锁定规则：对一个锁的解锁操作，先行发生于后续对这个锁的加锁操作。这里必须强调的是同一个锁。
• volatile 变量规则：对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
• 线程启动规则：Thread 对象的 start() 方法先行发生于此线程的每一个动作。
• 线程 join() 规则：被调用 join() 方法的线程的所有操作先行发生于 join() 的返回。
• 传递性规则：操作 a 先发生于操作 b，操作 b 先发生于操作 c，则操作 a 先发生于操作 c。
• 对象终结规则：一个对象的初始化完成(构造函数执行结束)先行发生于它的 finalize() 方法。

MyBatis 中如何配置连接中断或执行超时？

Mybatis 的 XML 配置中，在 节点中添加子节点 ，name=defaultStatementTimeout，设置等待数据库响应的超时时间。

介绍一下Redis

Redis 是一款使用 C 语言编写的高性能 key-value 数据库，开源免费，遵守 BSD 协议。

特点：

• 性能极高，能到 100000 次/s 读写速度
• 支持数据的持久化，对数据的更新采用Copy-on-write技术，可以异步地保存到磁盘上
• 丰富的数据类型，String(字符串)、List(列表)、Hash(字典)、Set(集合)、Sorted Set(有序集合)
• 原子性：Redis 的所有操作都是原子性的，多个操作通过 MULTI 和 EXEC 指令支持事务
• 丰富的特性：key 过期、publish/subscribe、notify
• 支持数据的备份，快速的主从复制
• 节点集群，很容易将数据分布到多个Redis实例中

十进制100转换成八进制是多少？

100 = 1*(8*8) + 4*(8) + 4*(1)

八进制：144

Java中八进制数必须以0开头，0144

MyBatis 是如何将 sql 执行结果转换为目标对象并返回的？有哪些映射形式？

• 方式一、 标签使用 resultType 参数，传递 Java 类，sql 中 select 的字段名保持与 Java 类属性名称一致

• 方式二、使用 标签，定义数据库列名和对象属性名之间的映射关系

• 方式三、使用注解 select 的字段名保持与接口方法返回的 Java 类或集合的元素类的属性名称一致

  方式一
  
  select * from user where id = #{id}
  

  方式二
  
  select * from user where id = #{id}
  
  
  
  
  

  方式三
  @Select(“select * from user”)
  List selectAllUsers();

根据解析得到 ResultMap 结合 sql 执行结果，通过反射创建对象，根据映射关系反射填充返回对象的属性

源码体现在 DefaultResultSetHandler 的 handleResultSets 方法

public List