精华内容
下载资源
问答
  • Java中级面试答案(120道Java中级面试大汇总)
    千次阅读
    2021-11-08 15:20:14

    Java中级面试题及答案【最新版及答案,干货!!!这是一个中级Java面试系列题中的第一部分。这一部分论述了可变参数,断言,垃圾回收,初始化器,令牌化,日期,日历等等Java核心问题。

    Java中级面试永远是程序员迈向成功的第一个门槛,想要面试成功,各种面试题的洗礼是必不可少的,下面就来看看小编精心整理的一些java高级工程师面试题及答案吧。

    如果不背 Java面试题的答案,肯定面试会挂!

    这套Java面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的

    1、线程与进程的区别

    进程是系统进行资源分配和调度的一个独立单位,线程是CPU调度和分派的基本单位

    进程和线程的关系:

    1、 一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程。

    2、 资源分配给进程,同一进程的所有线程共享该进程的所有资源。

    3、 线程在执行过程中,需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

    4、 线程是指进程内的一个执行单元,也是进程内的可调度实体。

    线程与进程的区别:

    1、 调度:线程作为调度和分配的基本单位,进程作为拥有资源的基本单位。

    2、 并发性:不仅进程之间可以并发执行,同一个进程的多个线程之间也可以并发执行。

    3、 拥有资源:进程是拥有资源的一个独立单位,线程不拥有系统资源,但可以访问隶属于进程的资源。

    4、 系统开销:在创建或撤销进程的时候,由于系统都要为之分配和回收资源,导致系统的明显大于创建或撤销线程时的开销。但进程有独立的地址空间,进程崩溃后,在保护模式下不会对其他的进程产生影响,而线程只是一个进程中的不同的执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但是在进程切换时,耗费的资源较大,效率要差些。

    2、什么是策略模式

    定义了一系列的算法 或 逻辑 或 相同意义的操作,并将每一个算法、逻辑、操作封装起来,而且使它们还可以相互替换。(其实策略模式Java中用的非常非常广泛)

    我觉得主要是为了 简化 if...else 所带来的复杂和难以维护。

    3、什么是游标?

    游标是sql查询结果集的一个指针,与select语句相关联。

    游标关键字是cursor,主要包含两个部分:游标结果集和游标位置。

    1、 游标结果集:执行select语句后的查询结果

    2、 游标位置:一个指向游标结果集内某条记录的指针。

    游标主要有两个状态:打开和关闭。

    1、 只有当游标处于打开状态时,才能够操作结果集中的数据

    2、 当游标关闭后,查询结果集就不存在了

    4、单例模式了解吗?给我解释一下双重检验锁方式实现单例模式!”

    双重校验锁实现对象单例(线程安全)

    说明:

    双锁机制的出现是为了解决前面同步问题和性能问题,看下面的代码,简单分析下确实是解决了多线程并行进来不会出现重复new对象,而且也实现了懒加载

    public class Singleton { private volatile static Singleton uniqueInstance; private Singleton() { } public static Singleton getUniqueInstance() { //先判断对象是否已经实例过,没有实例化过才进入加锁代码 if (uniqueInstance == null) { //类对象加锁 synchronized (Singleton.class) { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } } } return uniqueInstance; } }

    另外,需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。

    uniqueInstance 采用 volatile 关键字修饰也是很有必要的, uniqueInstance = new Singleton(); 这段代码其实是分为三步执行:

    1、 为 uniqueInstance 分配内存空间

    2、 初始化 uniqueInstance

    3、 将 uniqueInstance 指向分配的内存地址

    但是由于 JVM 具有指令重排的特性,执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题,但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如,线程 T1 执行了 1 和 3,此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空,因此返回 uniqueInstance,但此时 uniqueInstance 还未被初始化。

    使用 volatile 可以禁止 JVM 的指令重排,保证在多线程环境下也能正常运行。

    5、怎么获取 Java 程序使用的内存?堆使用的百分比?

    可以通过 java.lang.Runtime 类中与内存相关方法来获取剩余的内存,总内存及最大堆内存。通过这些方法你也可以获取到堆使用的百分比及堆内存的剩余空间。Runtime.freeMemory() 方法返回剩余空间的字节数,Runtime.totalMemory()方法总内存的字节数,Runtime.maxMemory() 返回最大内存的字节数。

    6、在java中守护线程和本地线程区别?

    java中的线程分为两种:守护线程(Daemon)和用户线程(User)。

    任何线程都可以设置为守护线程和用户线程,通过方法Thread.setDaemon(bool on);true则把该线程设置为守护线程,反之则为用户线程。Thread.setDaemon()必须在Thread.start()之前调用,否则运行时会抛出异常。

    两者的区别

    唯一的区别是判断虚拟机(JVM)何时离开,Daemon是为其他线程提供服务,如果全部的User Thread已经撤离,Daemon 没有可服务的线程,JVM撤离。也可以理解为守护线程是JVM自动创建的线程(但不一定),用户线程是程序创建的线程;比如JVM的垃圾回收线程是一个守护线程,当所有线程已经撤离,不再产生垃圾,守护线程自然就没事可干了,当垃圾回收线程是Java虚拟机上仅剩的线程时,Java虚拟机会自动离开。

    扩展

    Thread Dump打印出来的线程信息,含有daemon字样的线程即为守护进程,可能会有:服务守护进程、编译守护进程、windows下的监听Ctrl+break的守护进程、Finalizer守护进程、引用处理守护进程、GC守护进程。

    7、线程之间是如何通信的?

    当线程间是可以共享资源时,线程间通信是协调它们的重要的手段。Object类中wait()\notify()\notifyAll()方法可以用于线程间通信关于资源的锁的状态。

    8、聚集索引与非聚集索引有什么区别?

    所有的索引都是为了更快地检索数据,索引存放在索引页中,数据存放在数据页中,索引以B(balance)树的形式存储

    聚集索引:聚集索引用于决定数据表中的物理存储顺序,一张表最多有一个聚集索引。聚集索引的字段值尽量不能修改,因为修改后,因为修改后数据表的物理顺序需要重写排序。通常主键就是聚集索引

    非聚集索引:非聚集索引的关键自是index,不会决定表的物理存储顺序,在一张表内最多可以有249个非聚集索引。

    9、说一下 ArrayList 的优缺点

    ArrayList的优点如下:

    1、 ArrayList 底层以数组实现,是一种随机访问模式。ArrayList 实现了 RandomAccess 接口,因此查找的时候非常快。

    2、 ArrayList 在顺序添加一个元素的时候非常方便。

    ArrayList 的缺点如下:

    1、 删除元素的时候,需要做一次元素复制操作。如果要复制的元素很多,那么就会比较耗费性能。

    2、 插入元素的时候,也需要做一次元素复制操作,缺点同上。

    3、 ArrayList 比较适合顺序添加、随机访问的场景。

    10、请解释StackOverflowError和OutOfMemeryError的区别?

    通过之前的分析可以发现,实际上每一块内存中都会存在有一部分的可变伸缩区,其基本流程为:如果空间内存不足,在可变范围之内扩大内存空间,当一段时间之后发现内存充足,会缩小内存空间。

    永久代(JDK 1.8后消失了)

    虽然java的版本是JDK1.8,但是java EE 的版本还是jdk1.7,永久代存在于堆内存之中

    元空间

    元空间在Jdk1.8之后才有的,器功能实际上和永久代没区别,唯一的区别在于永久代使用的是JVM的堆内存空间,元空间使用的是物理内存,所以元空间的大小受本地内存影响,一般默认在2M 左右。

    范例:设置一些参数,让元空间出错

    Java -XX:MetaspaceSize=1m

    11、请阐述Catalina的配置文件有哪些?

    Catalina包含的配置文件有:

    1、 ·policy

    2、 ·properties

    3、 ·properties

    4、 ·xml

    5、 ·xml

    6、 ·Tomcat-users.xml

    12、Java中有几种类型的流?

    字节流和字符流。字节流继承于InputStream、OutputStream,字符流继承于Reader、Writer。在http://java.io 包中还有许多其他的流,主要是为了提高性能和使用方便。关于Java的I/O需要注意的有两点:一是两种对称性(输入和输出的对称性,字节和字符的对称性);二是两种设计模式(适配器模式和装潢模式)。另外Java中的流不同于C#的是它只有一个维度一个方向。

    面试题 - 编程实现文件拷贝。(这个题目在笔试的时候经常出现,下面的代码给出了两种实现方案)
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    public final class MyUtil {
        private MyUtil() {
            throw new AssertionError();
        }
        public static void fileCopy(String source, String target) throws IOException {
            try (InputStream in = new FileInputStream(source)) {
                try (OutputStream out = new FileOutputStream(target)) {
                    byte[] buffer = new byte[4096];
                    int bytesToRead;
                    while ((bytesToRead = in .read(buffer)) != -1) {
                        out.write(buffer, 0, bytesToRead);
                    }
                }
            }
        }
        public static void fileCopyNIO(String source, String target) throws IOException {
            try (FileInputStream in = new FileInputStream(source)) {
                try (FileOutputStream out = new FileOutputStream(target)) {
                    FileChannel inChannel = in .getChannel();
                    FileChannel outChannel = out.getChannel();
                    ByteBuffer buffer = ByteBuffer.allocate(4096);
                    while (inChannel.read(buffer) != -1) {
                        buffer.flip();
                        outChannel.write(buffer);
                        buffer.clear();
                    }
                }
            }
        }
    }
    注意:上面用到Java 7的TWR,使用TWR后可以不用在finally中释放外部资源 ,从而让代码更加优雅。

    13、当一个线程进入一个对象的synchronized方法A之后,其它线程是否可进入此对象的synchronized方法B?

    不能。其它线程只能访问该对象的非同步方法,同步方法则不能进入。因为非静态方法上的synchronized修饰符要求执行方法时要获得对象的锁,如果已经进入A方法说明对象锁已经被取走,那么试图进入B方法的线程就只能在等锁池(注意不是等待池哦)中等待对象的锁。

    14、什么是不可变对象(immutable object)?Java 中怎么创建一个不可变对象?

    不可变对象指对象一旦被创建,状态就不能再改变。任何修改都会创建一个新的对象,如 String、Integer及其它包装类。详情参见答案,一步一步指导你在 Java 中创建一个不可变的类。

    15、怎么利用 JUnit 来测试一个方法的异常?

    http://javarevisited.blogspot.sg/2013/04/JUnit-tutorial-example-test-exception-thrown-by-java-method.html

    16、两个相同的对象会有不同的的 hash code 吗?

    不能,根据 hash code 的规定,这是不可能的。

    17、如果你提交任务时,线程池队列已满,这时会发生什么

    有俩种可能:

    1、 如果使用的是无界队列 LinkedBlockingQueue,也就是无界队列的话,没关系,继续添加任务到阻塞队列中等待执行,因为 LinkedBlockingQueue 可以近乎认为是一个无穷大的队列,可以无限存放任务

    2、 如果使用的是有界队列比如 ArrayBlockingQueue,任务首先会被添加到ArrayBlockingQueue 中,ArrayBlockingQueue 满了,会根据maximumPoolSize 的值增加线程数量,如果增加了线程数量还是处理不过来,ArrayBlockingQueue 继续满,那么则会使用拒绝策略RejectedExecutionHandler 处理满了的任务,默认是 AbortPolicy

    18、GC日志的real、user、sys是什么意思?

    real 实际花费的时间,指的是从开始到结束所花费的时间。比如进程在等待I/O完成,这个阻塞时间也会被计算在内。user 指的是进程在用户态(User Mode)所花费的时间,只统计本进程所使用的时间,是指多核。sys 指的是进程在核心态(Kernel Mode)花费的CPU时间量,指的是内核中的系统调用所花费的时间,只统计本进程所使用的时间。

    这个是用来看日志用的,如果你不看日志,那不了解也无妨。不过,这三个参数的意义,在你能看到的地方,基本上都是一致的,比如操作系统。

    19、解释 Java 堆空间及 GC?

    当通过 Java 命令启动 Java 进程的时候,会为它分配内存。内存的一部分用于创建堆空间,当程序中创建对象的时候,就从对空间中分配内存。GC 是 JVM 内部的一个进程,回收无效对象的内存用于将来的分配。

    20、类的实例化顺序

    比如父类静态数据,构造函数,字段,子类静态数据,构造函数,字段,他们的执行顺序

    先静态、先父后子。

    先静态:父静态 > 子静态

    优先级:父类 > 子类 静态代码块 > 非静态代码块 > 构造函数

    一个类的实例化过程:

    1、 父类中的static代码块,当前类的static

    2、 顺序执行父类的普通代码块

    3、 父类的构造函数

    4、 子类普通代码块

    5、 子类(当前类)的构造函数,按顺序执行。

    6、 子类方法的执行,

    21、Spring中自动装配的方式有哪些?

    1、 no:不进行自动装配,手动设置Bean的依赖关系。

    2、 byName:根据Bean的名字进行自动装配。

    3、 byType:根据Bean的类型进行自动装配。

    4、 constructor:类似于byType,不过是应用于构造器的参数,如果正好有一个Bean与构造器的参数类型相同则可以自动装配,否则会导致错误。

    5、 autodetect:如果有默认的构造器,则通过constructor的方式进行自动装配,否则使用byType的方式进行自动装配。

    22、栈帧里面包含哪些东西?

    局部变量表、操作数栈、动态连接、返回地址等

    23、你是如何调用 wait() 方法的?使用 if 块还是循环?为什么?

    处于等待状态的线程可能会收到错误警报和伪唤醒,如果不在循环中检查等待条件,程序就会在没有满足结束条件的情况下退出。

    wait() 方法应该在循环调用,因为当线程获取到 CPU 开始执行的时候,其他条件可能还没有满足,所以在处理前,循环检测条件是否满足会更好。下面是一段标准的使用 wait 和 notify 方法的代码:

    synchronized (monitor) { // 判断条件谓词是否得到满足 while(!locked) { // 等待唤醒 monitor.wait(); } // 处理其他的业务逻辑 }

    24、ArrayList与LinkedList有什么区别?

    1、 ArrayList与LinkedList都实现了List接口。

    2、 ArrayList是线性表,底层是使用数组实现的,它在尾端插入和访问数据时效率较高,

    3、 Linked是双向链表,他在中间插入或者头部插入时效率较高,在访问数据时效率较低

    25、Super与this表示什么?

    1、 Super表示当前类的父类对象

    2、 This表示当前类的对象

    26、简述Java的对象结构

    Java对象由三个部分组成:对象头、实例数据、对齐填充。

    对象头由两部分组成,第一部分存储对象自身的运行时数据:哈希码、GC分代年龄、锁标识状态、线程持有的锁、偏向线程ID(一般占32/64 bit)。第二部分是指针类型,指向对象的类元数据类型(即对象代表哪个类)。如果是数组对象,则对象头中还有一部分用来记录数组长度。

    实例数据用来存储对象真正的有效信息(包括父类继承下来的和自己定义的)

    对齐填充:JVM要求对象起始地址必须是8字节的整数倍(8字节对齐 )

    27、Java 虚拟机栈的作用?

    Java 虚拟机栈来描述 Java 方法的内存模型。每当有新线程创建时就会分配一个栈空间,线程结束后栈空间被回收,栈与线程拥有相同的生命周期。栈中元素用于支持虚拟机进行方法调用,每个方法在执行时都会创建一个栈帧存储方法的局部变量表、操作栈、动态链接和方法出口等信息。每个方法从调用到执行完成,就是栈帧从入栈到出栈的过程。

    有两类异常:① 线程请求的栈深度大于虚拟机允许的深度抛出 StackOverflowError。② 如果 JVM 栈容量可以动态扩展,栈扩展无法申请足够内存抛出 OutOfMemoryError(HotSpot 不可动态扩展,不存在此问题)。

    28、实际开发中应用场景哪里用到了模板方法

    其实很多框架中都有用到了模板方法模式

    例如:

    数据库访问的封装、Junit单元测试、servlet中关于doGet/doPost方法的调用等等

    29、import java和javax有什么区别

    tech.souyunku.com/EasonJim/p/…

    31、Spring中自动装配的方式有哪些?

    1、 no:不进行自动装配,手动设置Bean的依赖关系。

    2、 byName:根据Bean的名字进行自动装配。

    3、 byType:根据Bean的类型进行自动装配。

    4、 constructor:类似于byType,不过是应用于构造器的参数,如果正好有一个Bean与构造器的参数类型相同则可以自动装配,否则会导致错误。

    5、 autodetect:如果有默认的构造器,则通过constructor的方式进行自动装配,否则使用byType的方式进行自动装配。

    32、栈帧里面包含哪些东西?

    局部变量表、操作数栈、动态连接、返回地址等

    33、你是如何调用 wait() 方法的?使用 if 块还是循环?为什么?

    处于等待状态的线程可能会收到错误警报和伪唤醒,如果不在循环中检查等待条件,程序就会在没有满足结束条件的情况下退出。

    wait() 方法应该在循环调用,因为当线程获取到 CPU 开始执行的时候,其他条件可能还没有满足,所以在处理前,循环检测条件是否满足会更好。下面是一段标准的使用 wait 和 notify 方法的代码:

    synchronized (monitor) { // 判断条件谓词是否得到满足 while(!locked) { // 等待唤醒 monitor.wait(); } // 处理其他的业务逻辑 }

    34、ArrayList与LinkedList有什么区别?

    1、 ArrayList与LinkedList都实现了List接口。

    2、 ArrayList是线性表,底层是使用数组实现的,它在尾端插入和访问数据时效率较高,

    3、 Linked是双向链表,他在中间插入或者头部插入时效率较高,在访问数据时效率较低

    35、Super与this表示什么?

    1、 Super表示当前类的父类对象

    2、 This表示当前类的对象

    36、简述Java的对象结构

    Java对象由三个部分组成:对象头、实例数据、对齐填充。

    对象头由两部分组成,第一部分存储对象自身的运行时数据:哈希码、GC分代年龄、锁标识状态、线程持有的锁、偏向线程ID(一般占32/64 bit)。第二部分是指针类型,指向对象的类元数据类型(即对象代表哪个类)。如果是数组对象,则对象头中还有一部分用来记录数组长度。

    实例数据用来存储对象真正的有效信息(包括父类继承下来的和自己定义的)

    对齐填充:JVM要求对象起始地址必须是8字节的整数倍(8字节对齐 )

    37、Java 虚拟机栈的作用?

    Java 虚拟机栈来描述 Java 方法的内存模型。每当有新线程创建时就会分配一个栈空间,线程结束后栈空间被回收,栈与线程拥有相同的生命周期。栈中元素用于支持虚拟机进行方法调用,每个方法在执行时都会创建一个栈帧存储方法的局部变量表、操作栈、动态链接和方法出口等信息。每个方法从调用到执行完成,就是栈帧从入栈到出栈的过程。

    有两类异常:① 线程请求的栈深度大于虚拟机允许的深度抛出 StackOverflowError。② 如果 JVM 栈容量可以动态扩展,栈扩展无法申请足够内存抛出 OutOfMemoryError(HotSpot 不可动态扩展,不存在此问题)。

    38、实际开发中应用场景哪里用到了模板方法

    其实很多框架中都有用到了模板方法模式

    例如:

    数据库访问的封装、Junit单元测试、servlet中关于doGet/doPost方法的调用等等

    39、import java和javax有什么区别

    tech.souyunku.com/EasonJim/p/…

    40、构造器(constructor)是否可被重写(override)?

    构造器不能被继承,因此不能被重写,但可以被重载。

    更多Java 面试题80道

    01、创建socket通讯的步骤?

    02、Java 中 sleep 方法和 wait 方法的区别?

    03、程序计数器(线程私有)

    04、什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing)?

    05、迭代器 Iterator 是什么?

    06、线程的 sleep()方法和 yield()方法有什么区别?

    07、Java 中能创建 volatile 数组吗?

    08、java中equals方法的用法以及==的用法

    09、如何创建一个json对象?

    10、如何判断对象是否是垃圾?

    11、抽象工厂模式和原型模式之间的区别?

    12、在 Java 程序中怎么保证多线程的运行安全?

    13、volatile 修饰符的有过什么实践?

    14、Java中各种数据默认值

    15、说说Java 垃圾回收机制

    16、有没有可能两个不相等的对象有有相同的 hashcode?

    17、synchronized 和 Lock 有什么区别?

    18、什么是Vector

    19、对象的访问定位有哪几种方式?

    20、equals 和 == 的区别?#

    21、什么是ThreadPoolExecutor?

    22、invokedynamic 指令是干什么的?

    23、synchronized、volatile、CAS 比较

    24、Iterator 怎么使用?有什么特点?

    25、被引用的对象就一定能存活吗?

    26、列出一些你常见的运行时异常?

    27、Servlet生命周期内调用的方法过程?

    28、阐述静态变量和实例变量的区别。

    29、类加载器双亲委派模型机制?

    30、抽象的(abstract)方法是否可同时是静态的(static),是否可同时是本地方法(native),是否可同时被synchronized修饰?

    31、如何判断一个对象是否存活

    32、Int与integer的区别

    33、Servlet的生命周期?

    34、怎么唤醒一个阻塞的线程

    35、虚拟DOM的优劣如何?

    36、双亲委派模型是什么?

    37、静态嵌套类(Static Nested Class)和内部类(Inner Class)的不同?

    38、如果对象的引用被置为null,垃圾收集器是否会立即释放对象占用的内存?

    39、JVM 出现 fullGC 很频繁,怎么去线上排查问题

    40、JVM 内存区域

    41、Parallel Old 收集器(多线程标记整理算法)

    42、对象分配内存是否线程安全?

    43、当一个线程进入某个对象的一个synchronized的实例方法后,其它线程是否可进入此对象的其它方法?

    44、Serial 与 Parallel GC 之间的不同之处?

    45、为什么线程通信的方法 wait(), notify()和 notifyAll()被定义在 Object 类里?

    46、redux异步中间件之间的优劣?

    47、类加载为什么要使用双亲委派模式,有没有什么场景是打破了这个模式?

    48、Hibernate中Session的load和get方法的区别是什么?

    49、说一下堆内存中对象的分配的基本策略

    50、Java 中如何将字符串转换为整数?

    51、讲讲什么情况下会出现内存溢出,内存泄漏?

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

    53、线程与进程的区别?

    54、Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法分别是做什么的?有什么区别?

    55、用代码演示三种代理

    56、stackoverflow错误,permgen space错误

    57、分代收集算法

    58、同步方法和同步块,哪个是更好的选择?

    69、Java 中的编译期常量是什么?使用它又什么风险?

    70、Java死锁以及如何避免?

    71、日期和时间:

    72、XML文档定义有几种形式?它们之间有何本质区别?解析XML文档有哪几种方式?

    73、依赖注入和工程模式之间有什么不同?

    74、Java 堆的结构是什么样子的?什么是堆中的永久代(Perm Gen space)

    75、如何修改tomcat的端口号?

    76、Java有没有goto?

    77、Java 内存分配与回收策率以及 Minor GC 和 Major GC

    78、简述Hibernate常见优化策略。

    79、Statement与preparedStatement区别

    80、什么是DAO模式?

    如果不背 Java面试题的答案,肯定面试会挂!

    这套Java面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的

    更多相关内容
  • 《昆虫》名著阅读试题及答案(选择题、判断题).pdf
  • 程序实验几十道,包括答案、分析、实现结果,可用于Python的学习
  • MySQL面试答案 【最新版】MySQL面试大全,发现网上很多MySQL面试答案整理都没有答案,所以花了很长时间搜集,本套MySQL面试大全 如果不背 MySQL面试答案,肯定面试会挂! 这套MySQL面试大全,...

    MySQL面试题及答案 【最新版】MySQL面试题大全,发现网上很多MySQL面试题及答案整理都没有答案,所以花了很长时间搜集,本套MySQL面试题大全

    如果不背 MySQL面试题的答案,肯定面试会挂!

    这套MySQL面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个面试手册,是PDF版的

    1、NOW()和CURRENT_DATE()有什么区别?

    NOW()命令用于显示当前年份,月份,日期,小时,分钟和秒。

    CURRENT_DATE()仅显示当前年份,月份和日期。

    2、CHAR和VARCHAR的区别?

    1.CHAR和VARCHAR类型在存储和检索方面有所不同

    2.CHAR列长度固定为创建表时声明的长度,长度值范围是1到255

    当CHAR值被存储时,它们被用空格填充到特定长度,检索CHAR值时需删除尾随空格。

    3、主键索引与唯一索引的区别

    1、 主键是一种约束,唯一索引是一种索引,两者在本质上是不同的。

    2、 主键创建后一定包含一个唯一性索引,唯一性索引并不一定就是主键。

    3、 唯一性索引列允许空值,而主键列不允许为空值。

    4、 主键列在创建时,已经默认为空值 ++ 唯一索引了。

    5、 一个表最多只能创建一个主键,但可以创建多个唯一索引。

    6、 主键更适合那些不容易更改的唯一标识,如自动递增列、身份证号等。

    7、 主键可以被其他表引用为外键,而唯一索引不能。 ?

    4、MySQL中有哪些不同的表格?

    共有5种类型的表格:

    1、 MyISAM

    2、 Heap

    3、 Merge

    4、 INNODB

    5、 ISAM

    5、SQL的生命周期?

    1、 应用服务器与数据库服务器建立一个连接

    2、 数据库进程拿到请求sql

    3、 解析并生成执行计划,执行

    4、 读取数据到内存并进行逻辑处理

    5、 通过步骤一的连接,发送结果到客户端

    6、 关掉连接,释放资源

    6、你怎么看到为表格定义的所有索引?

    索引是通过以下方式为表格定义的:

    SHOW INDEX FROM <tablename>;

    7、数据库为什么使用B+树而不是B树

    1、 B树只适合随机检索,而B+树同时支持随机检索和顺序检索;

    2、 B+树空间利用率更高,可减少I/O次数,磁盘读写代价更低。一般来说,索引本身也很大,不可能全部存储在内存中,因此索引往往以索引文件的形式存储的磁盘上。这样的话,索引查找过程中就要产生磁盘I/O消耗。B+树的内部结点并没有指向关键字具体信息的指针,只是作为索引使用,其内部结点比B树小,盘块能容纳的结点中关键字数量更多,一次性读入内存中可以查找的关键字也就越多,相对的,IO读写次数也就降低了。而IO读写次数是影响索引检索效率的最大因素;

    3、 B+树的查询效率更加稳定。B树搜索有可能会在非叶子结点结束,越靠近根节点的记录查找时间越短,只要找到关键字即可确定记录的存在,其性能等价于在关键字全集内做一次二分查找。而在B+树中,顺序检索比较明显,随机检索时,任何关键字的查找都必须走一条从根节点到叶节点的路,所有关键字的查找路径长度相同,导致每一个关键字的查询效率相当。

    4、 B-树在提高了磁盘IO性能的同时并没有解决元素遍历的效率低下的问题。B+树的叶子节点使用指针顺序连接在一起,只要遍历叶子节点就可以实现整棵树的遍历。而且在数据库中基于范围的查询是非常频繁的,而B树不支持这样的操作。

    5、 增删文件(节点)时,效率更高。因为B+树的叶子节点包含所有关键字,并以有序的链表结构存储,这样可很好提高增删效率。

    8、数据库三大范式是什么

    第一范式:每个列都不可以再拆分。

    第二范式:在第一范式的基础上,非主键列完全依赖于主键,而不能是依赖于主键的一部分。

    第三范式:在第二范式的基础上,非主键列只依赖于主键,不依赖于其他非主键。

    在设计数据库结构的时候,要尽量遵守三范式,如果不遵守,必须有足够的理由。比如性能。事实上我们经常会为了性能而妥协数据库的设计。

    9、怎么优化SQL查询语句吗

    1、 对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引

    2、 用索引可以提高查询

    3、 SELECT子句中避免使用*号,尽量全部大写SQL

    4、 应尽量避免在 where 子句中对字段进行 is null 值判断,否则将导致引擎放弃使用索引而进行全表扫描,使用 IS NOT NULL

    5、 where 子句中使用 or 来连接条件,也会导致引擎放弃使用索引而进行全表扫描

    6、 in 和 not in 也要慎用,否则会导致全表扫描

    10、覆盖索引、回表等这些,了解过吗?

    1、 覆盖索引: 查询列要被所建的索引覆盖,不必从数据表中读取,换句话说查询列要被所使用的索引覆盖。

    2、 回表:二级索引无法直接查询所有列的数据,所以通过二级索引查询到聚簇索引后,再查询到想要的数据,这种通过二级索引查询出来的过程,就叫做回表。

    11、MySQL数据库cpu飙升的话,要怎么处理呢?

    排查过程:

    1、 使用top 命令观察,确定是MySQLd导致还是其他原因。

    2、 如果是MySQLd导致的,show processlist,查看session情况,确定是不是有消耗资源的sql在运行。

    3、 找出消耗高的 sql,看看执行计划是否准确, 索引是否缺失,数据量是否太大。

    处理:

    1、 kill 掉这些线程(同时观察 cpu 使用率是否下降),

    2、 进行相应的调整(比如说加索引、改 sql、改内存参数)

    3、 重新跑这些 SQL。

    其他情况:

    也有可能是每个 sql 消耗资源并不多,但是突然之间,有大量的 session 连进来导致 cpu 飙升,这种情况就需要跟应用一起来分析为何连接数会激增,再做出相应的调整,比如说限制连接数等

    12、说说对SQL语句优化有哪些方法?(选择几条)

    1、 Where子句中:where表之间的连接必须写在其他Where条件之前,那些可以过滤掉最大数量记录的条件必须写在Where子句的末尾.HAVING最后。

    2、 用EXISTS替代IN、用NOT EXISTS替代NOT IN。

    3、 避免在索引列上使用计算

    4、 避免在索引列上使用IS NULL和IS NOT NULL

    5、 对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引。

    6、 应尽量避免在 where 子句中对字段进行 null 值判断,否则将导致引擎放弃使用索引而进行全表扫描

    7、 应尽量避免在 where 子句中对字段进行表达式操作,这将导致引擎放弃使用索引而进行全表扫描

    13、Innodb的事务与日志的实现方式

    有多少种日志

    innodb两种日志redo和undo。

    日志的存放形式

    1、 redo:在页修改的时候,先写到 redo log buffer 里面, 然后写到 redo log 的文件系统缓存里面(fwrite),然后再同步到磁盘文件( fsync)。

    2、 Undo:在 MySQL5.5 之前, undo 只能存放在 ibdata文件里面, 5.6 之后,可以通过设置 innodb_undo_tablespaces 参数把 undo log 存放在 ibdata之外。

    事务是如何通过日志来实现的

    1、 因为事务在修改页时,要先记 undo,在记 undo 之前要记 undo 的 redo, 然后修改数据页,再记数据页修改的 redo。 Redo(里面包括 undo 的修改) 一定要比数据页先持久化到磁盘。

    2、 当事务需要回滚时,因为有 undo,可以把数据页回滚到前镜像的 状态,崩溃恢复时,如果 redo log 中事务没有对应的 commit 记录,那么需要用 undo把该事务的修改回滚到事务开始之前。

    3、 如果有 commit 记录,就用 redo 前滚到该事务完成时并提交掉。

    14、非聚簇索引一定会回表查询吗?

    不一定,如果查询语句的字段全部命中了索引,那么就不必再进行回表查询(哈哈,覆盖索引就是这么回事)。

    举个简单的例子,假设我们在学生表的上建立了索引,那么当进行select age from student where age < 20的查询时,在索引的叶子节点上,已经包含了age信息,不会再次进行回表查询。

    15、Hash索引和B+树所有有什么区别或者说优劣呢?

    1、 首先要知道Hash索引和B+树索引的底层实现原理:

    2、 hash索引底层就是hash表,进行查找时,调用一次hash函数就可以获取到相应的键值,之后进行回表查询获得实际数据。B+树底层实现是多路平衡查找树。对于每一次的查询都是从根节点出发,查找到叶子节点方可以获得所查键值,然后根据查询判断是否需要回表查询数据。

    那么可以看出他们有以下的不同:

    1、 hash索引进行等值查询更快(一般情况下),但是却无法进行范围查询。

    2、 因为在hash索引中经过hash函数建立索引之后,索引的顺序与原顺序无法保持一致,不能支持范围查询。而B+树的的所有节点皆遵循(左节点小于父节点,右节点大于父节点,多叉树也类似),天然支持范围。

    3、 hash索引不支持使用索引进行排序,原理同上。

    4、 hash索引不支持模糊查询以及多列索引的最左前缀匹配。原理也是因为hash函数的不可预测。AAAA和AAAAB的索引没有相关性。

    5、 hash索引任何时候都避免不了回表查询数据,而B+树在符合某些条件(聚簇索引,覆盖索引等)的时候可以只通过索引完成查询。

    6、 hash索引虽然在等值查询上较快,但是不稳定。性能不可预测,当某个键值存在大量重复的时候,发生hash碰撞,此时效率可能极差。而B+树的查询效率比较稳定,对于所有的查询都是从根节点到叶子节点,且树的高度较低。

    7、 因此,在大多数情况下,直接选择B+树索引可以获得稳定且较好的查询速度。而不需要使用hash索引。

    16、select for update有什么含义,会锁表还是锁行还是其他。

    select for update 含义

    select查询语句是不会加锁的,但是select for update除了有查询的作用外,还会加锁呢,而且它是悲观锁哦。至于加了是行锁还是表锁,这就要看是不是用了索引/主键啦。

    没用索引/主键的话就是表锁,否则就是是行锁。

    select for update 加锁验证

    表结构:

    //id 为主键,name为唯一索引 CREATE TABLE `account` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(255) DEFAULT NULL, `balance` int(11) DEFAULT NULL, PRIMARY KEY (`id`), KEY `idx_name` (`name`) USING BTREE ) ENGINE=InnoDB AUTO_INCREMENT=1570068 DEFAULT CHARSET=utf8

    id为主键,select for update 1270070这条记录时,再开一个事务对该记录更新,发现更新阻塞啦,其实是加锁了。如下图:

    我们再开一个事务对另外一条记录1270071更新,发现更新成功,因此,如果查询条件用了索引/主键,会加行锁~

    我们继续一路向北吧,换普通字段balance吧,发现又阻塞了。因此,没用索引/主键的话,select for update加的就是表锁

    17、你们数据库是否支持emoji表情存储,如果不支持,如何操作?

    更换字符集utf8-->utf8mb4

    18、索引的数据结构(b树,hash)

    索引的数据结构和具体存储引擎的实现有关,在MySQL中使用较多的索引有Hash索引B+树索引等,而我们经常使用的InnoDB存储引擎的默认索引实现为:B+树索引。对于哈希索引来说,底层的数据结构就是哈希表,因此在绝大多数需求为单条记录查询的时候,可以选择哈希索引,查询性能最快;其余大部分场景,建议选择BTree索引。

    B树索引

    MySQL通过存储引擎取数据,基本上90%的人用的就是InnoDB了,按照实现方式分,InnoDB的索引类型目前只有两种:BTREE(B树)索引和HASH索引。B树索引是MySQL数据库中使用最频繁的索引类型,基本所有存储引擎都支持BTree索引。通常我们说的索引不出意外指的就是(B树)索引(实际是用B+树实现的,因为在查看表索引时,MySQL一律打印BTREE,所以简称为B树索引)

    ![99_1.png][99_1.png]

    查询方式:

    1、 主键索引区:PI(关联保存的时数据的地址)按主键查询,

    2、 普通索引区:si(关联的id的地址,然后再到达上面的地址)。所以按主键查询,速度最快

    B+tree性质:

    1、 n棵子tree的节点包含n个关键字,不用来保存数据而是保存数据的索引。

    2、 所有的叶子结点中包含了全部关键字的信息,及指向含这些关键字记录的指针,且叶子结点本身依关键字的大小自小而大顺序链接。

    3、 所有的非终端结点可以看成是索引部分,结点中仅含其子树中的最大(或最小)关键字。

    4、 B+ 树中,数据对象的插入和删除仅在叶节点上进行。

    5、 B+树有2个头指针,一个是树的根节点,一个是最小关键码的叶节点。

    哈希索引

    简要说下,类似于数据结构中简单实现的HASH表(散列表)一样,当我们在MySQL中用哈希索引时,主要就是通过Hash算法(常见的Hash算法有直接定址法、平方取中法、折叠法、除数取余法、随机数法),将数据库字段数据转换成定长的Hash值,与这条数据的行指针一并存入Hash表的对应位置;如果发生Hash碰撞(两个不同关键字的Hash值相同),则在对应Hash键下以链表形式存储。当然这只是简略模拟图。

    ![99_2.png][99_2.png]

    19、最左匹配原则?

    在创建联合索引时候,一般需要遵循最左匹配原则。即联合索引中的属性识别度最高的放在查询语句的最前面。

    20、对于关系型数据库而言,索引是相当重要的概念,请回答有关索引的几个问题:

    1.索引的目的是什么?

    快速访问数据表中的特定信息,提高检索速度

    创建唯一性索引,保证数据库表中每一行数据的唯一性。

    加速表和表之间的连接

    使用分组和排序子句进行数据检索时,可以显著减少查询中分组和排序的时间

    2.索引对数据库系统的负面影响是什么?

    负面影响:

    创建索引和维护索引需要耗费时间,这个时间随着数据量的增加而增加;索引需要占用物理空间,不光是表需要占用数据空间,每个索引也需要占用物理空间;当对表进行增、删、改、的时候索引也要动态维护,这样就降低了数据的维护速度。

    3.为数据表建立索引的原则有哪些?

    在最频繁使用的、用以缩小查询范围的字段上建立索引。

    在频繁使用的、需要排序的字段上建立索引

    4.什么情况下不宜建立索引?

    对于查询中很少涉及的列或者重复值比较多的列,不宜建立索引。

    对于一些特殊的数据类型,不宜建立索引,比如文本字段(text)等

    21、什么是最左前缀原则?什么是最左匹配原则?

    最左前缀原则,就是最左优先,在创建多列索引时,要根据业务需求,where子句中使用最频繁的一列放在最左边。

    当我们创建一个组合索引的时候,如(k1,k2,k3),相当于创建了(k1)、(k1,k2)和(k1,k2,k3)三个索引,这就是最左匹配原则。。

    22、myisamchk是用来做什么的?

    它用来压缩MyISAM表,这减少了磁盘或内存使用。

    23、说说分库与分表的设计

    分库分表方案,分库分表中间件,分库分表可能遇到的问题

    「分库分表方案:」

    1、 水平分库:以字段为依据,按照一定策略(hash、range等),将一个库中的数据拆分到多个库中。

    2、 水平分表:以字段为依据,按照一定策略(hash、range等),将一个表中的数据拆分到多个表中。

    3、 垂直分库:以表为依据,按照业务归属不同,将不同的表拆分到不同的库中。

    4、 垂直分表:以字段为依据,按照字段的活跃性,将表中字段拆到不同的表(主表和扩展表)中。

    「常用的分库分表中间件:」

    1、 sharding-jdbc(当当)

    2、 Mycat

    3、 TDDL(淘宝)

    4、 Oceanus(58同城数据库中间件)

    5、 vitess(谷歌开发的数据库中间件)

    6、 Atlas(Qihoo 360)

    「分库分表可能遇到的问题」

    1、 事务问题:需要用分布式事务啦

    2、 跨节点Join的问题:解决这一问题可以分两次查询实现

    3、 跨节点的count,order by,group by以及聚合函数问题:分别在各个节点上得到结果后在应用程序端进行合并。

    4、 数据迁移,容量规划,扩容等问题

    5、 ID问题:数据库被切分后,不能再依赖数据库自身的主键生成机制啦,最简单可以考虑UUID

    6、 跨分片的排序分页问题(后台加大pagesize处理?)

    24、什么情况下设置了索引但无法使用

    1.以“%”开头的LIKE语句,模糊匹配

    2\、OR语句前后没有同时使用索引

    3\、数据类型出现隐式转化(如varchar不加单引号的话可能会自动转换为int型)

    25、如何删除索引

    根据索引名删除普通索引、唯一索引、全文索引:alter table 表名 drop KEY 索引名

    alter table user_index drop KEY name; alter table user_index drop KEY id_card; alter table user_index drop KEY information;

    删除主键索引:alter table 表名 drop primary key(因为主键只有一个)。这里值得注意的是,如果主键自增长,那么不能直接执行此操作(自增长依赖于主键索引):

    ![99_3.png][99_3.png]

    需要取消自增长再行删除:

    alter table user_index -- 重新定义字段 MODIFY id int, drop PRIMARY KEY

    但通常不会删除主键,因为设计主键一定与业务逻辑无关。

    26、什么是数据库连接池?为什么需要数据库连接池呢?

    连接池基本原理:

    数据库连接池原理:在内部对象池中,维护一定数量的数据库连接,并对外暴露数据库连接的获取和返回方法。

    应用程序和数据库建立连接的过程:

    1、 通过TCP协议的三次握手和数据库服务器建立连接

    2、 发送数据库用户账号密码,等待数据库验证用户身份

    3、 完成身份验证后,系统可以提交SQL语句到数据库执行

    4、 把连接关闭,TCP四次挥手告别。

    数据库连接池好处:

    1、 资源重用 (连接复用)

    2、 更快的系统响应速度

    3、 新的资源分配手段

    4、 统一的连接管理,避免数据库连接泄漏

    27、列对比运算符是什么?

    在SELECT语句的列比较中使用=,<>,<=,<,> =,>,<<,>>,<=>,AND,OR或LIKE运算符。

    28、按照锁的粒度分,数据库锁有哪些呢?锁机制与InnoDB锁算法

    按锁粒度分有:表锁,页锁,行锁

    按锁机制分有:乐观锁,悲观锁

    29、LIKE声明中的%和_是什么意思?

    %对应于0个或更多字符,_只是LIKE语句中的一个字符。

    如何在Unix和MySQL时间戳之间进行转换?

    UNIX_TIMESTAMP是从MySQL时间戳转换为Unix时间戳的命令

    FROM_UNIXTIME是从Unix时间戳转换为MySQL时间戳的命令

    30、如何定位及优化SQL语句的性能问题?创建的索引有没有被使用到?或者说怎么才可以知道这条语句运行很慢的原因?

    对于低性能的SQL语句的定位,最重要也是最有效的方法就是使用执行计划,MySQL提供了explain命令来查看语句的执行计划。 我们知道,不管是哪种数据库,或者是哪种数据库引擎,在对一条SQL语句进行执行的过程中都会做很多相关的优化,对于查询语句,最重要的优化方式就是使用索引。 而执行计划,就是显示数据库引擎对于SQL语句的执行的详细情况,其中包含了是否使用索引,使用什么索引,使用的索引的相关信息等

    执行计划包含的信息 id 有一组数字组成。表示一个查询中各个子查询的执行顺序;

    1、 id相同执行顺序由上至下。

    2、 id不同,id值越大优先级越高,越先被执行。

    3、 id为null时表示一个结果集,不需要使用它查询,常出现在包含union等查询语句中。

    select_type 每个子查询的查询类型,一些常见的查询类型。

    table 查询的数据表,当从衍生表中查数据时会显示 x 表示对应的执行计划id partitions 表分区、表创建的时候可以指定通过那个列进行表分区。 举个例子:

    create table tmp ( id int unsigned not null AUTO_INCREMENT, name varchar(255), PRIMARY KEY (id) ) engine = innodb partition by key (id) partitions 5;

    type(非常重要,可以看到有没有走索引) 访问类型

    1、 ALL 扫描全表数据

    2、 index 遍历索引

    3、 range 索引范围查找

    4、 index_subquery 在子查询中使用 ref

    5、 unique_subquery 在子查询中使用 eq_ref

    6、 ref_or_null 对Null进行索引的优化的 ref

    7、 fulltext 使用全文索引

    8、 ref 使用非唯一索引查找数据

    9、 eq_ref 在join查询中使用PRIMARY KEYorUNIQUE NOT NULL索引关联。

    10、 possible_keys 可能使用的索引,注意不一定会使用。查询涉及到的字段上若存在索引,则该索引将被列出来。当该列为 NULL时就要考虑当前的SQL是否需要优化了。

    11、 key 显示MySQL在查询中实际使用的索引,若没有使用索引,显示为NULL。

    12、 TIPS:查询中若使用了覆盖索引(覆盖索引:索引的数据覆盖了需要查询的所有数据),则该索引仅出现在key列表中

    13、 key_length 索引长度

    14、 ref 表示上述表的连接匹配条件,即哪些列或常量被用于查找索引列上的值

    15、 rows 返回估算的结果集数目,并不是一个准确的值。

    16、 extra 的信息非常丰富,常见的有:

    17、 Using index 使用覆盖索引

    18、 Using where 使用了用where子句来过滤结果集

    19、 Using filesort 使用文件排序,使用非索引列进行排序时出现,非常消耗性能,尽量优化。

    20、 Using temporary 使用了临时表 sql优化的目标可以参考阿里开发手册

    推荐

    SQL性能优化的目标:至少要达到 range 级别,要求是ref级别,如果可以是consts最好

    说明:

    1、 consts 单表中最多只有一个匹配行(主键或者唯一索引),在优化阶段即可读取到数据。

    2、 ref 指的是使用普通的索引(normal index)。

    3、 range 对索引进行范围检索。

    反例:

    explain表的结果,type=index,索引物理文件全扫描,速度非常慢,这个index级别比较range还低,与全表扫描是小巫见大巫。

    更多 MySQL面试题 80道

    01、UNION与UNION ALL的区别?

    02、CHAR和VARCHAR的区别?

    03、Hash索引和B+树所有有什么区别或者说优劣呢?

    04、索引的基本原理

    05、简单总结下

    06、什么是死锁?怎么解决?

    07、LIKE声明中的%和_是什么意思?

    08、SQL 约束有哪几种呢?

    09、创建索引的三种方式

    10、为什么官方建议使用自增长主键作为索引?

    11、使用悲观锁

    12、一个6亿的表a,一个3亿的表b,通过外间tid关联,你如何最快的查询出满足条件的第50000到第50200中的这200条数据记录。

    13、覆盖索引、回表等这些,了解过吗?

    14、索引能干什么?

    15、为什么要尽量设定一个主键?

    16、数据库三大范式是什么

    17、MySQL的binlog有有几种录入格式?分别有什么区别?

    08、MySQL为什么这么设计

    19、主键使用自增ID还是UUID,为什么?

    20、索引使用场景

    21、隔离级别与锁的关系

    22、MySQL事务得四大特性以及实现原理

    23、锁的优化策略

    24、varchar与char的区别

    25、最左匹配原则?

    26、创建索引的三种方式

    27、日常工作中你是怎么优化SQL的?

    28、主从同步延迟的解决办法

    29、关心过业务系统里面的sql耗时吗?统计过慢查询吗?对慢查询都怎么优化过?

    30、MySQL的binlog有几种录入格式?分别有什么区别?

    31、按照锁的粒度分数据库锁有哪些?锁机制与InnoDB锁算法

    32、数据库索引的原理,为什么要用 B+树,为什么不用二叉树?

    33、MYSQL数据库服务器性能分析的方法命令有哪些?

    34、SQL语句的语法顺序:

    35、简述在MySQL数据库中MyISAM和InnoDB的区别

    36、一个6亿的表a,一个3亿的表b,通过外间tid关联,你如何最快的查询出满足条件的第50000到第50200中的这200条数据记录。

    37、MySQL的复制原理以及流程

    38、读写分离常见方案?

    39、drop、delete与truncate的区别

    40、字段为什么要求定义为not null?

    41、非聚簇索引一定会回表查询吗?

    42、varchar(50)中50的涵义

    43、完整性约束包括哪些?

    44、谈谈六种关联查询,使用场景。

    45、MVCC熟悉吗,它的底层原理?

    46、锁的优化策略

    47、什么是聚簇索引?何时使用聚簇索引与非聚簇索引

    48、500台db,在最快时间之内重启。

    49、你们数据库是否支持emoji表情存储,如果不支持,如何操作?

    50、说一下大表查询的优化方案

    51、数据库自增主键可能遇到什么问题。

    52、MySQL中InnoDB引擎的行锁是怎么实现的?

    53、MySQL有关权限的表都有哪几个?

    54、索引失效情况? ==校验SQL语句是否使用了索引方式为:

    55、什么情况下设置了索引但无法使用

    56、为什么要使用视图?什么是视图?

    57、MySQL中InnoDB引擎的行锁是怎么实现的?

    58、怎么优化SQL查询语句吗

    59、如何删除索引

    60、说一下数据库的三大范式

    71、MySQL中有哪几种锁?

    72、myisamchk是用来做什么的?

    73、NULL是什么意思

    74、读写分离有哪些解决方案?

    75、数据库为什么使用B+树而不是B树

    76、Innodb的事务实现原理?

    07、varchar(50)中50的涵义

    78、一条SQL语句在MySQL中如何执行的?

    79、什么是死锁?怎么解决?

    80、如何在Unix和MySQL时间戳之间进行转换?

    如果不背 MySQL面试题的答案,肯定面试会挂!

    这套MySQL面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个面试手册,是PDF版的

    展开全文
  • 史上最全Java初中级面试,发现网上很多Java初级面试都没有答案,所以花了很长时间搜集整理出来了这套Java面试大全,希望对大家有帮助哈~ 本人发现网上虽然有不少Java相关的面试,但第一未必全,第二未必有...

    史上最全Java初中级面试题,发现网上很多Java初级面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~

    本人发现网上虽然有不少Java相关的面试题,但第一未必全,第二未必有答案,第三虽然有答案,但未必能在面试中说,所以在本文里,会不断收集各种面试题,并站在面试官的立场上,给出我自己的答案。

    如果不背 Java面试题的答案,肯定面试会挂!

    这套Java面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的

    1、为什么使用Executor框架?

    1、 每次执行任务创建线程 new Thread()比较消耗性能,创建一个线程是比较耗时、耗资源的。

    2、 调用 new Thread()创建的线程缺乏管理,被称为野线程,而且可以无限制的创建,线程之间的相互竞争会导致过多占用系统资源而导致系统瘫痪,还有线程之间的频繁交替也会消耗很多系统资源。

    3、 接使用new Thread() 启动的线程不利于扩展,比如定时执行、定期执行、定时定期执行、线程中断等都不便实现。

    2、你能保证 GC 执行吗?

    不能,虽然你可以调用 System.gc() 或者 Runtime.gc(),但是没有办法保证 GC的执行。

    3、UML中有哪些常用的图?

    UML定义了多种图形化的符号来描述软件系统部分或全部的静态结构和动态结构,包括:用例图(use case diagram)、类图(class diagram)、时序图(sequence diagram)、协作图(collaboration diagram)、状态图(statechart diagram)、活动图(activity diagram)、构件图(component diagram)、部署图(deployment diagram)等。在这些图形化符号中,有三种图最为重要,分别是:用例图(用来捕获需求,描述系统的功能,通过该图可以迅速的了解系统的功能模块及其关系)、类图(描述类以及类与类之间的关系,通过该图可以快速了解系统)、时序图(描述执行特定任务时对象之间的交互关系以及执行顺序,通过该图可以了解对象能接收的消息也就是说对象能够向外界提供的服务)。

    用例图:

    类图:

    时序图:

    4、volatile关键字的原理是什么?干什么用的?

    使用了volatile关键字的变量,每当变量的值有变动的时候,都会将更改立即同步到主内存中;而如果某个线程想要使用这个变量,就先要从主存中刷新到工作内存,这样就确保了变量的可见性。

    一般使用一个volatile修饰的bool变量,来控制线程的运行状态。

    volatile boolean stop = false; void stop(){ this.stop = true; } void start(){ new Thread(()->{ while (!stop){ //sth } }).start(); }

    5、synchronized 和 Lock 有什么区别?

    1、 首先synchronized是Java内置关键字,在JVM层面,Lock是个Java类;

    2、 synchronized 可以给类、方法、代码块加锁;而 lock 只能给代码块加锁。

    3、 synchronized 不需要手动获取锁和释放锁,使用简单,发生异常会自动释放锁,不会造成死锁;而 lock 需要自己加锁和释放锁,如果使用不当没有 unLock()去释放锁就会造成死锁。

    4、 通过 Lock 可以知道有没有成功获取锁,而 synchronized 却无法办到。

    6、抽象类必须要有抽象方法吗

    不是必须。抽象类可以没有抽象方法。

    7、强引用、软引用、弱引用、虚引用是什么,有什么区别?

    1、 强引用,就是普通的对象引用关系,如 String s = new String("ConstXiong")

    2、 软引用,用于维护一些可有可无的对象。只有在内存不足时,系统则会回收软引用对象,如果回收了软引用对象之后仍然没有足够的内存,才会抛出内存溢出异常。SoftReference 实现

    3、 弱引用,相比软引用来说,要更加无用一些,它拥有更短的生命周期,当 JVM 进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。WeakReference 实现

    4、 虚引用是一种形同虚设的引用,在现实场景中用的不是很多,它主要用来跟踪对象被垃圾回收的活动。PhantomReference 实现

    8、Servlet的生命周期?

    1、 加载:判断servlet实例是否存在,如果不存在,就加载serlvet

    2、 实例化:

    3、 初始化

    4、服务

    5、销毁

    9、Hibernate的对象有几种状态

    1、 瞬时态(transient)

    2、 持久态(persistent)

    3、 游离态(detached)

    10、说一下HashMap的实现原理?

    1、 HashMap概述: HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。

    2、 HashMap的数据结构: 在Java编程语言中,最基本的结构就是两种,一个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基本结构来构造的,HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构,即数组和链表的结合体。

    HashMap 基于 Hash 算法实现的

    1、 当我们往HashMap中put元素时,利用key的hashCode重新hash计算出当前对象的元素在数组中的下标

    2、 存储时,如果出现hash值相同的key,此时有两种情况。

    (1)如果key相同,则覆盖原始值;

    (2)如果key不同(出现冲突),则将当前的key-value放入链表中

    3、 获取时,直接找到hash值对应的下标,在进一步判断key是否相同,从而找到对应值。

    4、 理解了以上过程就不难明白HashMap是如何解决hash冲突的问题,核心就是使用了数组的存储方式,然后将冲突的key的对象放入链表中,一旦发现冲突就在链表中做进一步的对比。

    需要注意Jdk 1.8中对HashMap的实现做了优化,当链表中的节点数据超过八个之后,该链表会转为红黑树来提高查询效率,从原来的O(n)到O(logn)

    1、java中有几种方法可以实现一个线程?

    继承 Thread 类

    实现 Runnable 接口

    实现 Callable 接口,需要实现的是 call() 方法

    2、Java 中的 HashSet,内部是如何工作的?

    HashSet 的内部采用 HashMap来实现。由于 Map 需要 key 和 value,所以所有 key 的都有一个默认 value。类似于 HashMap,HashSet 不允许重复的 key,只允许有一个null key,意思就是 HashSet 中只允许存储一个 null 对象。

    3、redux的工作流程?

    首先,我们看下几个核心概念:

    1、 Store:保存数据的地方,你可以把它看成一个容器,整个应用只能有一个Store。

    2、 State:Store对象包含所有数据,如果想得到某个时点的数据,就要对Store生成快照,这种时点的数据集合,就叫做State。

    3、 Action:State的变化,会导致View的变化。但是,用户接触不到State,只能接触到View。所以,State的变化必须是View导致的。Action就是View发出的通知,表示State应该要发生变化了。

    4、 Action Creator:View要发送多少种消息,就会有多少种Action。如果都手写,会很麻烦,所以我们定义一个函数来生成Action,这个函数就叫Action Creator。

    5、 Reducer:Store收到Action以后,必须给出一个新的State,这样View才会发生变化。这种State的计算过程就叫做Reducer。Reducer是一个函数,它接受Action和当前State作为参数,返回一个新的State。

    6、 dispatch:是View发出Action的唯一方法。

    然后我们过下整个工作流程:

    1、 首先,用户(通过View)发出Action,发出方式就用到了dispatch方法。

    2、 然后,Store自动调用Reducer,并且传入两个参数:当前State和收到的Action,Reducer会返回新的State

    3、 State一旦有变化,Store就会调用监听函数,来更新View。

    到这儿为止,一次用户交互流程结束。可以看到,在整个流程中数据都是单向流动的,这种方式保证了流程的清晰。

    redux原理详解

    4、String类的常用方法有那些?

    1、 charAt:返回指定索引处的字符

    2、 indexOf():返回指定字符的索引

    3、 replace():字符串替换

    4、 trim():去除字符串两端空白

    5、 split():分割字符串,返回一个分割后的字符串数组

    6、 getBytes():返回字符串的byte类型数组

    7、 length():返回字符串长度

    8、 toLowerCase():将字符串转成小写字母

    9、 toUpperCase():将字符串转成大写字符

    10、 substring():截取字符串

    11、 format():格式化字符串

    12、 equals():字符串比较

    5、请你谈谈对OOM的认识

    OOM是非常严重的问题,除了程序计数器,其他内存区域都有溢出的风险。和我们平常工作最密切的,就是堆溢出。另外,元空间在方法区内容非常多的情况下也会溢出。还有就是栈溢出,这个通常影响比较小。堆外也有溢出的可能,这个就比较难排查一些。

    6、ParNew 垃圾收集器(Serial+多线程)

    ParNew 垃圾收集器其实是 Serial 收集器的多线程版本,也使用复制算法,除了使用多线程进行垃圾收集之外,其余的行为和 Serial 收集器完全一样, ParNew 垃圾收集器在垃圾收集过程中同样也要暂停所有其他的工作线程。

    ParNew 收集器默认开启和 CPU 数目相同的线程数,可以通过-XX:ParallelGCThreads 参数来限制垃圾收集器的线程数。【Parallel:平行的】

    ParNew 虽然是除了多线程外和Serial 收集器几乎完全一样,但是ParNew垃圾收集器是很多 java虚拟机运行在 Server 模式下新生代的默认垃圾收集器。

    7、Java 中如何格式化一个日期?如格式化为 ddMMyyyy 的形式?

    http://javarevisited.blogspot.com/2011/09/convert-date-to-string-simpledateformat.html

    Java 中,可以使用 SimpleDateFormat 类或者 joda-time 库来格式日期。DateFormat 类允许你使用多种流行的格式来格式化日期。参见中的示例代码,代码中演示了将日期格式化成不同的格式,如 dd-MM-yyyy 或 ddMMyyyy。

    8、什么是Java虚拟机

    任何一种可以运行Java字节码的软件均可看成是Java的虚拟机(JVM)

    9、Java 中的同步集合与并发集合有什么区别?

    同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合,不过并发集合的可扩展性更高。在 Java1.5 之前程序员们只有同步集合来用且在多线程并发的时候会导致争用,阻碍了系统的扩展性。Java5 介绍了并发集合像ConcurrentHashMap,不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。

    10、适配器模式和代理模式之前有什么不同?

    这个问题与前面的类似,适配器模式和代理模式的区别在于他们的意图不同。由于适配器模式和代理模式都是封装真正执行动作的类,因此结构是一致的,但是适配器模式用于接口之间的转换,而代理模式则是增加一个额外的中间层,以便支持分配、控制或智能访问。

    1、说说G1垃圾收集器的工作原理

    优点:指定最大停顿时间、分Region的内存布局、按收益动态确定回收集

    1、 G1开创的基于Region的堆内存布局是它能够实现这个目标的关键。虽然G1也仍是遵循分代收集理论设计的,但其堆内存的布局与其他收集器有非常明显的差异:G1不再坚持固定大小以及固定数量的分代区域划分,而是把连续的Java堆划分为多个大小相等的独立区域(Region),每一个Region都可以根据需要,扮演新生代的Eden空间、Survivor空间,或者老年代空间。收集器能够对扮演不同角色的Region采用不同的策略去处理,这样无论是新创建的对象还是已经存活了一段时间、熬过多次收集的旧对象都能获取很好的收集效果。

    2、 虽然G1仍然保留新生代和老年代的概念,但新生代和老年代不再是固定的了,它们都是一系列区域(不需要连续)的动态集合。G1收集器之所以能建立可预测的停顿时间模型,是因为它将Region作为单次回收的最小单元,即每次收集到的内存空间都是Region大小的整数倍,这样可以有计划地避免在整个Java堆中进行全区域的垃圾收集。更具体的处理思路是让G1收集器去跟踪各个Region里面的垃圾堆积的“价值”大小,价值即回收所获得的空间大小以及回收所需时间的经验值,然后在后台维护一个优先级列表,每次根据用户设定允许的收集停顿时间(使用参数-XX:MaxGCPauseMillis指定,默认值是200毫秒),优先处理回收价值收益最大的那些Region,这也就是“Garbage First”名字的由来。这种使用Region划分内存空间,以及具有优先级的区域回收方式,保证了G1收集器在有限的时间内获取尽可能高的收集效率。

    3、 G1收集器的运作过程大致可划分为以下四个步骤:·初始标记 (Initial Marking):仅仅只是标记一下GC Roots能直接关联到的对象,并且修改TAMS指针的值,让下一阶段用户线程并发运行时,能正确地在可用的Region中分配新对象。这个阶段需要停顿线程,但耗时很短,而且是借用进行Minor GC的时候同步完成的,所以G1收集器在这个阶段实际并没有额外的停顿。·并发标记 (Concurrent Marking):从GC Root开始对堆中对象进行可达性分析,递归扫描整个堆里的对象图,找出要回收的对象,这阶段耗时较长,但可与用户程序并发执行。当对象图扫描完成以后,还要重新处理SATB记录下的在并发时有引用变动的对象。·最终标记 (Final Marking):对用户线程做另一个短暂的暂停,用于处理并发阶段结束后仍遗留下来的最后那少量的SATB记录。·筛选回收 (Live Data Counting and Evacuation):负责更新Region的统计数据,对各个Region的回收价值和成本进行排序,根据用户所期望的停顿时间来制定回收计划,可以自由选择任意多个Region构成回收集,然后把决定回收的那一部分Region的存活对象复制到空的Region中,再清理掉整个旧Region的全部空间。这里的操作涉及存活对象的移动,是必须暂停用户线程,由多条收集器线程并行完成的。从上述阶段的描述可以看出,G1收集器除了并发标记外,其余阶段也是要完全暂停用户线程的 。

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

    JRE 代表 Java 运行时(Java run-time),是运行 Java 引用所必须的。JDK 代表 Java 开发工具(Java development kit),是 Java 程序的开发工具,如 Java编译器,它也包含 JRE。JVM 代表 Java 虚拟机(Java virtual machine),它的责任是运行 Java 应用。JIT 代表即时编译(Just In Time compilation),当代码执行的次数超过一定的阈值时,会将 Java 字节码转换为本地代码,如,主要的热点代码会被准换为本地代码,这样有利大幅度提高 Java 应用的性能。

    3、当父类引用指向子类对象的时候,子类重写了父类方法和属性,那么当访问属性的时候,访问是谁的属性?调用方法时,调用的是谁的方法?

    子类重写了父类方法和属性,访问的是父类的属性,调用的是子类的方法

    4、堆溢出的原因?

    堆用于存储对象实例,只要不断创建对象并保证 GC Roots 到对象有可达路径避免垃圾回收,随着对象数量的增加,总容量触及最大堆容量后就会 OOM,例如在 while 死循环中一直 new 创建实例。

    堆 OOM 是实际应用中最常见的 OOM,处理方法是通过内存映像分析工具对 Dump 出的堆转储快照分析,确认内存中导致 OOM 的对象是否必要,分清到底是内存泄漏还是内存溢出。

    如果是内存泄漏,通过工具查看泄漏对象到 GC Roots 的引用链,找到泄露对象是通过怎样的引用路径、与哪些 GC Roots 关联才导致无法回收,一般可以准确定位到产生内存泄漏代码的具***置。

    如果不是内存泄漏,即内存中对象都必须存活,应当检查 JVM 堆参数,与机器内存相比是否还有向上调整的空间。再从代码检查是否存在某些对象生命周期过长、持有状态时间过长、存储结构设计不合理等情况,尽量减少程序运行期的内存消耗。

    5、说一下 runnable 和 callable 有什么区别

    相同点:

    1、 都是接口

    2、 都可以编写多线程程序

    3、 都采用Thread.start()启动线程

    主要区别:

    Runnable 接口 run 方法无返回值;Callable 接口 call 方法有返回值,是个泛型,和Future、FutureTask配合可以用来获取异步执行的结果

    Runnable 接口 run 方法只能抛出运行时异常,且无法捕获处理;Callable 接口 call 方法允许抛出异常,可以获取异常信息 注:Callalbe接口支持返回执行结果,需要调用FutureTask.get()得到,此方法会阻塞主进程的继续往下执行,如果不调用不会阻塞。

    6、JVM 类加载机制

    JVM 类加载机制分为五个部分:加载,验证,准备,解析,初始化。

    加载

    加载是类加载过程中的一个阶段, 这个阶段会在内存中生成一个代表这个类的 java.lang.Class 对象, 作为方法区这个类的各种数据的入口。注意这里不一定非得要从一个 Class 文件获取,这里既可以从 ZIP 包中读取(比如从 jar 包和 war 包中读取),也可以在运行时计算生成(动态代理),也可以由其它文件生成(比如将 JSP 文件转换成对应的 Class 类)。

    验证

    这一阶段的主要目的是为了确保 Class 文件的字节流中包含的信息是否符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。

    准备

    准备阶段是正式为类变量分配内存并设置类变量的初始值阶段,即在方法区中分配这些变量所使用的内存空间。注意这里所说的初始值概念,比如一个类变量定义为:

    实际上变量 v 在准备阶段过后的初始值为 0 而不是 8080, 将 v 赋值为 8080 的 put static 指令是程序被编译后, 存放于类构造器方法之中。

    但是注意如果声明为:

    public static final int v = 8080;

    在编译阶段会为 v 生成 ConstantValue 属性,在准备阶段虚拟机会根据 ConstantValue 属性将 v赋值为 8080。

    解析

    解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的

    public static int v = 8080;

    实际上变量 v 在准备阶段过后的初始值为 0 而不是 8080, 将 v 赋值为 8080 的 put static 指令是程序被编译后, 存放于类构造器方法之中。但是注意如果声明为:

    在编译阶段会为 v 生成 ConstantValue 属性,在准备阶段虚拟机会根据 ConstantValue 属性将 v赋值为 8080。

    解析

    解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的

    public static final int v = 8080;

    在编译阶段会为 v 生成 ConstantValue 属性,在准备阶段虚拟机会根据 ConstantValue 属性将 v赋值为 8080。

    解析

    解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的:

    1、 CONSTANT_Class_info

    2、 CONSTANT_Field_info

    3、 CONSTANT_Method_info

    等类型的常量。

    符号引用

    符号引用与虚拟机实现的布局无关, 引用的目标并不一定要已经加载到内存中。各种虚拟机实现的内存布局可以各不相同,但是它们能接受的符号引用必须是一致的,因为符号引用的字面量形式明确定义在 Java 虚拟机规范的 Class 文件格式中。

    直接引用

    直接引用可以是指向目标的指针,相对偏移量或是一个能间接定位到目标的句柄。如果有了直接引用,那引用的目标必定已经在内存中存在。

    初始化

    初始化阶段是类加载最后一个阶段,前面的类加载阶段之后,除了在加载阶段可以自定义类加载器以外,其它操作都由 JVM 主导。到了初始阶段,才开始真正执行类中定义的 Java 程序代码。

    类构造器

    初始化阶段是执行类构造器方法的过程。方法是由编译器自动收集类中的类变量的赋值操作和静态语句块中的语句合并而成的。虚拟机会保证子方法执行之前,父类的方法已经执行完毕, 如果一个类中没有对静态变量赋值也没有静态语句块,那么编译器可以不为这个类生成()方法。

    注意以下几种情况不会执行类初始化:

    1、 通过子类引用父类的静态字段,只会触发父类的初始化,而不会触发子类的初始化。

    2、 定义对象数组,不会触发该类的初始化。

    3、 常量在编译期间会存入调用类的常量池中,本质上并没有直接引用定义常量的类,不会触发定义常量所在的类。

    4、 通过类名获取 Class 对象,不会触发类的初始化。

    5、 通过 Class.forName 加载指定类时,如果指定参数 initialize 为 false 时,也不会触发类初始化,其实这个参数是告诉虚拟机,是否要对类进行初始化。

    6、 通过 ClassLoader 默认的 loadClass 方法,也不会触发初始化动作。

    7、怎么打破双亲委派模型?

    打破双亲委派机制则不仅要继承ClassLoader类,还要重写loadClass和findClass方法。

    8、垃圾收集算法

    GC最基础的算法有三种:标记 -清除算法、复制算法、标记-压缩算法,我们常用的垃圾回收器一般都采用分代收集算法。

    标记 -清除算法

    “标记-清除”(Mark-Sweep)算法,如它的名字一样,算法分为“标记”和“清除”两个阶段:首先标记出所有需要回收的对象,在标记完成后统一回收掉所有被标记的对象。

    复制算法

    “复制”(Copying)的收集算法,它将可用内存按容量划分为大小相等的两块,每次只使用其中的一块。当这一块的内存用完了,就将还存活着的对象复制到另外一块上面,然后再把已使用过的内存空间一次清理掉。

    标记-压缩算法

    标记过程仍然与“标记-清除”算法一样,但后续步骤不是直接对可回收对象进行清理,而是让所有存活的对象都向一端移动,然后直接清理掉端边界以外的内存

    分代收集算法

    “分代收集”(Generational Collection)算法,把Java堆分为新生代和老年代,这样就可以根据各个年代的特点采用最适当的收集算法

    9、你有哪些手段来排查 OOM 的问题?

    1、 增加两个参数 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof,当 OOM 发生时自动 dump 堆内存信息到指定目录

    2、 同时 jstat 查看监控 JVM 的内存和 GC 情况,先观察问题大概出在什么区域

    3、 使用 MAT 工具载入到 dump 文件,分析大对象的占用情况,比如 HashMap 做缓存未清理,时间长了就会内存溢出,可以把改为弱引用

    10、假设把实例化的数组的变量当成方法参数,当方法执行的时候改变了数组内的元素,那么在方法外,数组元素有发生改变吗?

    改变了,因为传递是对象的引用,操作的是引用所指向的对象

    1、怎么获取 Java 程序使用的内存?堆使用的百分比?

    可以通过 java.lang.Runtime 类中与内存相关方法来获取剩余的内存,总内存及最大堆内存。通过这些方法你也可以获取到堆使用的百分比及堆内存的剩余空间。Runtime.freeMemory() 方法返回剩余空间的字节数,Runtime.totalMemory() 方法总内存的字节数,Runtime.maxMemory() 返回最大内存的字节数。

    2、强引用、软引用、弱引用、虚引用是什么?

    普通的对象引用关系就是强引用

    软引用用于维护一些可有可无的对象。只有在内存不足时,系统则会回收软引用对象,如果回收了软引用对象之后仍然没有足够的内存,才会抛出内存溢出异常。

    弱引用对象相比较软引用,要更加无用一些,它拥有更短的生命周期。当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。

    虚引用是一种形同虚设的引用,在现实场景中用的不是很多,它主要用来跟踪对象被垃圾回收的活动。

    3、G1 收集器

    Garbage first 垃圾收集器是目前垃圾收集器理论发展的最前沿成果,相比与 CMS 收集器, G1 收集器两个最突出的改进是:

    1、 基于标记-整理算法,不产生内存碎片。

    2、 可以非常精确控制停顿时间,在不牺牲吞吐量前提下,实现低停顿垃圾回收。G1 收集器避免全区域垃圾收集,它把堆内存划分为大小固定的几个独立区域,并且跟踪这些区域的垃圾收集进度,同时在后台维护一个优先级列表,每次根据所允许的收集时间, 优先回收垃圾最多的区域。区域划分和优先级区域回收机制,确保 G1 收集器可以在有限时间获得最高的垃圾收集效率

    4、运行时常量池溢出的原因?

    String 的 intern 方法是一个本地方法,作用是如果字符串常量池中已包含一个等于此 String 对象的字符串,则返回池中这个字符串的 String 对象的引用,否则将此 String 对象包含的字符串添加到常量池并返回此 String 对象的引用。

    在 JDK6 及之前常量池分配在永久代,因此可以通过 -XX:PermSize 和 -XX:MaxPermSize 限制永久代大小,间接限制常量池。在 while 死循环中调用 intern 方法导致运行时常量池溢出。在 JDK7 后不会出现该问题,因为存放在永久代的字符串常量池已经被移至堆中。

    5、Java最顶级的父类是哪个?

    Object

    6、JVM 监控与分析工具你用过哪些?介绍一下。

    1、 jps,显示系统所有虚拟机进程信息的命令行工具

    2、 jstat,监视分析虚拟机运行状态的命令行工具

    3、 jinfo,查看和调整虚拟机参数的命令行工具

    4、 jmap,生成虚拟机堆内存转储快照的命令行工具

    5、 jhat,显示和分析虚拟机的转储快照文件的命令行工具

    6、 jstack,生成虚拟机的线程快照的命令行工具

    7、 jcmd,虚拟机诊断工具,JDK 7 提供

    8、 jhsdb,基于服务性代理实现的进程外可视化调试工具,JDK 9 提供

    9、 JConsole,基于JMX的可视化监视和管理工具

    10、 jvisualvm,图形化虚拟机使用情况的分析工具

    11、 Java Mission Control,监控和管理 Java 应用程序的工具

    1、 MAT,Memory Analyzer Tool,虚拟机内存分析工具

    2、 vjtools,唯品会的包含核心类库与问题分析工具

    3、 arthas,阿里开源的 Java 诊断工具

    4、 greys,JVM进程执行过程中的异常诊断工具

    5、 GCHisto,GC 分析工具

    6、 GCViewer,GC 日志文件分析工具

    7、 GCeasy,在线版 GC 日志文件分析工具

    8、 JProfiler,检查、监控、追踪 Java 性能的工具

    9、 BTrace,基于动态字节码修改技术(Hotswap)实现的Java程序追踪与分析工具

    下面可以重点体验下:

    JDK 自带的命令行工具方便快捷,不是特别复杂的问题可以快速定位;

    阿里的 arthas 命令行也不错;

    可视化工具 MAT、JProfiler 比较强大。

    7、JVM新生代中为什么要分为Eden和Survivor?

    如果没有Survivor,Eden区每进行一次Minor GC,存活的对象就会被送到老年代。老年代很快被填满,触发Major GC.老年代的内存空间远大于新生代,进行一次Full GC消耗的时间比Minor GC长得多,所以需要分为Eden和Survivor。Survivor的存在意义,就是减少被送到老年代的对象,进而减少Full GC的发生,Survivor的预筛选保证,只有经历16次Minor GC还能在新生代中存活的对象,才会被送到老年代。设置两个Survivor区最大的好处就是解决了碎片化,刚刚新建的对象在Eden中,经历一次Minor GC,Eden中的存活对象就会被移动到第一块survivor space S0,Eden被清空;等Eden区再满了,就再触发一次Minor GC,Eden和S0中的存活对象又会被复制送入第二块survivor space S1(这个过程非常重要,因为这种复制算法保证了S1中来自S0和Eden两部分的存活对象占用连续的内存空间,避免了碎片化的发生)

    8、Parallel Old 收集器(多线程标记整理算法)

    Parallel Old 收集器是Parallel Scavenge的年老代版本,使用多线程的标记-整理算法,在 JDK1.6才开始提供。

    在 JDK1.6 之前,新生代使用 ParallelScavenge 收集器只能搭配年老代的 Serial Old 收集器,只能保证新生代的吞吐量优先,无法保证整体的吞吐量, Parallel Old 正是为了在年老代同样提供吞吐量优先的垃圾收集器, 如果系统对吞吐量要求比较高,可以优先考虑新生代Parallel Scavenge和年老代 Parallel Old 收集器的搭配策略。

    9、Java线程具有五中基本状态

    1、 新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();

    2、 就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;

    3、 运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就 绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;

    4、 阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被CPU调用以进入到运行状态。

    根据阻塞产生的原因不同,阻塞状态又可以分为三种:

    1、 等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;

    2、 同步阻塞:线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;

    3、 其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

    5、 死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

    10、双亲委派模型是什么?

    类加载器具有等级制度但非继承关系,以组合的方式复用父加载器的功能。双亲委派模型要求除了顶层的启动类加载器外,其余类加载器都应该有自己的父加载器。

    一个类加载器收到了类加载请求,它不会自己去尝试加载,而将该请求委派给父加载器,每层的类加载器都是如此,因此所有加载请求最终都应该传送到启动类加载器,只有当父加载器反馈无法完成请求时,子加载器才会尝试。

    类跟随它的加载器一起具备了有优先级的层次关系,确保某个类在各个类加载器环境中都是同一个,保证程序的稳定性。

    更多Java 面试题70道

    01、java中有几种方法可以实现一个线程?

    02、Java 中的 HashSet,内部是如何工作的?

    03、redux的工作流程?

    04、String类的常用方法有那些?

    05、请你谈谈对OOM的认识

    06、ParNew 垃圾收集器(Serial+多线程)

    07、Java 中如何格式化一个日期?如格式化为 ddMMyyyy 的形式?

    08、什么是Java虚拟机

    09、Java 中的同步集合与并发集合有什么区别?

    10、适配器模式和代理模式之前有什么不同?

    11、说说G1垃圾收集器的工作原理

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

    13、当父类引用指向子类对象的时候,子类重写了父类方法和属性,那么当访问属性的时候,访问是谁的属性?调用方法时,调用的是谁的方法?

    14、堆溢出的原因?

    15、说一下 runnable 和 callable 有什么区别

    16、JVM 类加载机制

    17、怎么打破双亲委派模型?

    18、垃圾收集算法

    19、你有哪些手段来排查 OOM 的问题?

    20、假设把实例化的数组的变量当成方法参数,当方法执行的时候改变了数组内的元素,那么在方法外,数组元素有发生改变吗?

    21、怎么获取 Java 程序使用的内存?堆使用的百分比?

    22、强引用、软引用、弱引用、虚引用是什么?

    23、G1 收集器

    24、运行时常量池溢出的原因?

    25、Java最顶级的父类是哪个?

    26、JVM 监控与分析工具你用过哪些?介绍一下。

    27、JVM新生代中为什么要分为Eden和Survivor?

    28、Parallel Old 收集器(多线程标记整理算法)

    09、Java线程具有五中基本状态

    30、双亲委派模型是什么?

    31、什么是方法内联?

    32、你对线程优先级的理解是什么?

    33、Java是否需要开发人员回收内存垃圾吗?

    34、说说Java 垃圾回收机制

    35、volatile 变量和 atomic 变量有什么不同?

    36、JVM 内存区域

    37、JVM 有哪些运行时内存区域?

    38、Spring中Bean的作用域有哪些?

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

    40、什么是建造者模式

    41、为什么HashMap中String、Integer这样的包装类适合作为K?

    42、常见的计算机网络协议有那些?

    43、一个线程运行时发生异常会怎样?

    44、遍历一个 List 有哪些不同的方式?每种方法的实现原理是什么?Java 中 List 遍历的最佳实践是什么?

    45、StringBuffer,Stringbuilder有什么区别?

    46、什么是线程池?

    47、JDBC操作的步骤

    48、说一下 JVM 调优的工具?

    49、JVM 提供的常用工具

    50、SynchronizedMap和ConcurrentHashMap有什么区别?

    51、有哪些类加载器?

    52、mixin、hoc、render props、react-hooks的优劣如何?

    53、什么是Executors?

    54、如何判断对象是否是垃圾?

    55、volatile 类型变量提供什么保证?

    56、在 Java 程序中怎么保证多线程的运行安全?

    57、线上常用的 JVM 参数有哪些?

    58、volatile 关键字的作用

    59、解释何时在Tomcat使用SSL ?

    60、使用js获取一个表单元素

    61、Sql优化有那些方法?

    62、用 Java 写一个线程安全的单例模式(Singleton)?

    63、在 Java 中,对象什么时候可以被垃圾回收?

    64、线程的 run()和 start()有什么区别?

    65、重排序实际执行的指令步骤

    66、Java中异常分为哪两种?

    67、什么是并发容器的实现?

    68、创建线程的四种方式

    69、Java 中,直接缓冲区与非直接缓冲器有什么区别?

    70、poll() 方法和 remove() 方法的区别?

    如果不背 Java面试题的答案,肯定面试会挂!

    这套Java面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的

    展开全文
  • 发现网上很多Java面试都没有答案,所以花了很长时间搜集整理出来了这套Java面试大全,希望对大家有帮助哈~ Java面试永远是程序员迈向成功的第一个门槛,想要面试成功,各种面试的洗礼是必不可少的,下面就来...

    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~

    Java面试永远是程序员迈向成功的第一个门槛,想要面试成功,各种面试题的洗礼是必不可少的,下面就来看看小编精心整理的一些Java工程师面试题及答案吧。

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的。

    这套Java面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的

    1、64 位 JVM 中,int 的长度是多数?

    Java 中,int 类型变量的长度是一个固定值,与平台无关,都是 32 位。意思就是说,在 32 位 和 64 位 的 Java 虚拟机中,int 类型的长度是相同的。

    2、线程的状态

    1、 新建(new):新创建了一个线程对象。

    2、 就绪(可运行状态)(runnable):线程对象创建后,当调用线程对象的 start()方法,该线程处于就绪状态,等待被线程调度选中,获取cpu的使用权。

    3、 运行(running):可运行状态(runnable)的线程获得了cpu时间片(timeslice),执行程序代码。注:就绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;

    4、 阻塞(block):处于运行状态中的线程由于某种原因,暂时放弃对 CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被 CPU 调用以进入到运行状态。

    阻塞的情况分三种:

    1、 等待阻塞:

    运行状态中的线程执行 wait()方法,JVM会把该线程放入等待队列(waitting queue)中,使本线程进入到等待阻塞状态;

    2、 同步阻塞:

    线程在获取 synchronized 同步锁失败(因为锁被其它线程所占用),,则JVM会把该线程放入锁池(lock pool)中,线程会进入同步阻塞状态;

    3、 其他阻塞:

    通过调用线程的 sleep()或 join()或发出了 I/O 请求时,线程会进入到阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O 处理完毕时,线程重新转入就绪状态。

    4、 死亡(dead)(结束):

    线程run()、main()方法执行结束,或者因异常退出了run()方法,则该线程结束生命周期。死亡的线程不可再次复生。

    3、计算机网络有几层?

    1、 应用层

    2、 表示层

    3、 会话层

    4、 传输层

    5、 网络层

    6、 数据链路层

    7、 物理层

    8、 (物理层是最底层,应用层是最高层)

    4、模块化编程与热插拔

    OSGi 旨在为实现 Java 程序的模块化编程提供基础条件,基于 OSGi 的程序很可能可以实现模块级的热插拔功能,当程序升级更新时,可以只停用、重新安装然后启动程序的其中一部分,这对企业级程序开发来说是非常具有诱惑力的特性。

    OSGi 描绘了一个很美好的模块化开发目标,而且定义了实现这个目标的所需要服务与架构,同时也有成熟的框架进行实现支持。但并非所有的应用都适合采用 OSGi 作为基础架构,它在提供强大功能同时,也引入了额外的复杂度,因为它不遵守了类加载的双亲委托模型。

    5、我们能自己写一个容器类,然后使用 for-each 循环码?

    可以,你可以写一个自己的容器类。如果你想使用 Java 中增强的循环来遍历,你只需要实现 Iterable 接口。如果你实现 Collection 接口,默认就具有该属性。

    6、单例防止反射漏洞攻击

    private static boolean flag = false; private Singleton() { if (flag == false) { flag = !flag; } else { throw new RuntimeException("单例模式被侵犯!"); } } public static void main(String[] args) { }

    7、工作中常用的 JVM 配置参数有哪些?

    Java 8 为例

    日志

    1、 -XX:+PrintFlagsFinal,打印JVM所有参数的值

    2、 -XX:+PrintGC,打印GC信息

    3、 -XX:+PrintGCDetails,打印GC详细信息

    4、 -XX:+PrintGCTimeStamps,打印GC的时间戳

    5、 -Xloggc:filename,设置GC log文件的位置

    6、 -XX:+PrintTenuringDistribution,查看熬过收集后剩余对象的年龄分布信息

    内存设置

    1、 -Xms,设置堆的初始化内存大小

    2、 -Xmx,设置堆的最大内存

    3、 -Xmn,设置新生代内存大小

    4、 -Xss,设置线程栈大小

    5、 -XX:NewRatio,新生代与老年代比值

    6、 -XX:SurvivorRatio,新生代中Eden区与两个Survivor区的比值,默认为8,即Eden:Survivor:Survivor=8:1:1

    7、 -XX:MaxTenuringThreshold,从年轻代到老年代,最大晋升年龄。CMS 下默认为 6,G1 下默认为 15

    8、 -XX:MetaspaceSize,设置元空间的大小,第一次超过将触发 GC

    9、 -XX:MaxMetaspaceSize,元空间最大值

    10、 -XX:MaxDirectMemorySize,用于设置直接内存的最大值,限制通过 DirectByteBuffer 申请的内存

    11、 -XX:ReservedCodeCacheSize,用于设置 JIT 编译后的代码存放区大小,如果观察到这个值有限制,可以适当调大,一般够用即可

    设置垃圾收集相关

    1、 -XX:+UseSerialGC,设置串行收集器

    2、 -XX:+UseParallelGC,设置并行收集器

    3、 -XX:+UseConcMarkSweepGC,使用CMS收集器

    4、 -XX:ParallelGCThreads,设置Parallel GC的线程数

    5、 -XX:MaxGCPauseMillis,GC最大暂停时间 ms

    6、 -XX:+UseG1GC,使用G1垃圾收集器

    CMS 垃圾回收器相关

    1、 -XX:+UseCMSInitiatingOccupancyOnly

    2、 -XX:CMSInitiatingOccupancyFraction,与前者配合使用,指定MajorGC的发生时机

    3、 -XX:+ExplicitGCInvokesConcurrent,代码调用 System.gc() 开始并行 FullGC,建议加上这个参数

    4、 -XX:+CMSScavengeBeforeRemark,表示开启或关闭在 CMS 重新标记阶段之前的清除(YGC)尝试,它可以降低 remark 时间,建议加上

    5、 -XX:+ParallelRefProcEnabled,可以用来并行处理 Reference,以加快处理速度,缩短耗时

    G1 垃圾回收器相关

    1、 -XX:MaxGCPauseMillis,用于设置目标停顿时间,G1 会尽力达成

    2、 -XX:G1HeapRegionSize,用于设置小堆区大小,建议保持默认

    3、 -XX:InitiatingHeapOccupancyPercent,表示当整个堆内存使用达到一定比例(默认是 45%),并发标记阶段就会被启动

    4、 -XX:ConcGCThreads,表示并发垃圾收集器使用的线程数量,默认值随 JVM 运行的平台不同而变动,不建议修改

    参数查询官网地址:

    https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html

    建议面试时最好能记住 CMS 和 G1的参数,特点突出使用较多,被问的概率大

    8、面向对象的特征有哪些方面?

    面向对象的特征主要有以下几个方面:

    1、 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。

    2、 继承:继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类(超类、基类);得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段(如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分)。

    3、 封装:通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装;我们编写一个类就是对数据和数据操作的封装。可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口(可以想想普通洗衣机和全自动洗衣机的差别,明显全自动洗衣机封装更好因此操作起来更简单;我们现在使用的智能手机也是封装得足够好的,因为几个按键就搞定了所有的事情)。

    4、 多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当A系统访问B系统提供的服务时,B系统有多种提供服务的方式,但一切对A系统来说都是透明的(就像电动剃须刀是A系统,它的供电系统是B系统,B系统可以使用电池供电或者用交流电,甚至还有可能是太阳能,A系统只会通过B类对象调用供电的方法,但并不知道供电系统的底层实现是什么,究竟通过何种方式获得了动力)。方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:1)、方法重写(子类继承父类并重写父类中已有的或抽象的方法);2)、对象造型(用父类型引用引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

    9、是否了解连接池,使用连接池有什么好处?

    数据库连接是非常消耗资源的,影响到程序的性能指标。连接池是用来分配、管理、释放数据库连接的,可以使应用程序重复使用同一个数据库连接,而不是每次都创建一个新的数据库连接。通过释放空闲时间较长的数据库连接避免数据库因为创建太多的连接而造成的连接遗漏问题,提高了程序性能。

    10、JVM 选项 -XX:+UseCompressedOops 有什么作用?为什么要使用

    当你将你的应用从 32 位的 JVM 迁移到 64 位的 JVM 时,由于对象的指针从32 位增加到了 64 位,因此堆内存会突然增加,差不多要翻倍。这也会对 CPU缓存(容量比内存小很多)的数据产生不利的影响。因为,迁移到 64 位的 JVM主要动机在于可以指定最大堆大小,通过压缩OOP 可以节省一定的内存。通过-XX:+UseCompressedOops 选项,JVM 会使用 32 位的 OOP,而不是 64 位的 OOP。

    11、创建socket通讯的步骤?

    1、 服务器程序创建一个ServerSocket,然后再用accept方法等待客户来连接

    2、 客户端程序创建一个Socket并请求与服务器建立连接

    3、 服务器接收客户的连接请求,并创建一个新的Socket与该客户建立专线连接

    4、 刚才建立了连接的两个Socket在一个线程上对话

    5、 服务器开始等待新的连接请求

    12、Java 中 sleep 方法和 wait 方法的区别?

    虽然两者都是用来暂停当前运行的线程,但是 sleep() 实际上只是短暂停顿,因为它不会释放锁,而 wait() 意味着条件等待,这就是为什么该方法要释放锁,因为只有这样,其他等待的线程才能在满足条件时获取到该锁。

    13、程序计数器(线程私有)

    一块较小的内存空间, 是当前线程所执行的字节码的行号指示器,每条线程都要有一个独立的程序计数器,这类内存也称为“线程私有” 的内存。

    正在执行 java 方法的话,计数器记录的是虚拟机字节码指令的地址(当前指令的地址) 。如果还是 Native 方法,则为空。

    这个内存区域是唯一一个在虚拟机中没有规定任何 OutOfMemoryError 情况的区域。

    14、什么是线程调度器(Thread Scheduler)和时间分片(Time Slicing)?

    线程调度器是一个操作系统服务,它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它,它的执行便依赖于线程调度器的实现。时间分片是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制,所以由应用程序来控制它是更好的选择(也就是说不要让你的程序依赖于线程的优先级)。

    15、迭代器 Iterator 是什么?

    Iterator 接口提供遍历任何 Collection 的接口。我们可以从一个 Collection 中使用迭代器方法来获取迭代器实例。迭代器取代了 Java 集合框架中的 Enumeration,迭代器允许调用者在迭代过程中移除元素。

    因为所有Collection接继承了Iterator迭代器

    16、线程的 sleep()方法和 yield()方法有什么区别?

    1、 sleep()方法给其他线程运行机会时不考虑线程的优先级,因此会给低优先级的线程以运行的机会;yield()方法只会给相同优先级或更高优先级的线程以运行的机会;

    2、 线程执行 sleep()方法后转入阻塞(blocked)状态,而执行 yield()方法后转入就绪(ready)状态;

    3、 sleep()方法声明抛出 InterruptedException,而 yield()方法没有声明任何异常;

    4、 sleep()方法比 yield()方法(跟操作系统 CPU 调度相关)具有更好的可移植性,通常不建议使用yield()方法来控制并发线程的执行。

    17、Java 中能创建 volatile 数组吗?

    能,Java 中可以创建 volatile 类型数组,不过只是一个指向数组的引用,而不是整个数组。意思是,如果改变引用指向的数组,将会受到 volatile 的保护,但是如果多个线程同时改变数组的元素,volatile 标示符就不能起到之前的保护作用了。

    18、java中equals方法的用法以及==的用法

    tech.souyunku.com/bluestorm/a…

    19、如何创建一个json对象?

    使用{}实例化一个json对象,json对象多个元素使用逗号隔开,每个元素都是一个键值对

    20、如何判断对象是否是垃圾?

    引用计数:在对象中添加一个引用计数器,如果被引用计数器加 1,引用失效时计数器减 1,如果计数器为 0 则被标记为垃圾。原理简单,效率高,但是在 Java 中很少使用,因为存在对象间循环引用的问题,导致计数器无法清零。

    可达性分析:主流语言的内存管理都使用可达性分析判断对象是否存活。基本思路是通过一系列称为 GC Roots 的根对象作为起始节点集,从这些节点开始,根据引用关系向下搜索,搜索过程走过的路径称为引用链,如果某个对象到 GC Roots 没有任何引用链相连,则会被标记为垃圾。可作为 GC Roots 的对象包括虚拟机栈和本地方法栈中引用的对象、类静态属性引用的对象、常量引用的对象。

    21、抽象工厂模式和原型模式之间的区别?

    抽象工厂模式:通常由工厂方法模式来实现。但一个工厂中往往含有多个工厂方法生成一系列的产品。这个模式强调的是客户代码一次保证只使用一个系列的产品。当要切换为另一个系列的产品,换一个工厂类即可。

    原型模式:工厂方法的最大缺点就是,对应一个继承体系的产品类,要有一个同样复杂的工厂类的继承体系。我们可以把工厂类中的工厂方法放到产品类自身之中吗?如果这样的话,就可以将两个继承体系为一个。这也就是原型模式的思想,原型模式中的工厂方法为clone,它会返回一个拷贝(可以是浅拷贝,也可以是深拷贝,由设计者决定)。为了保证用户代码中到时可以通过指针调用clone来动态绑定地生成所需的具体的类。这些原型对象必须事先构造好。

    原型模式想对工厂方法模式的另一个好处是,拷贝的效率一般对构造的效率要高。

    22、在 Java 程序中怎么保证多线程的运行安全?

    出现线程安全问题的原因一般都是三个原因:

    1、 线程切换带来的原子性问题 解决办法:使用多线程之间同步synchronized或使用锁(lock)。

    2、 缓存导致的可见性问题 解决办法:synchronized、volatile、LOCK,可以解决可见性问题

    3、 编译优化带来的有序性问题 解决办法:Happens-Before 规则可以解决有序性问题

    23、volatile 修饰符的有过什么实践?

    一种实践是用 volatile 修饰 long 和 double 变量,使其能按原子类型来读写。double 和 long 都是64位宽,因此对这两种类型的读是分为两部分的,第一次读取第一个 32 位,然后再读剩下的 32 位,这个过程不是原子的,但 Java 中 volatile 型的 long 或 double 变量的读写是原子的。volatile 修复符的另一个作用是提供内存屏障(memory barrier),例如在分布式框架中的应用。简单的说,就是当你写一个 volatile 变量之前,Java 内存模型会插入一个写屏障(write barrier),读一个 volatile 变量之前,会插入一个读屏障(read barrier)。意思就是说,在你写一个 volatile 域时,能保证任何线程都能看到你写的值,同时,在写之前,也能保证任何数值的更新对所有线程是可见的,因为内存屏障会将其他所有写的值更新到缓存。

    24、Java中各种数据默认值

    1、 Byte,short,int,long默认是都是0

    2、 Boolean默认值是false

    3、 Char类型的默认值是’’

    4、 Float与double类型的默认是0.0

    5、 对象类型的默认值是null

    25、说说Java 垃圾回收机制

    在 Java 中,程序员是不需要显示的去释放一个对象的内存的,而是由虚拟机自行执行。在 JVM 中,有一个垃圾回收线程,它是低优先级的,在正常情况下是不会执行的,只有在虚拟机空闲或者当前堆内存不足时,才会触发执行,扫面那些没有被任何引用的对象,并将它们添加到要回收的集合中,进行回收。

    26、有没有可能两个不相等的对象有有相同的 hashcode?

    有可能,两个不相等的对象可能会有相同的 hashcode 值,这就是为什么在 hashmap 中会有冲突。相等 hashcode 值的规定只是说如果两个对象相等,必须有相同的hashcode 值,但是没有关于不相等对象的任何规定。

    27、synchronized 和 Lock 有什么区别?

    1、 首先synchronized是Java内置关键字,在JVM层面,Lock是个Java类;

    2、 synchronized 可以给类、方法、代码块加锁;而 lock 只能给代码块加锁。

    3、 synchronized 不需要手动获取锁和释放锁,使用简单,发生异常会自动释放锁,不会造成死锁;而 lock 需要自己加锁和释放锁,如果使用不当没有 unLock()去释放锁就会造成死锁。

    4、 通过 Lock 可以知道有没有成功获取锁,而 synchronized 却无法办到。

    28、什么是Vector

    Vector与ArrayList一样,也是通过数组实现的,不同的是它支持线程的同步,即某一时刻只有一个线程能够写Vector,避免多线程同时写而引起的不一致性,但实现同步需要很高的花费,访问它比访问ArrayList慢很多

    ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行复制、移动、代价比较高。因此,它适合随机查找和遍历,不适合插入和删除。ArrayList的缺点是每个元素之间不能有间隔。

    29、对象的访问定位有哪几种方式?

    建立对象就是为了使用对象,我们的Java程序通过栈上的 reference 数据来操作堆上的具体对象。对象的访问方式有虚拟机实现而定,目前主流的访问方式有使用句柄和直接指针2种:

    句柄:如果使用句柄的话,那么Java堆中将会划分出一块内存来作为句柄池,reference 中存储的就是对象的句柄地址,而句柄中包含了对象实例数据与类型数据各自的具体地址信息。

    直接指针:如果使用直接指针访问,那么 Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息,而reference 中存储的直接就是对象的地址。

    这两种对象访问方式各有优势。使用句柄来访问的最大好处是 reference 中存储的是稳定的句柄地址,在对象被移动时只会改变句柄中的实例数据指针,而 reference 本身不需要修改。使用直接指针访问方式最大的好处就是速度快,它节省了一次指针定位的时间开销。

    30、equals 和 == 的区别?#

    通俗点讲:是看看左右是不是一个东西。equals是看看左右是不是长得一样。如何记住嘛。如果单纯是想记住,:等于。equals:相同。两个长得一样的人,只能说长的相同(equals),但是不等于他们俩是一个人。你只要记住equals,==就不用记了。

    术语来讲的区别:

    1、 ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同

    2、 ==是指对内存地址进行比较 equals()是对字符串的内容进行比较3.==指引用是否相同 equals()指的是值是否相同

    31、如何判断一个对象是否存活

    判断一个对象是否存活有两种方法:

    1、 引用计数法

    所谓引用计数法就是给每一个对象设置一个引用计数器,每当有一个地方引用这个对象时,就将计数器加一,引用失效时,计数器就减一。当一个对象的引用计数器为零时,说明此对象没有被引用,也就是“死对象”,将会被垃圾回收、

    引用计数法有一个缺陷就是无法解决循环引用问题,也就是说当对象 A 引用对象 B,对象 B 又引用者对象 A,那么此时 A、B 对象的引用计数器都不为零,也就造成无法完成垃圾回收,所以主流的虚拟机都没有采用这种算法。

    2、 可达性算法(引用链法)

    该算法的思想是:从一个被称为 GC Roots 的对象开始向下搜索,如果一个对象到 GC Roots 没有任何引用链相连时,则说明此对象不可用。

    在 Java 中可以作为 GC Roots 的对象有以下几种:

    1、 虚拟机栈中引用的对象

    2、 方法区类静态属性引用的对象

    3、 方法区常量池引用的对象

    4、 本地方法栈JNI引用的对象

    虽然这些算法可以判定一个对象是否能被回收,但是当满足上述条件时,一个对象比不一定会被回收。当一个对象不可达 GC Root 时,这个对象并不会立马被回收,而是出于一个死缓的阶段,若要被真正的回收需要经历两次标记、

    如果对象在可达性分析中没有与 GC Root 的引用链,那么此时就会被第一次标记并且进行一次筛选,筛选的条件是是否有必要执行 finalize() 方法。当对象没有覆盖 finalize() 方法或者已被虚拟机调用过,那么就认为是没必要的。 如果该对象有必要执行 finalize() 方法,那么这个对象将会放在一个称为 F-Queue 的对队列中,虚拟机会触发一个 Finalize() 线程去执行,此线程是低优先级的,并且虚拟机不会承诺一直等待它运行完,这是因为如果 finalize() 执行缓慢或者发生了死锁,那么就会造成 F-Queue 队列一直等待,造成了内存回收系统的崩溃。GC 对处于 F-Queue 中的对象进行第二次被标记,这时,该对象将被移除” 即将回收” 集合,等待回收。

    32、Int与integer的区别

    Integer是int的包装类型。

    Int的默认值是0,integer的默认值是null

    33、Servlet的生命周期?

    1、 加载:判断servlet实例是否存在,如果不存在,就加载serlvet

    2、 实例化:

    3、 初始化

    4、服务

    5、销毁

    34、怎么唤醒一个阻塞的线程

    如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接接触到操作系统。

    35、虚拟DOM的优劣如何?

    优点:

    1、 保证性能下限: 虚拟DOM可以经过diff找出最小差异,然后批量进行patch,这种操作虽然比不上手动优化,但是比起粗暴的DOM操作性能要好很多,因此虚拟DOM可以保证性能下限

    2、 无需手动操作DOM: 虚拟DOM的diff和patch都是在一次更新中自动进行的,我们无需手动操作DOM,极大提高开发效率

    3、 跨平台: 虚拟DOM本质上是JavaScript对象,而DOM与平台强相关,相比之下虚拟DOM可以进行更方便地跨平台操作,例如服务器渲染、移动端开发等等

    缺点:

    无法进行极致优化: 在一些性能要求极高的应用中虚拟DOM无法进行针对性的极致优化,比如VScode采用直接手动操作DOM的方式进行极端的性能优化

    36、双亲委派模型是什么?

    类加载器具有等级制度但非继承关系,以组合的方式复用父加载器的功能。双亲委派模型要求除了顶层的启动类加载器外,其余类加载器都应该有自己的父加载器。

    一个类加载器收到了类加载请求,它不会自己去尝试加载,而将该请求委派给父加载器,每层的类加载器都是如此,因此所有加载请求最终都应该传送到启动类加载器,只有当父加载器反馈无法完成请求时,子加载器才会尝试。

    类跟随它的加载器一起具备了有优先级的层次关系,确保某个类在各个类加载器环境中都是同一个,保证程序的稳定性。

    37、静态嵌套类(Static Nested Class)和内部类(Inner Class)的不同?

    Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化,其语法看起来挺诡异的,如下所示。

    /  * 扑克类(一副扑克)  * @author 骆昊  *  */
    public class Poker {
        private static String[] suites = {
            "黑桃", "红桃", "草花", "方块"
        };
        private static int[] faces = {
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
        };
        private Card[] cards;
        /      * 构造器      *       */
        public Poker() {
            cards = new Card[52];
            for (int i = 0; i < suites.length; i++) {
                for (int j = 0; j < faces.length; j++) {
                    cards[i * 13 + j] = new Card(suites[i], faces[j]);
                }
            }
        }
        /      * 洗牌 (随机乱序)      *       */
        public void shuffle() {
            for (int i = 0, len = cards.length; i < len; i++) {
                int index = (int)(Math.random() * len);
                Card temp = cards[index];
                cards[index] = cards[i];
                cards[i] = temp;
            }
        }
        /      * 发牌      * @param index 发牌的位置      *       */
        public Card deal(int index) {
            return cards[index];
        }
        /      * 卡片类(一张扑克)      * [内部类]      * @author 骆昊      *      */
        public class Card {
            private String suite; // 花色         private int face;       // 点数         
     public Card(String suite, int face) {             this.suite = suite;           
      this.face = face;         }          @Override       
    
      public String toString() {             String faceStr = "";             switch(face) {             case 1: faceStr = "A"; break;             case 11: faceStr = "J"; break;             case 12: faceStr = "Q"; break;             case 13: faceStr = "K"; break;             default: faceStr = String.valueOf(face);             }             return suite + faceStr;         }     } }
            测试代码:
            class PokerTest {
                public static void main(String[] args) {
                    Poker poker = new Poker();
                    poker.shuffle();
                    // 洗牌         Poker.Card c1 = poker.deal(0);  // 发第一张牌       
      // 对于非静态内部类Card         // 只有通过其外部类Poker对象才能创建Card对象     
        Poker.Card c2 = poker.new Card("红心", 1);    // 自己创建一张牌        
      System.out.println(c1);     // 洗牌后的第一张         System.out.println(c2);  
       // 打印: 红心A     } }
    
    面试题 - 下面的代码哪些地方会产生编译错误?

    class Outer { class Inner {} public static void foo() { new Inner(); } public void bar() { new Inner(); } public static void main(String[] args) { new Inner(); } }

    注意:Java中非静态内部类对象的创建要依赖其外部类对象,上面的面试题中foo和main方法都是静态方法,静态方法中没有this,也就是说没有所谓的外部类对象,因此无法创建内部类对象,如果要在静态方法中创建内部类对象,可以这样做:

    new Outer().new Inner();

    38、如果对象的引用被置为null,垃圾收集器是否会立即释放对象占用的内存?

    1、 不会,在下一个垃圾回调周期中,这个对象将是被可回收的。

    2、 也就是说并不会立即被垃圾收集器立刻回收,而是在下一次垃圾回收时才会释放其占用的内存。

    39、JVM 出现 fullGC 很频繁,怎么去线上排查问题

    这题就依据full GC的触发条件来做:

    1、 如果有perm gen的话(jdk1.8就没了),要给perm gen分配空间,但没有足够的空间时,会触发full gc。

    2、 所以看看是不是perm gen区的值设置得太小了。

    3、 System.gc()方法的调用

    4、 这个一般没人去调用吧~~~

    5、 当统计得到的Minor GC晋升到旧生代的平均大小大于老年代的剩余空间,则会触发full gc(这就可以从多个角度上看了)

    6、 是不是频繁创建了大对象(也有可能eden区设置过小)(大对象直接分配在老年代中,导致老年代空间不足--->从而频繁gc)

    7、 是不是老年代的空间设置过小了(Minor GC几个对象就大于老年代的剩余空间了)

    40、JVM 内存区域

    JVM 内存区域主要分为线程私有区域【程序计数器、虚拟机栈、本地方法区】、线程共享区域【JAVA 堆、方法区】、直接内存。

    线程私有数据区域生命周期与线程相同, 依赖用户线程的启动/结束 而 创建/销毁(在 Hotspot VM 内, 每个线程都与操作系统的本地线程直接映射, 因此这部分内存区域的存/否跟随本地线程的生/死对应)。

    线程共享区域随虚拟机的启动/关闭而创建/销毁。

    直接内存并不是 JVM 运行时数据区的一部分, 但也会被频繁的使用: 在 JDK 1.4 引入的 NIO 提供了基于Channel与 Buffer的IO方式, 它可以使用Native函数库直接分配堆外内存, 然后使用DirectByteBuffer 对象作为这块内存的引用进行操作(详见: Java I/O 扩展), 这样就避免了在 Java堆和 Native 堆中来回复制数据, 因此在一些场景中可以显著提高性能。

    更多 Java 面试题 70 道

    01、如何判断一个对象是否存活

    02、Int与integer的区别

    03、Servlet的生命周期?

    04、怎么唤醒一个阻塞的线程

    05、虚拟DOM的优劣如何?

    06、双亲委派模型是什么?

    07、静态嵌套类(Static Nested Class)和内部类(Inner Class)的不同?

    08、如果对象的引用被置为null,垃圾收集器是否会立即释放对象占用的内存?

    09、JVM 出现 fullGC 很频繁,怎么去线上排查问题

    10、JVM 内存区域

    11、Parallel Old 收集器(多线程标记整理算法)

    12、对象分配内存是否线程安全?

    13、当一个线程进入某个对象的一个synchronized的实例方法后,其它线程是否可进入此对象的其它方法?

    14、Serial 与 Parallel GC 之间的不同之处?

    15、为什么线程通信的方法 wait(), notify()和 notifyAll()被定义在 Object 类里?

    16、redux异步中间件之间的优劣?

    17、类加载为什么要使用双亲委派模式,有没有什么场景是打破了这个模式?

    18、Hibernate中Session的load和get方法的区别是什么?

    19、说一下堆内存中对象的分配的基本策略

    20、Java 中如何将字符串转换为整数?

    21、讲讲什么情况下会出现内存溢出,内存泄漏?

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

    23、线程与进程的区别?

    24、Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法分别是做什么的?有什么区别?

    25、用代码演示三种代理

    26、stackoverflow错误,permgen space错误

    27、分代收集算法

    28、同步方法和同步块,哪个是更好的选择?

    29、Java 中的编译期常量是什么?使用它又什么风险?

    30、Java死锁以及如何避免?

    31、String 属于基础的数据类型吗?

    32、如何实现对象克隆?

    33、Java最顶级的父类是哪个?

    34、如何通过反射创建对象?

    35、Java 中堆和栈有什么区别?

    36、volatile 能使得一个非原子操作变成原子操作吗?

    37、为什么选择使用框架而不是原生?

    38、你能写出一个正则表达式来判断一个字符串是否是一个数字吗?

    39、运行时栈帧包含哪些结构?

    40、什么是Java程序的主类?应用程序和小程序的主类有何不同?

    41、volatile 关键字的作用

    42、Java 中用到的线程调度算法是什么?

    43、简单描述一下(分代)垃圾回收的过程

    44、什么是可重入锁(ReentrantLock)?

    45、线程池有什么优点?

    46、你有哪些手段来排查 OOM 的问题?

    47、什么是线程异步?什么是线程同步?

    48、Java 中,受检查异常 和 不受检查异常的区别?

    49、OOP 中的 组合、聚合和关联有什么区别?

    50、Java网络编程有几种?

    51、js如何实现页面刷新呢?

    52、什么是线程池?

    53、如何实现 Array 和 List 之间的转换?

    54、普通类和抽象类有哪些区别?

    55、为什么线程通信的方法wait(), notify()和notifyAll()被定义在Object 类里?

    56、遍历一个 List 有哪些不同的方式?每种方法的实现原理是什么?Java 中 List 遍历的最佳实践是什么?

    57、String str="i"与 String str=new String("i")一样吗?

    58、用过ConcurrentHashMap,讲一下他和HashTable的不同之处?

    59、线程的基本状态以及状态之间的关系?

    60、线程池中 submit() 和 execute() 方法有什么区别?

    61、在java中守护线程和本地线程区别?

    62、CMS分为哪几个阶段?

    03、抽象的关键字是什么?

    64、如何判断对象可以被回收

    65、如何通过反射调用对象的方法?

    66、如何进行单元测试

    67、什么情况下会发生栈内存溢出?

    68、什么是Hash算法

    69、什么是上下文切换?

    70、列举一些你知道的打破双亲委派机制的例子。为什么要打破?

    这套Java面试题大全,希望对大家有帮助哈~

    博主已将以下这些面试题整理成了一个Java面试手册,是PDF版的

     

    展开全文
  • 数据库系统概论判断题

    千次阅读 2020-07-31 10:41:33
    一、 判断题 1、从计算机数据管理的角度看,信息就是数据,数据就是信息。(B ) A、对 B、错 描述事物的符号记录称为数据 2、数据库的数据项之间无联系,记录之间存在联系。 (B ) A、对 B、错 3、概念模型是对...
  • 简答 1.数据库管理系统的主要功能有哪些 ? 答:数据库定义、操纵、保护、存储、维护和数据字典。 2.数据库系统中的常见故障有哪些 ? 答: .事务故障,系统故障、介质故障。 3.简述 SQL 语言的组成。 答:分为四个...
  • RabbitMQ面试以及答案整理【最新版】RabbitMQ高级面试大全(2021版),发现网上很多RabbitMQ面试都没有答案,所以花了很长时间搜集,本套RabbitMQ面试大全 如果不背 RabbitMQ面试答案,肯定面试会挂! ...
  • MySQL数据库考试试题及答案

    千次阅读 2021-02-08 03:55:10
    “1+2” C.”can’t” D.”张三-李四” 答案:B,D,C38.关于语句limit 5,5,说法正确的是 A.表示检索出第5行开始的5条记录 B.表示检索出行6开始的5条记录 C.表示检索出第6行开始的5条记录 D.表示检索出行5...
  • 软件工程期末试题及答案(史上最全)

    千次阅读 多人点赞 2021-07-15 15:39:15
    软件工程期末试题及答案 1.开发瀑布模型中的软件定义时期各个阶段依次是:( B) A) 可行性研究,问题定义,需求分析。 B) 问题定义,可行性研究,需求分析。 C) 可行性研究,需求分析,问题定义。 D) 以上顺序都...
  • 文章目录Java集合/泛型面试1、ArrayList和linkedList的区别2、 HashMap和HashTable的区别3、Collection包结构,与Collections的区别4、泛型常用特点(待补充)5、说说List、Set、Map、三者的区别?6、Array与...
  • 2021年前端面试答案

    万次阅读 多人点赞 2020-02-11 19:29:34
    前端面试汇总(2020年) 一 大纲 1、前言 2、前端工程化 3、前端设计模式 ...8、*前端基础知识点面试 ...由于新冠肺炎疫情,现在成天呆在家里,加上也要准备面试,就在家里看面试...
  • 自动化测试面试答案大全(1)

    千次阅读 2021-02-09 13:45:01
    自动化面试记录整理(部分答案自己整理)selenium中如何判断元素是否存在?没有提供原生的方法判断元素是否存在,一般我们可以通过定位元素+异常捕获的方式判断selenium中hidden或者是display = none的元素是否可以...
  • 注:最后一节始终是待批改状态,以及改过的也看不见正确答案答案如果有错,评论区告诉我哈,我在改改。 PS.重复的有点多,有的出现的章节不对,学校抽系统的问题吧。。 目 录存储系统2.1 主存储器概述2.2 主...
  • 最新Web前端面试精选大全及答案

    万次阅读 多人点赞 2021-01-07 11:53:44
    常见的兼容性一阶段内容中几个 26.垂直与水平居中的方式 27.三栏布局方式两边固定中间自适应 1. margin负值法:左右两栏均左浮动,左右两栏采用负的margin值。中间栏被宽度为100%的浮动元素包起来 2. 自身浮动法:...
  • 计算机二级习题答案

    千次阅读 2021-07-06 05:31:06
    34.9 积分《计算机基础与 Access 数据库程序设计》习题解答第 1章 习题答案及解析一、单选1. 计算机中实现计算和控制等功能的部件是 ()。A. 内存 B. CPU C. 控制器 D. 运算器答案: B2. 家用计算机一般是指 ()。A....
  • java笔试答案

    千次阅读 2019-03-01 10:55:17
    java笔试答案 最近在面试java开发工程师,虽然面试的结果不重要,但是过程还是很重要的,我觉得有必要记录下来。下面是我总结的一些java笔试,希望能帮到大家。 三维家 —、不定项选择 1、下列描述正确...
  • 数据库复习题选择题+判断题+填空题(考试续命必备

    万次阅读 多人点赞 2021-05-07 14:33:25
    数据库复习题选择题+判断题+填空题(考试续命必备 一些选择题 1、从计算机数据管理的角度看,信息就是数据,数据就是信息。(B ) A、对 B、错 (描述事物的符号记录称为数据 数据库的数据项之间无联系,...
  • Java面试答案(2022版),适用于应届生、有工作经验的程序员,每道都是认真筛选出的高频面试,助力大家能找到满意的工作! JVM篇 下载链接:全部面试答案PDF 1.JVM 的主要组成部分?及其作用? • 类加载器...
  • Mysql 练习答案

    万次阅读 多人点赞 2016-10-21 11:27:09
    --1.学生表Student(S,Sname,Sage,Ssex) --S 学生编号,Sname 学生姓名,Sage 出生年月,Ssex 学生性别--2.课程表 Course(C,Cname,T) --C --课程编号,Cname 课程名称,T 教师编号--3.教师表 Teacher(T,Tname) --T 教师...
  • 云计算题库以及答案4

    千次阅读 2020-07-07 17:50:53
    判断题)可以使用物理主机光驱为虚拟机安装操作系统 1.A、正确 2.B、错误 收藏试题 A B 3 (单选题)当需要使用FusionManager提供虚拟防火墙、负载均衡和DHCP功能时,需要部署哪种虚拟机? 1.A、VRM
  • ==可以判断基本数据类型值是否相等,也可以判断两个对象指向的内存地址是否相同,也就是说判断两个对象是否是同一个对象,Equlas通常用来做字符串比较。 47.如何将字符串反转? Stringbuilder或者stringbuffer的...
  • Kafka面试(附答案

    万次阅读 2019-05-15 17:25:05
    答案是:Kafka 会在含有分区目录最少的文件夹中创建新的分区目录,分区目录名为 Topic名+分区ID。注意,是分区文件夹总数最少的目录,而不是磁盘使用量最少的目录!也就是说,如果你给 log.dirs 参数新增了一个新的...
  • 总结 最近面试的小伙伴很多,对此我整理了一份Java面试手册:基础知识、JavaOOP、Java集合/泛型面试、Java异常面试、Java中的IO与NIO面试、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、...
  • 数据库常见面试(附答案

    万次阅读 多人点赞 2019-03-13 00:54:20
    分库分表,主从复制,读写分离 读写分离,读从库,写主库 spring配置两个数据库,通过AOP(面向切面编程),在写或读方法前面进行判断得到动态切换数据源。 20.数据库三范式 级别 概念 1NF 属性不可分 2NF 非主键...
  • 10万字208道Java经典面试总结(附答案)

    万次阅读 多人点赞 2021-08-01 16:05:55
    关注公众号【哪吒编程】,回复 面试 ,获取《10万字208道Java经典面试总结(附答案)》pdf,背更方便,一文在手,面试我有 前言 最近有很多粉丝问我,有什么方法能够快速提升自己,通过阿里、腾讯、字节跳动、...
  • 2022年python面试大全(50答案

    千次阅读 2022-02-23 10:20:19
    Python面试:50 1、一行代码实现1--100之和? 利用sum()函数求和 2、如何在一个函数内部修改全局变量? 利用global 修改全局变量 3、列出5个Python标准库? os:提供了不少与操作系统相关联的函数 ...
  • 模拟_1_答案判断 共 10 共计10 分 第1 1.0 分 使用报表向导创建报表"可以在报表中排序和分组记录,但只能选择 4 个字段作为排序和分组依 据"的说法是不正确的. 答案Y 第2 1.0 分 将一个基表或查询作为...
  • 2021年JAVA面试~集合篇附带答案

    千次阅读 2021-05-25 20:54:31
    本篇主要是我整理的集合面试, 其中有面试官问我的或者网上收集整理的 当然大佬们可以看看我整理的系列:光头佳的求职之旅 https://blog.csdn.net/u013351145/category_11030408.html 面试 我已经在会议室等待了30...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,294
精华内容 35,717
关键字:

判断题怎么记答案