个人技术分享网站

Java面试题大汇总,2021面试题及答案汇总

关于Java面试题2021 Java面试题大汇总系列基本收集整理完成了,最新常Java面试题汇总(含答案解析)发现网上很多Java面试题都没有答案,所有Java面试题目都是经过精心挑选的,很基础又考验求职者的基本功,应该说被面试到的几率很大。这里整理挑选出来2021年面试题供大家面试前拿来看一看,所有题目整理自网络,有一些错误和笔误,感谢读者的热心纠错,在声明中已经改正过来

其实,博主还整理了,更多大厂面试题,直接下载吧

下载链接:高清172份,累计 7701 页大厂面试题 PDF

1、什么是ORM?

对象关系映射(Object-Relational Mapping,简称ORM)是一种为了解决程序的面向对象模型与数据库的关系模型互不匹配问题的技术

2、乐观锁和悲观锁的理解及如何实现,有哪些实现方式?

悲观锁

总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。再比如Java里面的同步原语synchronized关键字的实现也是悲观锁。

乐观锁

顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提供的乐观锁。在Java中Java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

乐观锁的实现方式

1、 使用版本标识来确定读到的数据与提交时的数据是否一致。提交后修改版本标识,不一致时可以采取丢弃和再次尝试的策略。

2、 Java中的Compare and Swap即CAS ,当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是被告知这次竞争中失败,并可以再次尝试。 CAS 操作中包含三个操作数 —— 需要读写的内存位置(V)、进行比较的预期原值(A)和拟写入的新值(B)。如果内存位置V的值与预期原值A相匹配,那么处理器会自动将该位置值更新为新值B。否则处理器不做任何操作。

CAS缺点

1、 ABA问题

比如说一个线程one从内存位置V中取出A,这时候另一个线程two也从内存中取出A,并且two进行了一些操作变成了B,然后two又将V位置的数据变成A,这时候线程one进行CAS操作发现内存中仍然是A,然后one操作成功。尽管线程one的CAS操作成功,但可能存在潜藏的问题。从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。

2、 循环时间长开销大

对于资源竞争严重(线程冲突严重)的情况,CAS自旋的概率会比较大,从而浪费更多的CPU资源,效率低于synchronized。

3、 只能保证一个共享变量的原子操作

当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁。

3、如何在jsp页面上显示一些特定格式的数字或者日期

使用jstl标签库,使用numberformat或者dateformat标签

4、请说出与线程同步以及线程调度相关的方法。

1、 wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁;

2、 sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要处理InterruptedException异常;

3、 notify():唤醒一个处于等待状态的线程,当然在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且与优先级无关;

4、 notityAll():唤醒所有处于等待状态的线程,该方法并不是将对象的锁给所有线程,而是让它们竞争,只有获得锁的线程才能进入就绪状态;

提示:关于Java多线程和并发编程的问题,建议大家看我的另一篇文章《关于Java并发编程的总结和思考》

补充:Java 5通过Lock接口提供了显式的锁机制(explicit lock),增强了灵活性以及对线程的协调。Lock接口中定义了加锁(lock())和解锁(unlock())的方法,同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象;此外,Java 5还提供了信号量机制(semaphore),信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前,线程必须得到信号量的许可(调用Semaphore对象的acquire()方法);在完成对资源的访问后,线程必须向信号量归还许可(调用Semaphore对象的release()方法)。

下面的例子演示了100个线程同时向一个银行账户中存入1元钱,在没有使用同步机制和使用同步机制情况下的执行情况。

银行账户类:

/
 * 银行账户
 * @author 骆昊
 *
 */
public class Account {
    private double balance;     // 账户余额

    /
     * 存款
     * @param money 存入金额
     */
    public void deposit(double money) {
        double newBalance = balance + money;
        try {
            Thread.sleep(10);   // 模拟此业务需要一段处理时间
        }
        catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }

    /
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

存钱线程类:

/
 * 存钱线程
 * @author 骆昊
 *
 */
public class AddMoneyThread implements Runnable {
    private Account account;    // 存入账户
    private double money;       // 存入金额

    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }

    @Override
    public void run() {
        account.deposit(money);
    }

}

测试类:

import Java.util.concurrent.ExecutorService;
import Java.util.concurrent.Executors;

public class Test01 {

    public static void main(String[] args) {
        Account account = new Account();
        ExecutorService service = Executors.newFixedThreadPool(100);

        for(int i = 1; i <= 100; i++) {
            service.execute(new AddMoneyThread(account, 1));
        }

        service.shutdown();

        while(!service.isTerminated()) {}

        System.out.println("账户余额: " + account.getBalance());
    }
}

在没有同步的情况下,执行结果通常是显示账户余额在10元以下,出现这种状况的原因是,当一个线程A试图存入1元的时候,另外一个线程B也能够进入存款的方法中,线程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额,因此也是在原来的余额0上面做了加1元的操作,同理线程C也会做类似的事情,所以最后100个线程执行结束时,本来期望账户余额为100元,但实际得到的通常在10元以下(很可能是1元哦)。解决这个问题的办法就是同步,当一个线程对银行账户存钱时,需要将此账户锁定,待其操作完成后才允许其他的线程进行操作,代码有如下几种调整方案:

在银行账户的存款(deposit)方法上同步(synchronized)关键字

/
 * 银行账户
 * @author 骆昊
 *
 */
public class Account {
    private double balance;     // 账户余额

    /
     * 存款
     * @param money 存入金额
     */
    public synchronized void deposit(double money) {
        double newBalance = balance + money;
        try {
            Thread.sleep(10);   // 模拟此业务需要一段处理时间
        }
        catch(InterruptedException ex) {
            ex.printStackTrace();
        }
        balance = newBalance;
    }

    /
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

在线程调用存款方法时对银行账户进行同步

/
 * 存钱线程
 * @author 骆昊
 *
 */
public class AddMoneyThread implements Runnable {
    private Account account;    // 存入账户
    private double money;       // 存入金额

    public AddMoneyThread(Account account, double money) {
        this.account = account;
        this.money = money;
    }

    @Override
    public void run() {
        synchronized (account) {
            account.deposit(money); 
        }
    }

}

通过Java 5显示的锁机制,为每个银行账户创建一个锁对象,在存款操作进行加锁和解锁的操作

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

/
 * 银行账户
 * 
 * @author 骆昊
 *
 */
public class Account {
    private Lock accountLock = new ReentrantLock();
    private double balance; // 账户余额

    /
     * 存款
     * 
     * @param money
     *            存入金额
     */
    public void deposit(double money) {
        accountLock.lock();
        try {
            double newBalance = balance + money;
            try {
                Thread.sleep(10); // 模拟此业务需要一段处理时间
            }
            catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            balance = newBalance;
        }
        finally {
            accountLock.unlock();
        }
    }

    /
     * 获得账户余额
     */
    public double getBalance() {
        return balance;
    }
}

按照上述三种方式对代码进行修改后,重写执行测试代码Test01,将看到最终的账户余额为100元。当然也可以使用Semaphore或CountdownLatch来实现同步。

5、堆

JVM内存管理最大的一块,对被线程共享,目的是存放对象的实例,几乎所欲的对象实例都会放在这里,当堆没有可用空间时,会抛出OOM异常.根据对象的存活周期不同,JVM把对象进行分代管理,由垃圾回收器进行垃圾的回收管理

6、你所了解的数据源技术有那些?使用数据源有什么好处?

Dbcp,c3p0等,用的最多还是c3p0,因为c3p0比dbcp更加稳定,安全;通过配置文件的形式来维护数据库信息,而不是通过硬编码。当连接的数据库信息发生改变时,不需要再更改程序代码就实现了数据库信息的更新。

7、Java对象创建过程

1、 JVM遇到一条新建对象的指令时首先去检查这个指令的参数是否能在常量池中定义到一个类的符号引用。然后加载这个类(类加载过程在后边讲)

2、 为对象分配内存。一种办法“指针碰撞”、一种办法“空闲列表”,最终常用的办法“本地线程缓冲分配(TLAB)”

3、 将除对象头外的对象内存空间初始化为0

4、 对对象头进行必要设置

8、为什么HashTable是线程安全的?

因为HasTable的内部方法都被synchronized修饰了,所以是线程安全的。其他的都和HashMap一样

1、 HashMap添加方法的源码

2、 HashTable添加方法的源码

9、常用io类有那些?

**File

FileInputSteam,FileOutputStream

BufferInputStream,BufferedOutputSream

PrintWrite

FileReader,FileWriter

BufferReader,BufferedWriter

ObjectInputStream,ObjectOutputSream**

10、线程的调度策略

线程调度器选择优先级最高的线程运行,但是,如果发生以下情况,就会终止线程的运行:

1、 线程体中调用了yield方法让出了对cpu的占用权利

2、 线程体中调用了sleep方法使线程进入睡眠状态

3、 线程由于IO操作受到阻塞

4、 另外一个更高优先级线程出现

5)在支持时间片的系统中,该线程的时间片用完

11、为什么你应该在循环中检查等待条件?

12、什么是代理模式

13、用哪两种方式来实现集合的排序?

14、并发编程有什么缺点

15、两个对象值相同(x.equals(y) true),但却可有不同的hash code,这句话对不对?

16、线程的状态流转图

17、Java 线程数过多会造成什么异常?

18、两个对象的 hashCode()相同,则 equals()也一定为 true,对吗?

19、什么是线程池?

20、线程池有什么优点?

21、线程的状态

22、JRE、JDK、JVM 及 JIT 之间有什么不同?

23、HashMap中的key,可以是普通对象么?需要什么注意的地方?

24、Java反射创建对象效率高还是通过new创建对象的效率高?

25、Spring支持的事务管理类型有哪些?你在项目中使用哪种方式?

26、什么是多线程的上下文切换

27、CMS都有哪些问题?

28、垃圾回收的优点和原理。说说2种回收机制

29、方法区溢出的原因?

30、Sql中delete与truncate的区别

31、CopyOnWriteArrayList 是什么?

32、Java中Synchronized关键字的使用?

33、Error和Exception有什么区别?

34、构造方法能不能显式调用?

35、什么是重排序

36、策略模式的优点和缺点

37、JVM中一次完整的GC流程是怎样的,对象如何晋升到老年代?

38、设计模式的六大原则

39、阐述JDBC操作数据库的步骤。

40、判断两个对象是否相同,能使用equlas比较吗?

41、如何将字符串反转?

42、如何在两个线程间共享数据?

43、分区收集算法

44、String str=”aaa”,与String str=new String(“aaa”)一样吗?

全部答案,整理好了,直接下载吧

下载链接:高清172份,累计 7701 页大厂面试题 PDF

赞(1) 打赏
未经允许不得转载:搜云库 » Java面试题大汇总,2021面试题及答案汇总

一个专注于Java技术系列文章的技术分享网站

联系我们联系我们

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏