精华内容
下载资源
问答
  • 本题集包含了常见的算法、面试题,也包含了新的高级技术,比如:微服务架构等技术的面试题目。本题集非常全面,对于工作1-5年左右的java程序员面试有非常好的指导作用。 大家也可以访问(直接在线观看最新版的面试...

    前言

    本题集列举了众多IT公司面试真题,对应聘Java程序员职位的常见考点和知识体系都进行的分类和归纳整理。

    本题集适合应聘Java和JavaEE职位的程序员作为面试复习、学习和强化的资料,也适合其他程序员作为拓展读物进行阅读。

    本题集包含了常见的算法、面试题,也包含了新的高级技术,比如:微服务架构等技术的面试题目。本题集非常全面,对于工作1-5年左右的java程序员面试有非常好的指导作用。

    大家也可以访问(直接在线观看最新版的面试题):

    Java考试_Java笔试题机试题真题讲解_JavaWeb阶段考试_Java期末考试通关_Java程序员面试题

    图标

    大学生高端复合人才成长

    1.JAVA专业,1000课

    3.大数据专业,500课

    2.Python专业,500课

    4.人工智能专业,500课

    四个专业都要学,从零开始2000小时,成为高端人才,打下一生技术基础,不再是低端码农。

    String相关:

    1.下面程序的运行结果是()(选择一项)

    2.Java语言中,String类中的indexOf()方法返回值的类型是()

    3.给定以下代码,程序的运行结果是 ()(选择一项)

    4.执行下列代码后,哪个结论是正确的()(选择两项)

    5.实现String类的replaceAll方法

    思路说明:replaceAll方法的本质是使用正则表达式进行匹配,最终调用的其实是Matcher对象的replaceAll方法。

    6.在“=”后填写适当的内容:

    String []a=new String[10];

    则:a[0]~a[9]=null;

    a.length=10;

    如果是int[]a=new int[10];

    则:a[0]~a[9]= (0)

    a.length= (10)

    Java300集零基础适合初学者视频教程_Java300集零基础教程_Java初学入门视频基础巩固教程

    图标

    7.是否可以继承String类?

    答:不可以,因为String类有final修饰符,而final修饰的类是不能被继承的,实现细节不允许改变。

    public final class String implements java.io.Serializable,

    Comparable< String>, CharSequence

    8.给定两个字符串s和t, 写一个函数来决定是否t是s的重组词。你可以假设字符串只包含小写字母。

    9.String s=new String(“abc”);创建了几个String对象。

    两个或一个,”abc”对应一个对象,这个对象放在字符串常量缓冲区,常量”abc”不管出现多少遍,都是缓冲区中的那一个。New String每写一遍,就创建一个新的对象,它一句那个常量”abc”对象的内容来创建出一个新String对象。如果以前就用过’abc’,这句代表就不会创建”abc”自己了,直接从缓冲区拿。

    10.输出结果?

    false

    true

    11.下列程序的输出结果是什么?

    0 Hello world

    1 Hello world

    2 Hello world

    3 Hello world

    4 Hello world

    5 Hello world

    6 Hello world

    7 Hello world

    8 Hello world

    9 Hello world

    12.关于java.lang.String类,以下描述正确的一项是()

    13.下面哪个是正确的()

    14.已知如下代码:执行结果是什么()

    15.字符串如何转换为int类型

    Java300集零基础适合初学者视频教程_Java初学入门视频基础巩固教程_Java语言入门到精通

    图标

    16.写一个方法,实现字符串的反转,如:输入abc,输出cba

    17.编写java,将“I follow Bill Gate.Tom Gate.John Gate”中的“Gate”全部替换为“Gates”

    18.String 是最基本的数据类型吗?

    答: 不是 。Java中的基本数据类型只有8个:byte、short、int、long、float、double、char、boolean;除了基本类型(primitive type)和枚举类型(enumeration type),剩下的都是引用类型(reference type)。

    19.String 和StringBuilder、StringBuffer 的区别?

    答: Java 平台提供了两种类型的字符串:String和StringBuffer / StringBuilder

    相同点:

    它们都可以储存和操作字符串,同时三者都使用final修饰,都属于终结类不能派生子类,操作的相关方法也类似例如获取字符串长度等;

    不同点:

    其中String是只读字符串,也就意味着String引用的字符串内容是不能被改变的,而StringBuffer和StringBuilder类表示的字符串对象可以直接进行修改,在修改的同时地址值不会发生改变。StringBuilder是JDK 1.5中引入的,它和StringBuffer的方法完全相同,区别在于它是在单线程环境下使用的,因为它的所有方面都没有被synchronized修饰,因此它的效率也比StringBuffer略高。在此重点说明一下,String、StringBuffer、StringBuilder三者类型不一样,无法使用equals()方法比较其字符串内容是否一样!

    补充1:有一个面试题问:有没有哪种情况用+做字符串连接比调用StringBuffer / StringBuilder对象的append方法性能更好?如果连接后得到的字符串在静态存储区中是早已存在的,那么用+做字符串连接是优于StringBuffer / StringBuilder的append方法的。

    补充2:下面也是一个面试题,问程序的输出,看看自己能不能说出正确答案。

    解析:

    String类存在intern()方法,含义如下:返回字符串对象的规范化表示形式。它遵循以下规则:对于任意两个字符串 s 和 t,当且仅当 s.equals(t) 为 true 时,s.intern() == t.intern() 才为 true。

    字符串比较分为两种形式,一种使用比较运算符”==”比较,他们比较的是各自的字符串在内存当中的地址值是否相同;一种是使用equals()方法进行比较,比较的是两个字符串的内容是否相同!

    结果如下:

    a == b-->false

    a == c-->true

    a.equals(b)-->true

    a.equals(c)-->true

    a.intern() == b.intern()-->true

    20.String类为什么是final的

    答:1) 为了效率。若允许被继承,则其高度的被使用率可能会降低程序的性能。

    2)为了安全。JDK中提供的好多核心类比如String,这类的类的内部好多方法的实现都不是java编程语言本身编写的,好多方法都是调用的操作系统本地的API,这就是著名的“本地方法调用”,也只有这样才能做事,这种类是非常底层的,和操作系统交流频繁的,那么如果这种类可以被继承的话,如果我们再把它的方法重写了,往操作系统内部写入一段具有恶意攻击性质的代码什么的,这不就成了核心病毒了么?不希望别人改,这个类就像一个工具一样,类的提供者给我们提供了, 就希望我们直接用就完了,不想让我们随便能改,其实说白了还是安全性,如果随便能改了,那么java编写的程序肯定就很不稳定,你可以保证自己不乱改, 但是将来一个项目好多人来做,管不了别人,再说有时候万一疏忽了呢?他也不是估计的, 所以这个安全性是很重要的,java和C++相比,优点之一就包括这一点。

    21.String类型是基本数据类型吗?基本数据类型有哪些

    1) 基本数据类型包括byte、short/char、int、long、float、double、boolean

    2 ) java.lang.String类是引用数据类型,并且是final类型的,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,我们应该用StringBuffer类

    22.String s="Hello";s=s+"world!";执行后,是否是对前面s指向空间内容的修改?

    答:不是对前面s指向空间内容的直接修改。

    因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。在这段代码中,s原先指向一个String对象,内容是 "Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?答案是没有。这时,s不指向原来那个对象了,而指向了另一个 String对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。

    通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。这时,应该考虑使用StringBuffer类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。

    同时,我们还可以知道,如果要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化,把它设置为初始值,应当这样做:

    而非

    s = new String("Initial Value");

    后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。

    上面的结论还基于这样一个事实:对于字符串常量,如果内容相同,Java认为它们代表同一个String对象。而用关键字new调用构造器,总是会创建一个新的对象,无论内容是否相同。

    至于为什么要把String类设计成不可变类,是它的用途决定的。其实不只String,很多Java标准类库中的类都是不可变的。在开发一个系统的时候,我们有时候也需要设计不可变类,来传递一组相关的值,这也是面向对象思想的体现。不可变类有一些优点,比如因为它的对象是只读的,所以多线程并发访问也不会有任何问题。当然也有一些缺点,比如每个不同的状态都要一个对象来代表,可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本,即 StringBuffer。

    23.String s = new String("xyz");创建几个String Object?

    答:两个或一个,”xyz”对应一个对象,这个对象放在字符串常量缓冲区,常量”xyz”不管出现多少遍,都是缓冲区中的那一个。New String每写一遍,就创建一个新的对象,它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’,这句代表就不会创建”xyz”自己了,直接从缓冲区拿。

    24.下面这条语句一共创建了多少个对象:String s="a"+"b"+"c"+"d";

    答:对于如下代码:

    String s1 = "a";

    String s2 = s1 + "b";

    String s3 = "a" + "b";

    System.out.println(s2 == "ab");

    System.out.println(s3 == "ab");

    第一条语句打印的结果为false,第二条语句打印的结果为true,这说明javac编译可以对字符串常量直接相加的表达式进行优化,不必要等到运行期去进行加法运算处理,而是在编译时去掉其中的加号,直接将其编译成一个这些常量相连的结果。

    题目中的第一行代码被编译器在编译时优化后,相当于直接定义一个”abcd”的字符串,所以,上面的代码应该只创建了一个String对象。

    写如下两行代码,

    String s = "a" + "b" + "c" + "d";

    System.out.println(s == "abcd");

    最终打印的结果应该为true。

    因java面试题合集内容过多,在此只更新一部分,需要完整版java面试题集的朋友们,评论区留言,我看到发给你!

    文章内容整理不易,若对你有帮助,点赞收藏走一波呗~

    展开全文
  • 史上最全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中级面试永远是程序员迈向成功的第一个门槛,想要面试成功,各种面试题的洗礼是必不可少的,下面就来看看小编精心整理的一些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版的

    展开全文
  • 最近梳理2021最新 Redis面试题【附答案解析】,包含了 Java基础、并发、JVM、数据库、Spring、SpringMVC、Redis、SpringCloud、设计模式、MQ、Linux、Redis等多个类型。 今天这篇是关于 Redis,总结了 110 道经典...

    最近梳理2021最新 Redis面试题【附答案解析】,包含了 Java基础、并发、JVM、数据库、Spring、SpringMVC、Redis、SpringCloud、设计模式、MQ、Linux、Redis等多个类型。

    今天这篇是关于 Redis,总结了 110 道经典问题。

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

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

    1、一个Redis实例最多能存放多少的keys?List、Set、Sorted Set他们最多能存放多少元素?

    理论上Redis可以处理多达232的keys,并且在实际中进行了测试,每个实例至少存放了2亿5千万的keys。我们正在测试一些较大的值。任何list、set、和sorted set都可以放232个元素。换句话说,Redis的存储极限是系统中的可用内存值。

    2、为什么要做Redis分区?

    分区可以让Redis管理更大的内存,Redis将可以使用所有机器的内存。如果没有分区,你最多只能使用一台机器的内存。分区使Redis的计算能力通过简单地增加计算机得到成倍提升,Redis的网络带宽也会随着计算机和网卡的增加而成倍增长。

    3、定时删除

    优点:对内存友好,定时删除策略可以保证过期键会尽可能快地被删除,并释放国期间所占用的内存

    缺点:对cpu时间不友好,在过期键比较多时,删除任务会占用很大一部分cpu时间,在内存不紧张但cpu时间紧张的情况下,将cpu时间用在删除和当前任务无关的过期键上,影响服务器的响应时间和吞吐量

    4、怎么理解Redis事务?

    事务是一个单独的隔离操作:事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中,不会被其他客户端发送来的命令请求所打断。

    事务是一个原子操作:事务中的命令要么全部被执行,要么全部都不执行。

    5、什么是Redis?

    Redis本质上是一个Key-Value类型的内存数据库,很像Memcached,整个数据库统统加载在内存当中进行操作,定期通过异步操作把数据库数据flush到硬盘上进行保存。因为是纯内存操作,Redis的性能非常出色,每秒可以处理超过 10万次读写操作,是已知性能最快的Key-Value DB。

    Redis的出色之处不仅仅是性能,Redis最大的魅力是支持保存多种数据结构,此外单个value的最大限制是1GB,不像 Memcached只能保存1MB的数据,因此Redis可以用来实现很多有用的功能,比方说用他的List来做FIFO双向链表,实现一个轻量级的高性 能消息队列服务,用他的Set可以做高性能的tag系统等等。另外Redis也可以对存入的Key-Value设置expire时间,因此也可以被当作一 个功能加强版的Memcached来用。

    Redis的主要缺点是数据库容量受到物理内存的限制,不能用作海量数据的高性能读写,因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上。

    6、Redis分布式锁实现

    先拿setnx来争抢锁,抢到之后,再用expire给锁加一个过期时间防止锁忘记了释放。如果在setnx之后执行expire之前进程意外crash或者要重启维护了,那会怎么样?set指令有非常复杂的参数,这个应该是可以同时把setnx和expire合成一条指令来用的!

    7、Redis做异步队列

    一般使用list结构作为队列,rpush生产消息,lpop消费消息。当lpop没有消息的时候,要适当sleep一会再重试。缺点:在消费者下线的情况下,生产的消息会丢失,得使用专业的消息队列如rabbitmq等。能不能生产一次消费多次呢?使用pub/sub主题订阅者模式,可以实现1:N的消息队列。

    8、Reids常用5种数据类型

    string,list,set,sorted set,hash

    9、Redis 事务相关的命令有哪几个?

    MULTI、EXEC、DISCARD、WATCH

    10、WATCH命令和基于CAS的乐观锁:

    在Redis的事务中,WATCH命令可用于提供CAS(check-and-set)功能。假设我们通过WATCH命令在事务执行之前监控了多个Keys,倘若在WATCH之后有任何Key的值发生了变化,EXEC命令执行的事务都将被放弃,同时返回Null multi-bulk应答以通知调用者事务

    执行失败。例如,我们再次假设Redis中并未提供incr命令来完成键值的原子性递增,如果要实现该功能,我们只能自行编写相应的代码。其伪码如下:

    val = GET mykey val = val + 1 SET mykey $val

    以上代码只有在单连接的情况下才可以保证执行结果是正确的,因为如果在同一时刻有多个客户端在同时执行该段代码,那么就会出现多线程程序中经常出现的一种错误场景--竞态争用(race condition)。

    比如,客户端A和B都在同一时刻读取了mykey的原有值,假设该值为10,此后两个客户端又均将该值加一后set回Redis服务器,这样就会导致mykey的结果为11,而不是我们认为的12。为了解决类似的问题,我们需要借助WATCH命令的帮助,见如下代码:

    WATCH mykey val = GET mykey val = val + 1 MULTI SET mykey $val EXEC

    和此前代码不同的是,新代码在获取mykey的值之前先通过WATCH命令监控了该键,此后又将set命令包围在事务中,这样就可以有效的保证每个连接在执行EXEC之前,如果当前连接获取的mykey的值被其它连接的客户端修改,那么当前连接的EXEC命令将执行失败。这样调用者在判断返回值后就可以获悉val是否被重新设置成功。

    11、MySQL里有2000w数据,Redis中只存20w的数据,如何保证Redis中的数据都是热点数据?

    Redis内存数据集大小上升到一定大小的时候,就会施行数据淘汰策略。

    12、Redis 过期键的删除策略?

    1、 定时删除:在设置键的过期时间的同时,创建一个定时器 timer). 让定时器在键的过期时间来临时, 立即执行对键的删除操作。

    12、 惰性删除:放任键过期不管,但是每次从键空间中获取键时,都检查取得的键是 否过期, 如果过期的话, 就删除该键;如果没有过期, 就返回该键。

    13、 定期删除:每隔一段时间程序就对数据库进行一次检查,删除里面的过期键。至 于要删除多少过期键, 以及要检查多少个数据库, 则由算法决定。

    13、mySQL里有2000w数据,Redis中只存20w的数据,如何保证Redis中的数据都是热点数据

    相关知识:Redis 内存数据集大小上升到一定大小的时候,就会施行数据淘汰策略(回收策略)。

    14、Redis key的过期时间和永久有效分别怎么设置?

    EXPIRE和PERSIST命令。

    15、请用Redis和任意语言实现一段恶意登录保护的代码,

    限制1小时内每用户Id最多只能登录5次。具体登录函数或功能用空函数即可,不用详细写出。

    用列表实现:列表中每个元素代表登陆时间,只要最后的第5次登陆时间和现在时间差不超过1小时就禁止登陆.用Python写的代码如下:

    #!/usr/bin/env python3 import Redis import sys import time r = Redis.StrictRedis(host=’127.0.0.1′, port=6379, db=0) try: id = sys.argv[1] except: print(‘input argument error’) sys.exit(0) if r.llen(id) >= 5 and time.time() – float(r.lindex(id, 4)) <= 3600: print(“you are forbidden logining”) else: print(‘you are allowed to login’) r.lpush(id, time.time()) # login_func()

    16、,或是关注

    17、怎么理解Redis事务?

    事务是一个单独的隔离操作:事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中,不会被其他客户端发送来的命令请求所打断。

    事务是一个原子操作:事务中的命令要么全部被执行,要么全部都不执行。

    18、Redis key 的过期时间和永久有效分别怎么设置?

    EXPIRE 和 PERSIST 命令。

    19、Redis中海量数据的正确操作方式

    利用SCAN系列命令(SCAN、SSCAN、HSCAN、ZSCAN)完成数据迭代。

    20、什么是Redis?简述它的优缺点?

    Redis的全称是:Remote Dictionary.Server,本质上是一个Key-Value类型的内存数据库,很像Memcached,整个数据库统统加载在内存当中进行操作,定期通过异步操作把数据库数据flush到硬盘上进行保存。

    因为是纯内存操作,Redis的性能非常出色,每秒可以处理超过 10万次读写操作,是已知性能最快的Key-Value DB。

    Redis的出色之处不仅仅是性能,Redis最大的魅力是支持保存多种数据结构,此外单个value的最大限制是1GB,不像 Memcached只能保存1MB的数据,因此Redis可以用来实现很多有用的功能。

    比方说用他的List来做FIFO双向链表,实现一个轻量级的高性 能消息队列服务,用他的Set可以做高性能的tag系统等等。

    另外Redis也可以对存入的Key-Value设置expire时间,因此也可以被当作一 个功能加强版的Memcached来用。 Redis的主要缺点是数据库容量受到物理内存的限制,不能用作海量数据的高性能读写,因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上。

    21、为什么 edis 需要把所有数据放到内存中?

    Redis 为了达到最快的读写速度将数据都读到内存中,并通过异步的方式将数据写入磁盘。所以 Redis 具有快速和数据持久化的特征。如果不将数据放在内存中, 磁盘 I/O 速度为严重影响 Redis 的性能。在内存越来越便宜的今天, Redis 将会越来越受欢迎。如果设置了最大使用的内存, 则数据已有记录数达到内存限值后不能继续插入新值。

    22、MySQL里有2000w数据,Redis中只存20w的数据

    如何保证Redis中的数据都是热点数据?

    Redis内存数据集大小上升到一定大小的时候,就会施行数据淘汰策略。

    其实面试除了考察Redis,不少公司都很重视高并发高可用的技术,特别是一线互联网公司,分布式、JVM、spring源码分析、微服务等知识点已是面试的必考题。我自己整理收集了一套系统的架构技术体系,针对当前互联网公司的技术需求以及结合主流技术,这些东西可能你们平时在工作中接触过,但是缺少的全面系统的学习,加入

    23、Reids6种淘汰策略:

    noeviction: 不删除策略, 达到最大内存限制时, 如果需要更多内存, 直接返回错误信息。大多数写命令都会导致占用更多的内存(有极少数会例外。

    **allkeys-lru:**所有key通用; 优先删除最近最少使用(less recently used ,LRU) 的 key。

    **volatile-lru:**只限于设置了 expire 的部分; 优先删除最近最少使用(less recently used ,LRU) 的 key。

    **allkeys-random:**所有key通用; 随机删除一部分 key。

    volatile-random: 只限于设置了 expire 的部分; 随机删除一部分 key。

    volatile-ttl: 只限于设置了 expire 的部分; 优先删除剩余时间(time to live,TTL) 短的key。

    24、Redis还提供的高级工具

    像慢查询分析、性能测试、Pipeline、事务、Lua自定义命令、Bitmaps、HyperLogLog、/订阅、Geo等个性化功能。

    25、Pipeline 有什么好处,为什么要用pipeline?

    可以将多次 IO 往返的时间缩减为一次,前提是 pipeline 执行的指令之间没有因果相关性。使用 Redis-benchmark 进行压测的时候可以发现影响 Redis 的 QPS 峰值的一个重要因素是 pipeline 批次指令的数目。

    26、Redis 集群方案什么情况下会导致整个集群不可用?

    有 A, B, C 三个节点的集群,在没有复制模型的情况下,如果节点 B 失败了, 那么整个集群就会以为缺少 5501-11000 这个范围的槽而不可用。

    27、Redis 的内存用完了会发生什么?

    如果达到设置的上限,Redis 的写命令会返回错误信息( 但是读命令还可以正常返回。) 或者你可以将 Redis 当缓存来使用配置淘汰机制, 当 Redis 达到内存上限时会冲刷掉旧的内容。

    28、删除key

    del key1 key2 ...

    29、Redis集群最大节点个数是多少?

    16384个。

    30、Redis 到底是怎么实现“附近的人”

    GEOADD key longitude latitude member [longitude latitude member ...]

    将给定的位置对象(纬度、经度、名字)添加到指定的key。其中,key为集合名称,member为该经纬度所对应的对象。在实际运用中,当所需存储的对象数量过多时,可通过设置多key(如一个省一个key)的方式对对象集合变相做sharding,避免单集合数量过多。

    成功插入后的返回值:

    (integer) N

    其中N为成功插入的个数。

    Redis 面试题更多70道

    01、Redis集群方案应该怎么做?都有哪些方案?

    02、Reids支持的语言:

    03、怎么测试Redis的连通性?

    04、Redis 集群会有写操作丢失吗?为什么?

    05、Redis回收使用的是什么算法?

    06、Redis的并发竞争问题如何解决?

    07、AOF常用配置总结

    08、Redis 管道 Pipeline

    09、微信公众号:Java资讯库,回复“架构”

    10、Redis集群方案什么情况下会导致整个集群不可用?

    11、一个Redis实例最多能存放多少的keys?List、Set、Sorted Set他们最多能存放多少元素?

    12、为什么要做Redis分区?

    13、定时删除

    14、怎么理解Redis事务?

    15、什么是Redis?

    16、Redis分布式锁实现

    17、Redis做异步队列

    18、Reids常用5种数据类型

    19、Redis 事务相关的命令有哪几个?

    20、WATCH命令和基于CAS的乐观锁:

    21、Redis集群最大节点个数是多少?

    22、Reids的特点

    23、Redis最适合的场景?

    24、使用Redis有哪些好处?

    25、为什么edis需要把所有数据放到内存中?

    26、Redis的内存用完了会发生什么?

    27、Redis 的回收策略(淘汰策略)

    28、假如Redis里面有1亿个key,其中有10w个key是以某个固定的已知的前缀开头的,如果将它们全部找出来?

    29、Memcached 与Redis 的区别?

    30、Redis 常见性能问题和解决方案:

    31、为什么Redis需要把所有数据放到内存中?

    32、查看Redis使用情况及状态信息用什么命令?

    34、修改配置不重启Redis会实时生效吗?

    35、是否使用过 Redis 集群,集群的原理是什么?

    36、缓存并发问题

    37、使用过Redis分布式锁么,它是什么回事?

    38、Reids主从复制

    39、Redis与Memcached相比有哪些优势?

    40、Redis 最适合的场景?

    41、为什么 edis 需要把所有数据放到内存中?

    42、MySQL里有2000w数据,Redis中只存20w的数据

    43、Reids6种淘汰策略:

    44、Redis还提供的高级工具

    45、Pipeline 有什么好处,为什么要用pipeline?

    46、Redis 集群方案什么情况下会导致整个集群不可用?

    47、Redis 的内存用完了会发生什么?

    48、删除key

    49、Redis集群最大节点个数是多少?

    50、Redis 到底是怎么实现“附近的人”

    51、MySQL里有2000w数据,Redis中只存20w的数据,如何保证Redis中的数据都是热点数据?

    52、Redis 过期键的删除策略?

    53、mySQL里有2000w数据,Redis中只存20w的数据,如何保证Redis中的数据都是热点数据

    54、Redis key的过期时间和永久有效分别怎么设置?

    55、请用Redis和任意语言实现一段恶意登录保护的代码,

    56、,或是关注

    57、怎么理解Redis事务?

    58、Redis key 的过期时间和永久有效分别怎么设置?

    59、Redis中海量数据的正确操作方式

    60、什么是Redis?简述它的优缺点?

    61、为什么 edis 需要把所有数据放到内存中?

    62、MySQL里有2000w数据,Redis中只存20w的数据

    63、Reids6种淘汰策略:

    64、Redis还提供的高级工具

    65、Pipeline 有什么好处,为什么要用pipeline?

    66、Redis 集群方案什么情况下会导致整个集群不可用?

    67、Redis 的内存用完了会发生什么?

    68、删除key

    69、Redis集群最大节点个数是多少?

    70、Redis 到底是怎么实现“附近的人”

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

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

    展开全文
  • String是最常使用的Java类之一,整理的了一些重要的String知识分享给大家。作为一个Java新手程序员,对String进行更深入的了解很有必要。如果你是有几年Java开发经验,可以根据目录选择性的阅读以下内容。1、什么是...
  • 最新SpringCloud面试题及答案【附答案解析】SpringCloud面试题及答案,SpringCloud最新面试题及答案,SpringCloud面试题答案已经全部更新完了,有些答案是自己总结的,也有些答案是在网上搜集整理的。这些答案难免...
  • 最近梳理2021最新 Spring 面试题 全家桶【附答案解析】,包含了 Java基础、Spring、SpringMVC、Redis、SpringCloud、设计模式、等多个类型。 今天这篇是关于 Spring 全家桶面试题,总结了 110 道经典问题。 这套...
  • 这是一个高级Java面试系列中的第一部分。这一部分论述了可变参数,断言,垃圾回收,初始化器,令牌化,日期,日历等等Java核心问题。1. 什么是可变参数?可变参数允许调用参数数量不同的方法。请看下面例子中的...
  • 2021年前端面试题及答案(更新中)

    千次阅读 2021-03-25 17:47:07
    这三种是常规用的 NaN 的数据类型是 number 数组(Array)的数据类型是 object 日期(Date)的数据类型为 object null 的数据类型是 object 未定义变量的数据类型为 undefined null 不存在的因素解决方案 原因是: 1、...
  • 100道最新Java面试题,常见面试题及答案汇总

    万次阅读 多人点赞 2021-01-28 15:32:15
    小编特意整理了100道Java面试题,送给大家,希望大家都能顺利通过面试,拿下高薪。赶紧码住吧~~ Q1:Java内部类和子类之间有什么区别? 答案:内部类是指在一个外部类的内部再定义一个类,内部类对外部类有访问权限...
  • 前言string是C++、java,VB等编程语言中的[字符串],字符串是一个特殊的对象,属于引用类型。 在java中,String类对象创建后,字符串一旦初始化就不能...同时string在互联网大厂面试的时候也是一个常问的技术点,下...
  • Android开发人员面试题及答案技术方向:Android?选择题(30题,每题1.5分,共45分)1.java.io包中定义了多个流类型来实现输入和输出功能,可以从不同的角度对其进行分 类,按功能分为:(),如果为读取的内容进行处理后再...
  • java最新面试题及答案20201. 一个".java"源文件中是否可以包括多个类(不是内部类)?有什么限制?一个“.java”源文件里面可以包含多个类,但是只允许有一java最新面试题及答案个public类,并且类名必须和文件名一致...
  • java高级工程师面试题及答案解析

    万次阅读 2021-03-07 03:50:08
    面试永远是程序员迈向成功的第一个门槛,想要面试成功,各种面试题的洗礼是必不可少的,下面就来看看小编精心整理的一些java高级工程师面试题及答案吧。一、堆的年轻代和老年代怎么理解?堆的年轻代大则老年代小,GC...
  • 最新Jvm面试题答案【附答案解析】Jvm面试题大全带答案,Jvm面试题最新面试题,Jvm面试题新答案已经全部更新完了,有些答案是自己总结的,也有些Jvm面试题答案是在网上搜集整理的。这些答案难免会存在一些错误,仅...
  • Java开发面试题及答案 今天抽空来整理整理Java开发面试中的那点事儿吧,帮助那些正在找工作或想跳槽找工作的兄弟姐妹们! 分享目前Java开发常见的面试问题以及问题的答案给大家阅读参考。 1、String类可以被...
  • java常见面试题及答案1.什么是Java虚拟机?为什么Java被称作是“平台无关的编程语言”?Java 虚拟机是一个可以执行 Java 字节码的虚拟机进程。Java 源文件被编译成能被 Java 虚拟机执行的字节码文件。Java 被设计成...
  • 花了大量时间整理了这套Redis面试题及答案,希望对大家有帮助哈~ 弄明白了这些Redis面试题基本上就可以成为面霸了,吊打面试官,哈哈~ 如果不背 Redis面试题答案,肯定面试会挂! 这套Redis面试题大全,希望对...
  • Java最新2021年面试题及答案,汇总版

    千次阅读 多人点赞 2021-05-08 20:56:23
    Java最新2021年面试题及答案,汇总版 其实,博主还整理了,更多大厂面试题,直接下载吧 下载链接:高清172份,累计 7701 页大厂面试题 PDF 1、如何判断一个对象是否存活 判断一个对象是否存活有两种方法: 1、 引用...
  • 1.String类可以被继承吗?不能。String类在声明中使用final关键字修饰符。使用final关键字修饰的类无法被继承。Java语言的开发者为什么要将String类定义为final类呢?•因为当字符串是不可变的,字符串池才有可能...
  • 最新常Java面试题汇总(含答案解析)发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全汇总,希望对大家有帮助哈 本套Java面试题大全,全的不能再全,哈哈~ 1、创建socket通讯的...
  • 说到Java开发,所有的java程序员都知道...近期也有不少的小伙伴面临着就业面试的问题,下面就整理了一些java IO的面试题及答案,帮助大家学习一下。1、字节流和字符流的区别?答:字节流读取的时候,读到一个字节...
  • 2021年最新Web前端面试题精选大全及答案

    万次阅读 多人点赞 2021-01-07 11:53:44
    table布局 28.Doctype作用 声明文档类型 Javascript相关 1.Js基本数据类型有哪些 字符串String 数值Number 布尔boolean null undefined 对象 数组 2.Ajax如何使用 一个完整的AJAX请求包括五个步骤: 创建...
  • 在JavaScript中,特殊的数字类型还有几种:Infinity 表示无穷大特殊值 二、对于字符串类型, typeof 返回的值是 string。比如typeof(“123”)返回的值是string。三、对于布尔类型, typeof 返回的值是 boolean 。...
  • Redis面试题及答案 【最新版】Redis面试题大全,发现网上很多Redis面试题及答案整理都没有答案,所以花了很长时间搜集,本套Redis面试题大全 如果不背 Redis面试题答案,肯定面试会挂! 这套Redis面试题大全,...
  • 星标/置顶公众号????,硬核文章第一时间送达!链接 |https://zhuanlan.zhihu.com/p/274473971很多,先上后上答案,便于大家思考问题点:1、C和C++...
  • 2021 .NET/dotnet Core/C# 面试题及参考答案. 文章目录 1. NET/dotnet core/.NET framework 的关系? 2. corefx, coreclr 都是什么? 3. asp.net core 3.1. Kestrel 3.2. asp.net core 主要的特性 3.3. startup class...
  • 2.React 项目用过什么脚手架(本是开放性题目) creat-react-app Yeoman 等 3什么时候用类组件Class Component,或函数组件Function 如果您的组件具有状态( state ) 或 生命周期方法,请使用 Class 组件。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,880
精华内容 22,752
关键字:

string面试题及答案