java 基础面试题目讲解

    技术2022-07-13  89

    文章目录

    一、基础篇二、JVM篇三、容器四、多线程五、反射六、异常七、Java Web

    参考文章

    java 面试200题java集合面试

    一、基础篇

    1. JDK 和 JRE 有什么区别? JDK:Java Development Kit 的简称,java 开发工具包,提供了 java 的开发环境和运行环境。 JRE:Java Runtime Environment 的简称,java 运行环境,为 java 的运行提供了所需环境。 具体来说 JDK 其实包含了 JRE,同时还包含了编译 java 源码的编译器 javac,还包含了很多 java 程序调试和分析的工具。简单来说:如果你需要运行 java 程序,只需安装 JRE 就可以了,如果你需要编写 java 程序,需要安装 JDK。

    2.Java基本数据类型(八种) Byte short int long float double boolean char

    3.==和 equals 的区别是什么?

    == 解读

    对于基本类型和引用类型 == 的作用效果是不同的,如下所示:

    基本类型:比较的是值是否相同; 引用类型:比较的是引用是否相同;

    String x = "string"; String y = "string"; String z = new String("string"); int a = 1; int b = 1; System.out.println(x==y); // true System.out.println(x==z); // false System.out.println(a==b); // true

    代码解读:因为 x 和 y 指向的是同一个引用,所以 x==y也是 true,而 new String()方法则重写开辟了内存空间,所以 x==z结果为 false,而对于基本类型而言,a和b的值相等,所以是true。

    equals 解读 equals 是 java.lang.Object类的一个方法,所以只能用于引用类型。

    equals 本质上就是 ==,只不过 String 和 Integer 等类重写了 equals 方法,把它变成了值比较。看下面的代码就明白了。

    首先来看默认情况下 equals 比较一个有相同值的对象,代码如下:

    class Cat { public Cat(String name) { this.name = name; } private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } Cat c1 = new Cat("王磊"); Cat c2 = new Cat("王磊"); System.out.println(c1.equals(c2)); // false

    输出结果出乎我们的意料,竟然是 false?这是怎么回事,看了 equals 源码就知道了,源码如下:

    public boolean equals(Object obj) { return (this == obj); }

    原来 equals 本质上就是 ==。

    那问题来了,两个相同值的 String 对象,为什么返回的是 true?代码如下:

    String s1 = new String("老王"); String s2 = new String("老王"); System.out.println(s1.equals(s2)); // true

    同样的,当我们进入 String 的 equals 方法,找到了答案,代码如下:

    public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length; if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }

    原来是 String 重写了 Object 的 equals 方法,把引用比较改成了值比较。

    总结 :== 对于基本类型来说是值比较,对于引用类型来说是比较的是引用;而 equals 默认情况下是引用比较,只是很多类重写了 equals 方法,比如 String、Integer 等把它变成了值比较,所以一般情况下 equals 比较的是值是否相等。

    4.两个对象的 hashCode()相同,则 equals()也一定为 true,对吗? 不对,两个对象的 hashCode()相同,equals()不一定 true。

    代码示例:

    String str1 = “通话”; String str2 = “重地”; System.out.println(String.format(“str1:%d | str2:%d”, str1.hashCode(),str2.hashCode())); System.out.println(str1.equals(str2)); 执行的结果:

    str1:1179395 | str2:1179395

    false

    代码解读:很显然“通话”和“重地”的 hashCode() 相同,然而 equals() 则为 false,因为在散列表中,hashCode()相等即两个键值对的哈希值相等,然而哈希值相等,并不一定能得出键值对相等。

    5.java中stringbuffer和stringbuilder和string 的区别 操作字符串的类有:String、StringBuffer、StringBuilder。

    String 和 StringBuffer、StringBuilder 的区别在于 String 声明的是不可变的对象,每次操作都会生成新的 String 对象,然后将指针指向新的 String 对象. 看下面的一个例子

    String a = "123"; a = "456"; // 打印出来的a为456 System.out.println(a)

    可以看出来,再次给a赋值时,并不是对原来堆中实例对象进行重新赋值,而是生成一个新的实例对象,并且指向“456”这个字符串,a则指向最新生成的实例对象,之前的实例对象仍然存在,如果没有被再次引用,则会被垃圾回收。

    StringBuffer、StringBuilder 可以在原有对象的基础上进行操作,所以在经常改变字符串内容的情况下最好不要使用 String。

    StringBuffer 和 StringBuilder 最大的区别在于,StringBuffer 是线程安全的,而 StringBuilder 是非线程安全的,但 StringBuilder 的性能却高于 StringBuffer,所以在单线程环境下推荐使用 StringBuilder,多线程环境下推荐使用 StringBuffer。

    6.普通类和抽象类有哪些区别? 普通类不能包含抽象方法,抽象类可以包含抽象方法。 抽象类不能直接实例化,普通类可以直接实例化。

    7. String 类的常用方法都有那些? indexOf():返回指定字符的索引。 charAt():返回指定索引处的字符。 replace():字符串替换。 trim():去除字符串两端空白。 split():分割字符串,返回一个分割后的字符串数组。 getBytes():返回字符串的 byte 类型数组。 length():返回字符串长度。 toLowerCase():将字符串转成小写字母。 toUpperCase():将字符串转成大写字符。 substring():截取字符串。 equals():字符串比较。

    8、int和Integer有什么区别?

    Java是一个近乎纯洁的面向对象编程语言,但是为了编程的方便还是引入了基本数据类型,但是为了能够将这些基本数据类型当成对象操作,Java为每一个基本数据类型都引入了对应的包装类型(wrapper class),int的包装类就是Integer,从Java 5开始引入了自动装箱/拆箱机制,使得二者可以相互转换。

    class AutoUnboxingTest { public static void main(String[] args) { Integer a = new Integer(3); Integer b = 3; // 将3自动装箱成Integer类型 int c = 3; System.out.println(a == b); // false 两个引用没有引用同一对象 System.out.println(a == c); // true a自动拆箱成int类型再和c比较 } }

    最近还遇到一个面试题,也是和自动装箱和拆箱有点关系的,代码如下所示:

    public class Test03 { public static void main(String[] args) { Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150; System.out.println(f1 == f2); System.out.println(f3 == f4); } }

    如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用,所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢?当我们给一个Integer对象赋一个int值的时候,会调用Integer类的静态方法valueOf

    public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } 简单的说,如果整型字面量的值在-128到127之间,那么不会new新的Integer对象,而是直接引用常量池中的Integer对象,所以上面的面试题中f1==f2的结果是true,而f3==f4的结果是false。

    9.final 在 java 中有什么作用? final 修饰的类叫最终类,该类不能被继承。 final 修饰的方法不能被重写。 final 修饰的变量叫常量,常量必须初始化,初始化之后值就不能被修改。

    10. 什么是序列化和反序列化? 序列化的定义 序列化(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。一般将一个对象存储至一个储存媒介,例如档案或是记亿体缓冲等。在网络传输过程中,可以是字节或是XML等格式。而字节的或XML编码格式可以还原完全相等的对象。这个相反的过程又称为反序列化。 java中的序列化 在Java中,我们可以通过多种方式来创建对象,并且只要对象没有被回收我们都可以复用该对象。但是,我们创建出来的这些Java对象都是存在于JVM的堆内存中的。只有JVM处于运行状态的时候,这些对象才可能存在。一旦JVM停止运行,这些对象的状态也就随之而丢失了。

    但是在真实的应用场景中,我们需要将这些对象持久化下来,并且能够在需要的时候把对象重新读取出来。Java的对象序列化可以帮助我们实现该功能。

    一个类的对象要想序列化成功,需要满足两个条件:

    该类必须实现 java.io.Serializable 接口。

    该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的,则该属性必须注明是短暂的(transient)。

    11. 接口和类的相同点和不同点? 接口与类相似点:

    一个接口可以有多个方法。接口文件保存在 .java 结尾的文件中,文件名使用接口名。接口的字节码文件保存在 .class 结尾的文件中。接口相应的字节码文件必须在与包名称相匹配的目录结构中。

    接口与类的区别:

    接口不能用于实例化对象。接口没有构造方法。接口中所有的方法必须是抽象方法。接口不能包含成员变量,除了 static 和 final 变量。接口不是被类继承了,而是要被类实现。接口支持多继承。

    12.接口和抽象类的区别?

    抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    13. java中的静态代理,动态代理和cglib代理? https://www.jianshu.com/p/305c8da4563d

    二、JVM篇

    参考博客JVM架构图分析

    1.简述JVM内存模型? 2. JAVA 的类加载机制是怎么样的? 什么是类加载的双亲委派机制?

    参考文章JAVA 的类加载机制

    4.新生代中为什么要分为Eden和Survivor?为什么要设置两个Survivor区?

    1)共享内存区划分

    共享内存区 = 持久 代+ 堆持久带 = 方法区 + 其他Java堆 = 老年代 + 新生代新生代 = Eden + S0 + S1

    2)一些参数的配置

    默认的,新生代 ( Young ) 与老年代 ( Old ) 的比例的值为 1:2 ,可以通过参数 –XX:NewRatio 配置。

    默认的,Edem : from : to = 8 : 1 : 1 ( 可以通过参数 –XX:SurvivorRatio 来设定)

    Survivor区中的对象被复制次数为15(对应虚拟机参数 -XX:+MaxTenuringThreshold)

    如果没有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两部分的存活对象占用连续的内存空间,避免了碎片化的发生)

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

    Java堆 = 老年代 + 新生代新生代 = Eden + S0 + S1当 Eden 区的空间满了, Java虚拟机会触发一次 Minor GC,以收集新生代的垃圾,存活下来的对象,则会转移到 Survivor区。大对象(需要大量连续内存空间的Java对象,如那种很长的字符串)直接进入老年态;如果对象在Eden出生,并经过第一次Minor GC后仍然存活,并且被Survivor容纳的话,年龄设为1,每熬过一次Minor GC,年龄+1,若年龄超过一定限制(15),则被晋升到老年态。即长期存活的对象进入老年态。老年代满了而无法容纳更多的对象,Minor GC 之后通常就会进行Full GC,Full GC 清理整个内存堆 – 包括年轻代和年老代。Major GC 发生在老年代的GC,清理老年区,经常会伴随至少一次Minor GC,比Minor GC慢10倍以上。

    6.你知道哪几种垃圾收集器,各自的优缺点,重点讲下cms和G1,包括原理,流程,优缺点。 思路: 一定要记住典型的垃圾收集器,尤其cms和G1,它们的原理与区别,涉及的垃圾回收算法。 我的答案: 1)几种垃圾收集器:

    Serial收集器: 单线程的收集器,收集垃圾时,必须stop the world,使用复制算法。ParNew收集器: Serial收集器的多线程版本,也需要stop the world,复制算法。Parallel Scavenge收集器: 新生代收集器,复制算法的收集器,并发的多线程收集器,目标是达到一个可控的吞吐量。如果虚拟机总共运行100分钟,其中垃圾花掉1分钟,吞吐量就是99%。Serial Old收集器: 是Serial收集器的老年代版本,单线程收集器,使用标记整理算法。Parallel Old收集器: 是Parallel Scavenge收集器的老年代版本,使用多线程,标记-整理算法。CMS(Concurrent Mark Sweep) 收集器: 是一种以获得最短回收停顿时间为目标的收集器,标记清除算法,运作过程:初始标记,并发标记,重新标记,并发清除,收集结束会产生大量空间碎片。G1收集器: 标记整理算法实现,运作流程主要包括以下:初始标记,并发标记,最终标记,筛选标记。不会产生空间碎片,可以精确地控制停顿。

    2)CMS收集器和G1收集器的区别:

    CMS收集器是老年代的收集器,可以配合新生代的Serial和ParNew收集器一起使用;G1收集器收集范围是老年代和新生代,不需要结合其他收集器使用;CMS收集器以最小的停顿时间为目标的收集器;G1收集器可预测垃圾回收的停顿时间CMS收集器是使用“标记-清除”算法进行的垃圾回收,容易产生内存碎片G1收集器使用的是“标记-整理”算法,进行了空间整合,降低了内存空间碎片。

    7.说说你知道的几种主要的JVM参数 思路: 可以说一下堆栈配置相关的,垃圾收集器相关的,还有一下辅助信息相关的。 我的答案: 1)堆栈配置相关

    java -Xmx3550m -Xms3550m -Xmn2g -Xss128k -XX:MaxPermSize=16m -XX:NewRatio=4 -XX:SurvivorRatio=4 -XX:MaxTenuringThreshold=0 复制代码 -Xmx3550m: 最大堆大小为3550m。 -Xms3550m: 设置初始堆大小为3550m。 -Xmn2g: 设置年轻代大小为2g。 -Xss128k: 每个线程的堆栈大小为128k。 -XX:MaxPermSize: 设置持久代大小为16m -XX:NewRatio=4: 设置年轻代(包括Eden和两个Survivor区)与年老代的比值(除去持久代)。 -XX:SurvivorRatio=4: 设置年轻代中Eden区与Survivor区的大小比值。设置为4,则两个Survivor区与一个Eden区的比值为2:4,一个Survivor区占整个年轻代的1/6 -XX:MaxTenuringThreshold=0: 设置垃圾最大年龄。如果设置为0的话,则年轻代对象不经过Survivor区,直接进入年老代。

    2)垃圾收集器相关

    -XX:+UseParallelGC -XX:ParallelGCThreads=20 -XX:+UseConcMarkSweepGC -XX:CMSFullGCsBeforeCompaction=5 -XX:+UseCMSCompactAtFullCollection: 复制代码 -XX:+UseParallelGC: 选择垃圾收集器为并行收集器。 -XX:ParallelGCThreads=20: 配置并行收集器的线程数 -XX:+UseConcMarkSweepGC: 设置年老代为并发收集。 -XX:CMSFullGCsBeforeCompaction:由于并发收集器不对内存空间进行压缩、整理,所以运行一段时间以后会产生“碎片”,使得运行效率降低。此值设置运行多少次GC以后对内存空间进行压缩、整理。 -XX:+UseCMSCompactAtFullCollection: 打开对年老代的压缩。可能会影响性能,但是可以消除碎片

    3)辅助信息相关

    -XX:+PrintGC -XX:+PrintGCDetails 复制代码 -XX:+PrintGC 输出形式: [GC 118250K->113543K(130112K), 0.0094143 secs] [Full GC 121376K->10414K(130112K), 0.0650971 secs] -XX:+PrintGCDetails 输出形式: [GC [DefNew: 8614K->781K(9088K), 0.0123035 secs] 118250K->113543K(130112K), 0.0124633 secs] [GC [DefNew: 8614K->8614K(9088K), 0.0000665 secs][Tenured: 112761K->10414K(121024K), 0.0433488 secs] 121376K->10414K(130112K), 0.0436268 secs

    8.jvm的常用命令jps jinfo jstat jstack jmap jhat

    三、容器

    1.java中的容器都有哪些? 2.Java 集合框架的基础接口有哪些?

    Collection ,为集合层级的根接口。一个集合代表一组对象,这些对象即为它的元素。Java 平台不提供这个接口任何直接的实现。 Set ,是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模,被用来代表集合,就如一副牌。List ,是一个有序集合,可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态变换的数组。 Map ,是一个将 key 映射到 value 的对象。一个 Map 不能包含重复的 key,每个 key 最多只能映射一个 value 一些其它的接口有 Queue、Dequeue、SortedSet、SortedMap 和 ListIterator 。

    3.Collection 和 Collections 有什么区别? java.util.Collection 是一个集合接口(集合类的一个顶级接口)。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式,其直接继承接口有List与Set。 Collections则是集合类的一个工具类/帮助类,其中提供了一系列静态方法,用于对集合中元素进行排序、搜索以及线程安全等各种操作。

    4.HashMap 和 Hashtable 有什么区别?

    hashMap去掉了HashTable 的contains方法,但是加上了containsValue()和containsKey()方法。hashTable同步的,而HashMap是非同步的,效率上逼hashTable要高。hashMap允许空键值,而hashTable不允许。

    5.如何决定使用 HashMap 还是 TreeMap? 对于在Map中插入、删除和定位元素这类操作,HashMap是最好的选择。然而,假如你需要对一个有序的key集合进行遍历,TreeMap是更好的选择。基于你的collection的大小,也许向HashMap中添加元素会更快,将map换为TreeMap进行有序key的遍历。

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

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

    当我们往Hashmap中put元素时,首先根据key的hashcode重新计算hash值,根绝hash值得到这个元素在数组中的位置(下标),如果该数组在该位置上已经存放了其他元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.如果数组中该位置没有元素,就直接将该元素放到数组的该位置上。

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

    7.hashmap put的流程?

    8. HashMap中确定数组位置为什么要用hash进行扰动?(Hash为什么要右移16位异或) 主要是为了减少哈希碰撞的概率。详参考博客(HashMap中确定数组位置为什么要用hash进行扰动?(Hash为什么要右移16位异或))

    9.使用hashmap时候什么时候需要重写hashcode和equals方法? 使用HashMap,如果key是自定义的类,就必须重写hashcode()和equals()。

    10.ConcurrentHashMap的实现,1.7和1.8的区别; :在JDK1.7中,ConcurrentHashMap采用Segment + HashEntry的方式进行实现,结构如下:

    该类包含两个静态内部类 HashEntry 和 Segment ;前者用来封装映射表的键值对,后者用来充当锁的角色;Segment 是一种可重入的锁 ReentrantLock,每个 Segment 守护一个HashEntry 数组里得元素,当对 HashEntry 数组的数据进行修改时,必须首先获得对应的 Segment 锁。 在JDK1.8中,放弃了Segment臃肿的设计,取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现,结构如下:

    11.说一下 HashSet 的实现原理?

    HashSet底层由HashMap实现HashSet的值存放于HashMap的key上HashSet不需要value,因此value统一为PRESENT

    12.ArrayList 和 LinkedList 的区别是什么? 最明显的区别是 ArrrayList底层的数据结构是数组,支持随机访问,而 LinkedList 的底层数据结构是双向循环链表,不支持随机访问。使用下标访问一个元素,ArrayList 的时间复杂度是 O(1),而 LinkedList 是 O(n)。

    13.Iterator 怎么使用?有什么特点? Java中的Iterator功能比较简单,并且只能单向移动:

    (1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时,它返回序列的第一个元素。注意:iterator()方法是java.lang.Iterable接口,被Collection继承。 (2) 使用next()获得序列中的下一个元素。 (3) 使用hasNext()检查序列中是否还有元素。 (4) 使用remove()将迭代器新返回的元素删除。 Iterator是Java迭代器最简单的实现,为List设计的ListIterator具有更多的功能,它可以从两个方向遍历List,也可以从List中插入和删除元素。

    四、多线程

    1.创建线程有哪几种方式?

    (1) 继承Thread类创建线程类

    定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 创建Thread子类的实例,即创建了线程对象。 调用线程对象的start()方法来启动该线程。 (2). 通过Runnable接口创建线程类

    定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。 创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。 调用线程对象的start()方法来启动该线程。 (3). 通过Callable和Future创建线程

    创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。 创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。 使用FutureTask对象作为Thread对象的target创建并启动新线程。 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

    2.线程有哪些状态? 线程通常都有五种状态,创建、就绪、运行、阻塞和死亡。

    创建状态。在生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态。 就绪状态。当调用了线程对象的start方法之后,该线程就进入了就绪状态,但是此时线程调度程序还没有把该线程设置为当前线程,此时处于就绪状态。在线程运行之后,从等待或者睡眠中回来之后,也会处于就绪状态。 运行状态。线程调度程序将处于就绪状态的线程设置为当前线程,此时线程就进入了运行状态,开始运行run函数当中的代码。 阻塞状态。线程正在运行的时候,被暂停,通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend,wait等方法都可以导致线程阻塞。 死亡状态。如果一个线程的run方法执行结束或者调用stop方法后,该线程就会死亡。对于已经死亡的线程,无法再使用start方法令其进入就绪

    3.sleep() 和 wait() 有什么区别? sleep():方法是线程类(Thread)的静态方法,让调用线程进入睡眠状态,让出执行机会给其他线程,等到休眠时间结束后,线程进入就绪状态和其他线程一起竞争cpu的执行时间。因为sleep() 是static静态的方法,他不能改变对象的机锁,当一个synchronized块中调用了sleep() 方法,线程虽然进入休眠,但是对象的机锁没有被释放,其他线程依然无法访问这个对象。

    wait():wait()是Object类的方法,当一个线程执行到wait方法时,它就进入到一个和该对象相关的等待池,同时释放对象的机锁,使得其他线程能够访问,可以通过notify,notifyAll方法来唤醒等待的线程。 4. notify()和 notifyAll()有什么区别? 如果线程调用了对象的 wait()方法,那么线程便会处于该对象的等待池中,等待池中的线程不会去竞争该对象的锁。 当有线程调用了对象的 notifyAll()方法(唤醒所有 wait 线程)或 notify()方法(只随机唤醒一个 wait 线程),被唤醒的的线程便会进入该对象的锁池中,锁池中的线程会去竞争该对象锁。也就是说,调用了notify后只要一个线程会由等待池进入锁池,而notifyAll会将该对象等待池内的所有线程移动到锁池中,等待锁竞争。 优先级高的线程竞争到对象锁的概率大,假若某线程没有竞争到该对象锁,它还会留在锁池中,唯有线程再次调用 wait()方法,它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行,直到执行完了 synchronized 代码块,它会释放掉该对象锁,这时锁池中的线程会继续竞争该对象锁。 5. 线程的 run()和 start()有什么区别? 每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。

    start()方法来启动一个线程,真正实现了多线程运行。这时无需等待run方法体代码执行完毕,可以直接继续执行下面的代码; 这时此线程是处于就绪状态, 并没有运行。 然后通过此Thread类调用方法run()来完成其运行状态, 这里方法run()称为线程体,它包含了要执行的这个线程的内容, Run方法运行结束, 此线程终止。然后CPU再调度其它线程。

    run()方法是在本线程里的,只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实就相当于是调用了一个普通函数而已,直接待用run()方法必须等待run()方法执行完毕才能执行下面的代码,所以执行路径还是只有一条,根本就没有线程的特征,所以在多线程执行时要使用start()方法而不是run()方法。

    6. 创建线程池有哪几种方式? (1). newFixedThreadPool(int nThreads)

    创建一个固定长度的线程池,每当提交一个任务就创建一个线程,直到达到线程池的最大数量,这时线程规模将不再变化,当线程发生未预期的错误而结束时,线程池会补充一个新的线程。

    (2) newCachedThreadPool() 这是一个可以无限扩大的线程池,它比较适合处理执行时间比较小的任务, corePoolSize为0,maximumPoolSize为无限大,意味着线程数量可以无限大, keepAliveTime为60S,意味着线程空闲时间超过60S就会被杀死, 采用 SynchronousQueue装等待的任务,这个阻塞队列没有存储空间,这意味着只要有请求到来,就必须要找到一条工作线程处理他,如果当前没有空闲的线程,那么就会再创建一条新的线程。

    (3). newSingleThreadExecutor()

    这是一个单线程的Executor,它创建单个工作线程来执行任务,如果这个线程异常结束,会创建一个新的来替代它;它的特点是能确保依照任务在队列中的顺序来串行执行。

    (4). newScheduledThreadPool(int corePoolSize)

    创建了一个固定长度的线程池,而且以延迟或定时的方式来执行任务,类似于Timer。

    7.CAS 原理及其优缺点

    参考博客(CAS 原理及其优缺点)

    8.volatile与synchronize的区别是什么? 1、Volatile轻量级的,只能修饰变量。synchronize重量级的,还可以修饰方法 2、Volatile只保证数据的可见性,不能用来同步,因为多线程访问Volatile变量不会阻塞 3、synchronize不仅保证可见性,而且保证原子性,因为自由获得了锁的线程才能到达临界区,从而保证了临界区中的所有语句被执行,多个线程抢夺synchronize锁的时候,会出现阻塞。

    9.ReentrantLock和Synchronized的区别和原理

    10.AQS 的原理 参考文章AQS 源码分析

    11.ThreadLocal是什么? (ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。 synchronized是利用锁的机制,使变量或代码块在某一时该只能被一个线程访问。 而ThreadLocal为每一个线程都提供了变量的副本,使得每个线程在某一时间访问到的并不是同一个对象,这样就隔离了多个线程对数据的数据共享。 而Synchronized却正好相反,它用于在多个线程间通信时能够获得数据共享)

    12.ThreadPoolExecutor 有哪些参数? corePoolSize: 线程池维护线程的最少数量 maximumPoolSize:线程池维护线程的最大数量 keepAliveTime: 线程池维护线程所允许的空闲时间 unit: 线程池维护线程所允许的空闲时间的单位 workQueue: 线程池所使用的缓冲队列 handler: 线程池对拒绝任务的处理策略

    13.ThreadPoolExecutor有哪些拒绝策略?

    1.AbortPolicy ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 这是线程池默认的拒绝策略,在任务不能再提交的时候,抛出异常,及时反馈程序运行状态。如果是比较关键的业务,推荐使用此拒绝策略,这样子在系统不能承载更大的并发量的时候,能够及时的通过异常发现。2.DiscardPolicy ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。如果线程队列已满,则后续提交的任务都会被丢弃,且是静默丢弃。 使用此策略,可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如,本人的博客网站统计阅读量就是采用的这种拒绝策略。3.DiscardOldestPolicy ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新提交被拒绝的任务。 此拒绝策略,是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略,还得根据实际业务是否允许丢弃老任务来认真衡量。4.CallerRunsPolicy ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务 如果任务被拒绝了,则由调用线程(提交任务的线程)直接执行此任务。

    五、反射

    1. 什么是反射? 反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力

    Java反射:

    在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法

    Java反射机制主要提供了以下功能:

    在运行时判断任意一个对象所属的类。 在运行时构造任意一个类的对象。 在运行时判断任意一个类所具有的成员变量和方法。 在运行时调用任意一个对象的方法。

    六、异常

    1.try-catch-finally 中,如果 catch 中 return 了,finally 还会执行吗? 答:会执行,在 return 前执行。

    代码示例1:

    package com.zx; public class hello { public static void main(String[] args) { getInt(); } public static int getInt() { int a = 10; try { System.out.println(a / 0); } catch (ArithmeticException e) { System.out.println("next is return a"); return a; } finally { System.out.println("next is a = 40"); } return a; } }

    结果是

    next is return a next is a = 40

    可以看出finally中的语句在catch中return之前被执行了。

    2.throw 和 throws 的区别? throw:

    表示方法内抛出某种异常对象如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出 即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常,否则编译报错执行到 throw 语句则后面的语句块不再执行 throws:方法的定义上使用 throws 表示这个方法可能抛出某种异常需要由方法的调用者进行异常处理

    3. final、finally、finalize 有什么区别? final可以修饰类、变量、方法,修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。 finally一般作用在try-catch代码块中,在处理异常的时候,通常我们将一定要执行的代码方法finally代码块中,表示不管是否出现异常,该代码块都会执行,一般用来存放一些关闭资源的代码。 finalize是一个方法,属于Object类的一个方法,而Object类是所有类的父类,该方法一般由垃圾回收器来调用,当我们调用System的gc()方法的时候,由垃圾回收器调用finalize(),回收垃圾。

    七、Java Web

    1.jsp 和 servlet 有什么区别? jsp经编译后就变成了Servlet.(JSP的本质就是Servlet,JVM只能识别java的类,不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类) jsp更擅长表现于页面显示,servlet更擅长于逻辑控制。 Servlet中没有内置对象,Jsp中的内置对象都是必须通过HttpServletRequest对象,HttpServletResponse对象以及HttpServlet对象得到。 Jsp是Servlet的一种简化,使用Jsp只需要完成程序员需要输出到客户端的内容,Jsp中的Java脚本如何镶嵌到一个类中,由Jsp容器完成。而Servlet则是个完整的Java类,这个类的Service方法用于生成对客户端的响应。

    2. Servlet生命周期

    加载Servlet。当Tomcat第一次访问Servlet的时候,Tomcat会负责创建Servlet的实例初始化。当Servlet被实例化后,Tomcat会调用init()方法初始化这个对象处理服务。当浏览器访问Servlet的时候,Servlet 会调用service()方法处理请求销毁。当Tomcat关闭时或者检测到Servlet要从Tomcat删除的时候会自动调用destroy()方法,让该实例释放掉所占的资源。一个Servlet如果长时间不被使用的话,也会被Tomcat自动销毁卸载。当Servlet调用完destroy()方法后,等待垃圾回收。如果有需要再次使用这个Servlet,会重新调用init()方法进行初始化操作。

    3.Servlet 中 doGet与doPost方法的两个参数是什么

    HttpServletRequest:封装了与请求相关的信息HttpServletResponse:封装了与响应相关的信息

    4、Servlet API中forward() 与redirect()的区别? forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器,其实客户端浏览器只发了一次请求,所以它的地址栏中还是原来的地址,session,request参数都可以获取。

    redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址,相当于客户端浏览器发送了两次请求。

    5.spring IOC 和 DI 怎么理解? **Ioc(Inversion of Control)**翻译成中文就是“控制反转”,一个比较晦涩的词语。如果要真正理解这个词语,必须要用过Spring框架才行,因为Spring开启了一种新的编程方式。

    传统的编程方式: 所有的对象和资源都是由开发人员来控制,由你来决定什么时候new一个对象,什么时候申请资源、使用资源、释放资源。

    使用Spring框架: 开发人员提供一个清单给Spring,然后对象的整个生命周期都是由Spring框架来管理,一个对象中引用的资源、引用的其他对象也都是由Spring框架来管理。

    深入剖析一下“控制反转”这个词:

    控制: 控制指的是控制外部资源的获取、控制对象的生命周期。

    反转: 刚开始流行的是由开发人员操纵一切,现在变了,由Spring框架来控制程序中的外部资源、控制对象的生命周期等。所以取名“反转”,即控制的权利由开发人员转移到了Spring框架。由Spring框架帮我创建我们对象中依赖的对象,我们的对象只能被动的接受。

    IOC的好处就是解耦,对象和对象之间的耦合度变低了,便于测试、便于功能复用。

    DI **DI(Dependency Injection)**翻译成中文叫做“依赖注入”,既然对象的整个生命周期都是由Spring框架来维护的,那么我的这个对象中引用了另一个对象,你打算怎么办?Spring框架自然考虑到这一点了。“依赖注入”这两个词语也要拆开来讲:

    依赖: 我的A对象中引用了B对象,也就是说A对象依赖B对象。你要通过配置文件告诉Spring你的对象之间的依赖关系。

    注入: 你的对象已经交给Spring管理了,你也告诉Spring你的对象之间的依赖关系了,那么在合适的时候,由Spring把你依赖的其他对象(或者资源、常量等)注入给你。

    总结就是,把所有的控制权交给Spring,由Spring帮你创建对象、帮你维护对象之间的依赖关系。

    6.spring AOP 怎么理解? Aop英文全称是 aspect object programming,即 面向切面编程功能,主要目的是让关注点代码与业务代码分离!面向切面编程就是指: 对很多功能都有的重复的代码抽取,再在运行的时候往业务方法上动态植入“切面类代码”。

    关注点: 重复代码就叫做关注点。

    切面: 关注点形成的类,就叫切面(类)

    切入点: 执行目标对象方法,动态植入切面代码。 可以通过切入点表达式,指定拦截哪些类的哪些方法; 给指定的类在运行的时候植入切面类代码。

    切入点表达式: 指定哪些类的哪些方法被拦截

    7. spring @autowired 和@resource区别是什么?

    1、共同点 两者都可以写在属性和setter方法上。两者如果都写在字段上,那么就不需要再写setter方法。

    2、不同点

    (1)@Autowired

    @Autowired为Spring提供的注解,需要导入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

    @Autowired注解是按照类型(byType)装配依赖对象,默认情况下它要求依赖对象必须存在,如果允许null值,可以设置它的required属性为false。如果我们想使用按照名称(byName)来装配,可以结合@Qualifier注解一起使用。

    (2)@Resource

    @Resource默认按照ByName自动注入,由J2EE提供,需要导入包javax.annotation.Resource。@Resource有两个重要的属性:name和type,而Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以,如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性,这时将通过反射机制使用byName自动注入策略。

    8. @RequestMapping 的作用是什么? RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。

    RequestMapping注解有六个属性,下面我们把她分成三类进行说明。

    value, method:

    value:指定请求的实际地址,指定的地址可以是URI Template 模式(后面将会说明); method:指定请求的method类型, GET、POST、PUT、DELETE等; consumes,produces

    consumes:指定处理请求的提交内容类型(Content-Type),例如application/json, text/html; produces:指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回; params,headers

    params: 指定request中必须包含某些参数值是,才让该方法处理。 headers:指定request中必须包含某些指定的header值,才能让该方法处理请求。

    9.mybatis常用标签有哪些?

    10.springboot的优点是什么?

    简化编码 比如我们要创建一个 web 项目,使用 Spring 的朋友都知道,在使用 Spring 的时候,需要在 pom 文件中添加多个依赖,而 Spring Boot 则会帮助开发着快速启动一个 web 容器,在 Spring Boot 中,我们只需要在 pom 文件中添加如下一个 starter-web 依赖即可。 我们点击进入该依赖后可以看到,Spring Boot 这个 starter-web 已经包含了多个依赖,包括之前在 Spring 工程中需要导入的依赖。由此可以看出,Spring Boot 大大简化了我们的编码,我们不用一个个导入依赖,直接一个依赖即可。

    简化配置 Spring 虽然使Java EE轻量级框架,但由于其繁琐的配置,一度被人认为是“配置地狱”。各种XML、Annotation配置会让人眼花缭乱,而且配置多的话,如果出错了也很难找出原因。Spring Boot更多的是采用 Java Config 的方式,对 Spring 进行配置。

    简化部署 在使用 Spring 时,项目部署时需要我们在服务器上部署 tomcat,然后把项目打成 war 包扔到 tomcat里,在使用 Spring Boot 后,我们不需要在服务器上去部署 tomcat,因为 Spring Boot 内嵌了 tomcat,我们只需要将项目打成 jar 包,使用 java -jar xxx.jar一键式启动项目。 另外,也降低对运行环境的基本要求,环境变量中有JDK即可。

    简化监控 我们可以引入 spring-boot-start-actuator 依赖,直接使用 REST 方式来获取进程的运行期性能参数,从而达到监控的目的,比较方便。但是 Spring Boot 只是个微框架,没有提供相应的服务发现与注册的配套功能,没有外围监控集成方案,没有外围安全管理方案,所以在微服务架构中,还需要 Spring Cloud 来配合一起使用。

    Processed: 0.013, SQL: 9