Java面试考核题

1.1Java基础

 

1.集合有哪些?数据结构?初始长度?扩容机制?哪些是线程安全的? hashmap的底层原理?

集合类型主要有3种：set(集）、list(列表）和map(映射)。

1、List（有序、可重复）

List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。

2、Set（无序、不能重复）

Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。

3、Map（键值对、键唯一、值不唯一）

Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

Set接口数据结构

哈希表存储结构

List

有序可重复

ArrayList

ArrayList数据结构是数组。查询快，增删慢。ArrayList是线程不安全的，允许元素为null 。

Vector

线程安全的数组，效率较差，已经过时不用。

LinkedList

LinkedList 数据结构是双向链表，插入删除比较方便。LinkedList 是线程不安全的，允许元素为null 。

Map

Map遍历

map遍历的方式有4种，分别是：1、使用for循环遍历map；2、使用迭代遍历map；3、使用keySet迭代遍历map；4、使用entrySet遍历map

HashMap :

jdk1.8中HashMap底层是哈希表数据结构，数组+链表+红黑树，HashMap是线程不安全的，允许使用null键和null值，

HashMap根据键的HashCode值存储数据，具有很快的访问速度。

HashMap存入的键值对在遍历时的顺序是随机的。

HashMap不支持并发

HashTable:

线程安全，使用synchronized锁住全部数据，效率较低。

LinkedHashMap:

LinkedHashMap 是HashMap的一个子类，默认LinkedHashMap遍历时输出的顺序和put输入的顺序是相同的。

LinkedHashMap有两种排序方式：插入排序和访问排序（修改或访问一个元素后，将该元素移到队列末尾），默认是插入排序。使用accessOrder来标记使用哪种排序方式，accessOrder==true时，表示使用访问排序，默认为false；

LinkedHashMap使用了双向链表来保证了顺序性。

TreeMap:

TreeMap底层是红黑树数据结构，线程不安全，可以用于给Map集合中的键进行排序

TreeMap遍历出来的是排序后的键值对。

ConcurrentHashMap

ConcurrentHashMap是线程安全的，jdk1.8使用CAS和volatile实现。而jdk1.8以前通过锁分段技术、可重入锁实现。

支持并发，可以一边更新一边遍历

初始长度 扩容机制

 

默认初始容量         加载因子      一次扩容后的容量

Arraylist 10                          1.5n+1

Vector   10              1              2n

HashSet  16             0.75             2n

HashMap  16            0.75           2n

线程安全和线程不安全的集合

Vector、HashTable、Properties是线程安全的；

ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。

值得注意的是：为了保证集合是线程安全的，相应的效率也比较低；线程不安全的集合效率相对会高一些。

HashMap 的实现原理？

HashMap的put()和get()的实现

map.put:

1.调用hashcode方法得出hash值  2.通过哈希算法转化成下标  3.下标位置上如果没有任何元素，就把Node添加到这个位置上  4.如果对应位置有链表 用key和链表上的key进行equals  5.如果map.put返回值都为false则添加到末尾 如果有为true的 覆盖value

map.get:

1. 调用hashcode方法得出hash值  2.通过哈希算法转化成下标  3.下标位置上如果没有任何元素，就返回null  4.如果对应位置有链表 用key和链表上的key进行equals  5.如果map.get 都是false则返回null 如果有true就返回对应value

哈希冲突的产生原因

哈希是通过对数据进行再压缩，提高效率的一种解决方法。但由于通过哈希函数产生的哈希值是有限的，而数据可能比较多，导致经过哈希函数处理后仍然有不同的数据对应相同的值。这时候就产生了哈希冲突。

产生哈希冲突的影响因素

装填因子（装填因子=数据总数 / 哈希表长）、哈希函数、处理冲突的方法

解决哈希冲突的四种方法

1.开放地址方法

　　（1）线性探测

　　　按顺序决定值时，如果某数据的值已经存在，则在原来值的基础上往后加一个单位，直至不发生哈希冲突。　

　　（2）再平方探测

　　　按顺序决定值时，如果某数据的值已经存在，则在原来值的基础上先加1的平方个单位，若仍然存在则减1的平方个单位。随之是2的平方，3的平方等等。直至不发生哈希冲突。

　　（3）伪随机探测

　　　按顺序决定值时，如果某数据已经存在，通过随机函数随机生成一个数，在原来值的基础上加上随机数，直至不发生哈希冲突。

2.链式地址法（HashMap的哈希冲突解决方法）

　　对于相同的值，使用链表进行连接。使用数组存储每一个链表。

　　优点：

　　（1）拉链法处理冲突简单，且无堆积现象，即非同义词决不会发生冲突，因此平均查找长度较短；

　　（2）由于拉链法中各链表上的结点空间是动态申请的，故它更适合于造表前无法确定表长的情况；

　　（3）开放定址法为减少冲突，要求装填因子α较小，故当结点规模较大时会浪费很多空间。而拉链法中可取α≥1，且结点较大时，拉链法中增加的指针域可忽略不计，因此节省空间；

　　（4）在用拉链法构造的散列表中，删除结点的操作易于实现。只要简单地删去链表上相应的结点即可。
　　缺点：

　　指针占用较大空间时，会造成空间浪费，若空间用于增大散列表规模进而提高开放地址法的效率。

3.建立公共溢出区

　　建立公共溢出区存储所有哈希冲突的数据。

4.再哈希法

　　对于冲突的哈希值再次进行哈希处理，直至没有哈希冲突。

2.jvm内存模型的理解?

JVM 内存共分为虚拟机栈，堆，方法区，程序计数器，本地方法栈五个部分。

（1）程序计数器（Program Counter Register）：当前线程所执行的字节码的行号指示器，字节码解析器的工作是通过改变这个计数器的值，来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能，都需要依赖这个计数器来完成；

（2）Java 虚拟机栈（Java Virtual Machine Stacks）：用于存储局部变量表、操作数栈、动态链接、方法出口等信息；

（3）本地方法栈（Native Method Stack）：与虚拟机栈的作用是一样的，只不过虚拟机栈是服务 Java 方法的，而本地方法栈是为虚拟机调用 Native 方法服务的；

（4）Java 堆（Java Heap）：Java 虚拟机中内存最大的一块，是被所有线程共享的，几乎所有的对象实例都在这里分配内存；

（5）方法区（Methed Area）：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数据。

3.jvm垃圾回收机制和jvm调优?

1.1 分代管理

将堆和方法区按照对象不同年龄进行分代：

新生代：

1.      所有新对象创建发生在Eden区，Eden区满后触发新生代上的minor GC，将Eden区和非空闲Survivor区存活对象复制到另一个空闲的Survivor区中。

2.      永远保证一个Survivor是空的，新生代minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。

旧生代：

1.      Eden区满后触发minor GC将存活对象复制到Survivor区，Survivor区满后触发minor GC将存活对象复制到旧生代。

2.      经过新生代的两个Survivor之间多次复制，仍然存活下来的对象就是年龄相对比较老的，就可以放入到旧生代了，随着时间推移，如果旧生代也满了，将触发Full GC，针对整个堆（包括新生代、旧生代和持久代）进行垃圾回收。

1.2 垃圾回收

要执行gc关键在于两点，一是检测出垃圾对象，二是释放垃圾对象所占用的空间。

1.2.1 检测垃圾对象

检测出垃圾对象一般有两种算法：

1. 引用计数法

为每一个创建的对象分配一个引用计数器，用来存储该对象被引用的个数。当该个数为零，意味着没有人再使用这个对象，可以认为“对象死亡”。但是，这种方案存在严重的问题，就是无法检测“循环引用”：当两个对象互相引用，即时它俩都不被外界任何东西引用，它俩的计数都不为零，因此永远不会被回收。而实际上对于开发者而言，这两个对象已经完全没有用处了。

因此，Java 里没有采用这样的方案来判定对象的“存活性”。

2、 可达性分析

基本思路是把所有引用的对象想象成一棵树，从树的根结点 GC Roots 出发，持续遍历找出所有连接的树枝对象，这些对象则被称为“可达”对象，或称“存活”对象。其余的对象则被视为“死亡”的“不可达”对象，或称“垃圾”。

1.2.2 释放空间

1、垃圾回收算法

复制(Copying)

标记-清除(Mark-Sweep)

标记-整理(Mark-Compact)

2.1 性能调优的目的

减少minor gc的频率、以及full gc的次数

2.2 性能调优的手段

1.使用JDK提供的内存查看工具，如JConsole和Java VisualVM

2.控制堆内存各个部分所占的比例

3.采用合适的垃圾收集器

手段1：内存查看工具(如jstat)和GC日志分析

手段2：针对新生代和旧生代的比例

手段3：针对Eden和Survivor的比例

手段4：采用正确的垃圾收集器

 

 

4.线程的创建? 开启?状态? sleep 和wait的区别?线程池?死锁?如何保证线程安全?

创建

1）继承Thread类创建线程

2）实现Runnable接口创建线程

3）使用Callable创建线程

相同点：

1、两者都是接口

2、两者都需要调用Thread.start启动线程

不同点：

1、如上面代码所示，callable的核心是call方法，允许返回值，runnable的核心是run方法，没有返回值

2、call方法可以抛出异常，但是run方法不行

3、因为runnable是java1.1就有了，所以他不存在返回值，后期在java1.5进行了优化，就出现了callable，就有了返回值和抛异常

4、callable和runnable都可以应用于executors。而thread类只支持runnable

开启

1. start（）方法来启动线程，真正实现了多线程运行。
2. run（）方法当作普通方法的方式调用。

状态：创建、就绪、运行、阻塞和死亡。

共同点：

都是使线程暂停一段时间的方法。

不同点：

①原理不同-sleep()是属于Thread类中的,而wait()方法，则是属于Object类中的。

②锁处理机制不同-sleep()最主要作用使线程暂停执行一段时间，时间一到自动恢复，不涉及线程通讯，因此，调用sleep()方法并不会释放锁。而当调用wait()方法的时候，线程会释放它所占的锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

③使用区域不同-wait()方法必须放在同步代码块或者同步方法中使用，sleep()可以用在任何地方

线程池

降低资源消耗。通过重复利用已创建的线程，降低线程创建和销毁造成的消耗。

提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

增加线程的可管理型。线程是稀缺资源，使用线程池可以进行统一分配，调优和监控。

什么是死锁？

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者进程在运行过程中，请求和释放资源的顺序不当而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

保证线程安全

1、使用线程安全的类；

2、使用synchronized同步代码块，或者用Lock锁；

1）Lock 是一个接口；synchronized 是 Java 中的关键字，synchronized 是内置的语言实现；

2）Lock 在发生异常时，如果没有主动通过 unLock() 去释放锁，很可能会造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁；synchronized 不需要手动获取锁和释放锁，在发生异常时，会自动释放锁，因此不会导致死锁现象发生；

3）Lock 的使用更加灵活，可以有响应中断、有超时时间等；而 synchronized 却不行，使用 synchronized 时，等待的线程会一直等待下去，直到获取到锁；

4）在性能上，随着近些年 synchronized 的不断优化，Lock 和 synchronized 在性能上已经没有很明显的差距了，所以性能不应该成为我们选择两者的主要原因。官方推荐尽量使用 synchronized，除非 synchronized 无法满足需求时，则可以使用 Lock。

3、多线程并发情况下，线程共享的变量改为方法局部级变量；

volatile关键字会触发lock前缀指令，进而触发缓存一致性协议以及想配套的锁，从而保障了线程可见。

synchronized 关键字底层原理

Synchronized进过编译，通过内部对象Monitor(监视器锁)实现，会在同步块的前后分别形成monitorenter和monitorexit这个两个字节码指令。在执行monitorenter指令时，首先要尝试获取对象锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象锁，把锁的计算器加1，相应的，在执行monitorexit指令时会将锁计算器就减1，当计算器为0时，锁就被释放了。如果获取对象锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

5. 重写与重载的区别?

重载：一个类中有多个同名的方法，但是具有有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）。

重写：发生在子类与父类之间，子类对父类的方法进行重写，参数都不能改变，返回值类型可以不相同，但是必须是父类返回值的派生类。

 

6.java中字符串的方法有哪些? string stringbuilder stringbuffer 的区别?

indexOf()：返回指定字符的索引。

charAt()：返回指定索引处的字符。

replace()：字符串替换。

trim()：去除字符串两端空白。

split()：分割字符串，返回一个分割后的字符串数组。

getBytes()：返回字符串的 byte 类型数组。

length()：返回字符串长度。

toLowerCase()：将字符串转成小写字母。

toUpperCase()：将字符串转成大写字符。

substring()：截取字符串。

equals()：字符串比较。

String：String 的值被创建后不能修改，任何对 String 的修改都会引发新的 String 对象的生成。

StringBuffer：跟 String 类似，但是值可以被修改，使用 synchronized 来保证线程安全。

StringBuilder：StringBuffer 的非线程安全版本，没有使用 synchronized，具有更高的性能，推荐优先使用。

7. == 和equals的区别?

==：运算符，用于比较基础类型变量和引用类型变量。

对于基础类型变量，比较的变量保存的值是否相同，类型不一定要相同。

对于引用类型变量，比较的是两个对象的地址是否相同。

equals 在 Object 方法中其实等同于 ==，但是在实际的使用中，equals 通常被重写用于比较两个对象的值是否相同。

8. 对反射的理解?获取Class对象的方式有哪些?如何用反射取私有属性Filed?

反射是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能称为反射机制。

 1、new Object().getClass 2、Object.class 3、 Class.forName(“java.util.String”)

利用反射，首先是Class字节码对象的获取，

// 获得指定类的属性

Field field = clazz.getDeclaredField("name");

// 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查。

field.setAccessible(true);取消 Java 语言访问检查

9.常用设计模式有哪些? 在项目中哪里有用到?单例中懒汉饿汉优缺点?

工厂设计模式 : Spring使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。

代理设计模式 : Spring AOP 功能的实现。

单例设计模式 : Spring 中的 Bean 默认都是单例的。

1、时间和空间

懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

2、线程安全

从线程安全性上讲，不加同步的懒汉式是线程不安全的，饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

代理模式

Java中实现代理模式主要有三种方式：

静态代理

动态代理

cglib代理

作用

1.Proxy类的代码量被固定下来，不会因为业务的逐渐庞大而庞大；

2.可以实现AOP编程，实际上静态代理也可以实现，总的来说，AOP可以算作是代理模式的一个典型应用；

3.解耦，通过参数就可以判断真实类，不需要事先实例化，更加灵活多变。

 

10. jdk1. 8的新特性有哪些?

Lambda表达式

函数式接口

*方法引用和构造器调用

Stream API

接口中的默认方法和静态方法

新时间日期API

 

11.泛型的理解?什么是类型擦除?

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），

然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，

操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

擦除是将泛型类型以其父类代替，如String 变成了Object等。其实在使用的时候还是进行带强制类型的转化，只不过这是比较安全的转换，因为在编译阶段已经确保了数据的一致性。

12. error和exception的区别?常见的异常及异常处理的方式有哪些?

Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。

Exception类表示程序可以处理的异常，可以捕获且可能恢复。

ArrayIndexOutOfBoundsException 数组下标越界异常，
ArithmaticException 算数异常 如除数为零
NullPointerException 空指针异常
IllegalArgumentException 不合法参数异常

13. 类加载机制?代码块的执行顺序?

类加载分为三个步骤：加载、连接、初始化。

首先执行静态代码块，接着执行构造代码块，最后指向构造方法

14. cookie 和session的区别? session 的实现原理?session的生命周期? session 如何存储数据?

cookie保存在客户端，session保存在服务器端，

cookie目的可以跟踪会话，也可以保存用户喜好或者保存用户名密码

session用来跟踪会话

 session 的实现原理

　当用户访问到一个服务器，如果服务器启用Session，服务器就要为该用户创建一个SESSION，在创建这个SESSION的时候，服务器首先检查这个用户发来的请求里是否包含了一个SESSION ID，如果包含了一个SESSION ID则说明之前该用户已经登陆过并为此用户创建过SESSION，那服务器就按照这个SESSION ID把这个SESSION在服务器的内存中查找出来，如果客户端请求里不包含有SESSION ID，则为该客户端创建一个SESSION并生成一个与此SESSION相关的SESSION ID。

Session的生命周期

Session存储在服务器的内存中（为了高速存取）。

Session何时生效

Sessinon在用户访问第一次访问服务器时创建，需要注意只有访问JSP、Servlet等程序时才会创建Session，只访问HTML、IMAGE等静态资源并不会创建Session,可调用request.getSession(true)强制生成Session。

Session何时失效

服务器会把长时间没有活动的Session从服务器内存中清除，此时Session便失效。Tomcat中Session的默认失效时间为20分钟。

Session的存储方式

sessionid是一个会话的key，浏览器第一次访问服务器会在服务器端生成一个session，有一个sessionid和它对应。tomcat生成的sessionid叫做jsessionid。

session在访问tomcat服务器HttpServletRequest的getSession(true)的时候创建，tomcat的ManagerBase类提供创建sessionid的方法：随机数+时间+jvmid。

存储在服务器的内存中，tomcat的StandardManager类将session存储在内存中，也可以持久化到file，数据库，memcache，redis等。客户端只保存sessionid到cookie中，而不会保存session，session销毁只能通过invalidate或超时，关掉浏览器并不会关闭session。

Cookie和session的联系

Cookies是属于Session对象的一种。但有不同，Cookies不会占服务器资源，是存在客服端内存或者一个cookie的文本文件中；而“Session”则会占用服务器资源。

SessionId的保存方法

使用Cookie来保存

使用URL附加信息的方式

第三种方式是在页面表单里面增加隐藏域

15.java中锁的种类和基本原理?

乐观锁/悲观锁

乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。

悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改自己的数据，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。

独享锁/共享锁

独享锁是指该锁一次只能被一个线程所持有，Java ReentrantLock就是独享锁，Synchronized也是独享锁。

共享锁是指该锁可被多个线程所持有，Java ReadWriteLock其读锁是共享锁，其写锁是独享锁，读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

互斥锁/读写锁

互斥锁/读写锁是具体的实现。
互斥锁在Java中的具体实现就是ReentrantLock，读写锁在Java中的具体实现就是ReadWriteLock。

可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁，ReetrantLock和Synchronized都是可重入锁。

公平锁/非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁。

非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。

偏向锁/轻量级锁/重量级锁

偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价。

轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

重量级锁是指