java基础面经--下

24、反射的实现与作用

Java语言编译之后会生成一个.class文件，反射就是通过字节码文件找到某一个类，类中的方法以及属性等。反射的实现主要借助以下四个类：

Class:类的对象

Constructor：类的构造方法

Field:类中的属性对象

Method:类中的方法对象

作用：反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，那么就可以通过反射机制来获取类的所有信息。

反射的优点和缺点：优点就是增加灵活性，可以在运行时动态获取对象实例。缺点是反射的效率很低，而且会破坏封装，通过反射可以访问类的私有方法，不安全。

什么是代理模式？ 中介

 代购，中介的意思

定义：代理模式是指，为其他对象提供一种代理以控制对这个对象的访问。

目的：为了在不修改目标对象的基础上，增强主业务逻辑。

举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。用图表示如下：

为什么要用代理模式？

• 控制访问：代理类不允许你访问目标，例如商家不让用户访问厂家。
• 开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成（aop），而没必要打开已经封装好的委托类。

什么是静态代理和动态代理？优缺点？

按照代理创建的时期来进行分类的话， 可以分为两种：静态代理、动态代理。

静态代理是指代理类在程序运行之前就已经定义好了.java源文件，其与目标类的关系在程序运行之前就已经确立。在程序运行前代理类已经编译为.class文件。

动态代理是在程序运行时通过反射机制动态创建的。

1.静态代理     

 第一步：创建服务类接口

 1 package main.java.proxy;
 2 
 3 /**
 4  * @Auther: dan gao
 5  * @Description:
 6  * @Date: 22:40 2018/1/9 0009
 7  */
 8 public interface BuyHouse {
 9     void buyHosue();
10 }

第二步：实现服务接口

 1 import main.java.proxy.BuyHouse;
 2 
 3 /**
 4  * @Auther: dan gao
 5  * @Description:
 6  * @Date: 22:42 2018/1/9 0009
 7  */
 8 public class BuyHouseImpl implements BuyHouse {
 9 
10     @Override
11     public void buyHosue() {
12         System.out.println("我要买房");
13     }
14 }

第三步：创建代理类

 1 package main.java.proxy.impl;
 2 
 3 import main.java.proxy.BuyHouse;
 4 
 5 /**
 6  * @Auther: dan gao
 7  * @Description:
 8  * @Date: 22:43 2018/1/9 0009
 9  */
10 public class BuyHouseProxy implements BuyHouse {
11 
12     private BuyHouse buyHouse;
13 
14     public BuyHouseProxy(final BuyHouse buyHouse) {
15         this.buyHouse = buyHouse;
16     }
17 
18     @Override
19     public void buyHosue() {
20         System.out.println("买房前准备");
21         buyHouse.buyHosue();
22         System.out.println("买房后装修");
23 
24     }
25 }

第四步：编写测试类

import main.java.proxy.impl.BuyHouseImpl;
import main.java.proxy.impl.BuyHouseProxy;

/**
 * @Auther: dan gao
 * @Description:
 * @Date: 22:43 2018/1/9 0009
 */
public class ProxyTest {
    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImpl();
        buyHouse.buyHosue();
        BuyHouseProxy buyHouseProxy = new BuyHouseProxy(buyHouse);
        buyHouseProxy.buyHosue();
    }
}

静态代理总结：

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。                                             

2.动态代理

　　在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态处理器就可以了。真正的代理对象由JDK再运行时为我们动态的来创建。

第一步：编写动态处理器

 1 package main.java.proxy.impl;
 2 
 3 import java.lang.reflect.InvocationHandler;
 4 import java.lang.reflect.Method;
 5 
 6 /**
 7  * @Auther: dan gao
 8  * @Description:
 9  * @Date: 20:34 2018/1/12 0012
10  */
11 public class DynamicProxyHandler implements InvocationHandler {
12 
13     private Object object;
14 
15     public DynamicProxyHandler(final Object object) {
16         this.object = object;
17     }
18 
19     @Override
20     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
21         System.out.println("买房前准备");
22         Object result = method.invoke(object, args);
23         System.out.println("买房后装修");
24         return result;
25     }
26 }

第二步：编写测试类

 1 package main.java.proxy.test;
 2 
 3 import main.java.proxy.BuyHouse;
 4 import main.java.proxy.impl.BuyHouseImpl;
 5 import main.java.proxy.impl.DynamicProxyHandler;
 6 
 7 import java.lang.reflect.Proxy;
 8 
 9 /**
10  * @Auther: dan gao
11  * @Description:
12  * @Date: 20:38 2018/1/12 0012
13  */
14 public class DynamicProxyTest {
15     public static void main(String[] args) {
16         BuyHouse buyHouse = new BuyHouseImpl();
17         BuyHouse proxyBuyHouse = (BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new
18                 Class[]{BuyHouse.class}, new DynamicProxyHandler(buyHouse));
19         proxyBuyHouse.buyHosue();
20     }
21 }

 注意Proxy.newProxyInstance()方法接受三个参数：

• ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法是固定的
• Class<?>[] interfaces:指定目标对象实现的接口的类型,使用泛型方式确认类型
• InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法

动态代理总结：

优点：相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。

缺点：但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫Proxy。Java的继承机制注定了这些动态代理类们无法实现对class的动态代理，原因是多继承在Java中本质上就行不通。有很多条理由，人们可以否定对 class代理的必要性，但是同样有一些理由，相信支持class动态代理会更美好。接口和类的划分，本就不是很明显，只是到了Java中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。但是，不完美并不等于不伟大，伟大是一种本质，Java动态代理就是佐例。

3.CGLIB代理

       JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

第一步：创建CGLIB代理类

 1 package dan.proxy.impl;
 2 
 3 import net.sf.cglib.proxy.Enhancer;
 4 import net.sf.cglib.proxy.MethodInterceptor;
 5 import net.sf.cglib.proxy.MethodProxy;
 6 
 7 import java.lang.reflect.Method;
 8 
 9 /**
10  * @Auther: dan gao
11  * @Description:
12  * @Date: 20:38 2018/1/16 0016
13  */
14 public class CglibProxy implements MethodInterceptor {
15     private Object target;
16     public Object getInstance(final Object target) {
17         this.target = target;
18         Enhancer enhancer = new Enhancer();
19         enhancer.setSuperclass(this.target.getClass());
20         enhancer.setCallback(this);
21         return enhancer.create();
22     }
23 
24     public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
25         System.out.println("买房前准备");
26         Object result = methodProxy.invoke(object, args);
27         System.out.println("买房后装修");
28         return result;
29     }
30 }

第二步：创建测试类

 1 package dan.proxy.test;
 2 
 3 import dan.proxy.BuyHouse;
 4 import dan.proxy.impl.BuyHouseImpl;
 5 import dan.proxy.impl.CglibProxy;
 6 
 7 /**
 8  * @Auther: dan gao
 9  * @Description:
10  * @Date: 20:52 2018/1/16 0016
11  */
12 public class CglibProxyTest {
13     public static void main(String[] args){
14         BuyHouse buyHouse = new BuyHouseImpl();
15         CglibProxy cglibProxy = new CglibProxy();
16         BuyHouseImpl buyHouseCglibProxy = (BuyHouseImpl) cglibProxy.getInstance(buyHouse);
17         buyHouseCglibProxy.buyHosue();
18     }
19 }

CGLIB代理总结： CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。

JDK动态代理和CGLIB代理有什么区别？

JDK动态代理主要针对类实现了某个接口，AOP则会使用JDK动态代理（spring的代理模式）。他基于反射机制实现，生成一个实现同样接口的代理类，然后通过重写的方式，实现读代码的增强。

而如果某个类没有实现接口，AOP则会使用CGLIB代理。CGLIBd的原理是继承，底层是基于ASM第三方框架，通过修改字节码，生成一个子类，然后重写父类的方法，实现对代码的增强。

25、注解的原理

注解本质是一个继承了Annotation 的特殊接口，其具体实现类是Java 运行时生成的动态代理类。而我们通过反射获取注解时，返回的是Java 运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用AnnotationInvocationHandler 的invoke 方法。该方法会从memberValues 这个Map 中索引出对应的值。而memberValues 的来源是Java 常量池。

26、Integer和int＝5的区别：

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

Java 为每个原始类型提供了包装类型：

• - 原始类型: boolean，char，byte，short，int，long，float，double
• - 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

如：

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比较

    }

}

区别：

1. Integer是int的包装类，int则是java的一种基本数据类型。
2. Integer变量必须实例化后才能使用，而int变量不需要。
3. Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象，而int则是直接存储数据值。
4. Integer的默认值是null,int的默认值是0.

面试：为什么使用包装类型？

包装类型可以解决一些基本类型解决不了的问题：

1.集合不允许存放基本数据类型。add(Object o)

2.函数需要传递进去的参数为Object类型，传入基本数据类型就不可行。

3.基本类型可以和包装类型之间相互转换，自动装箱拆箱。

4.通过包装类型的parse方法可以实现基本数据类型和String类型之间的相互转换。

假设有这样一个场景，我接收到一个String型的数据想把它转换为整型，如果没有包装类这个操作是无法完成的，有了包装类我们可以这样做：

String num1 = "123";
int num2 = Integer.parseInt(num1);

parseInt就是Integer包装类提供的一个将字符串转成int型的方法。

27、equals和== 有什么区别？

1. 对于字符串的比较“==”比较的是两个字符串的地址

2. 对于字符串的比较 “equals”比较的是两个字符串的内容

<1>先说”==”:

对于基本数据类型 （byte,short,char,int,long,float,double,boolean）的变量”==”比较的是两个变量的值是否相等。

比如：int a = 3; int b = 3; a==b;返回就是true

对于引用类型如,则比较的是该变量所指向的地址.

拿我们最常用的String型来举例：

比如：String a = “abc”; String b = “abc”;

在这种情况下 字符串直接赋值给变量，该字符串会进入到常量池中，当第一次将 “abc”赋值给a的时候，会去常量池中找看有没有”abc”这个字符串，如果有的话，就将a指向该字符串在常量池中的地址，如果没有则在常量池中创建，第二次赋值 将 “abc”赋值给b的时候同样去常量池中找”abc”这个字符串，然后将他的地址赋值给b.

所以我们在做 a==b操作的时候返回的为true

再来看另一种情况：String a = new String(“abc”) ; String b = new String(“abc”);

这种情况下我们在做 a==b操作的时候返回的为false。

当我们使用 String a = new String(“abc”)创建一个字符串对象时在内存里面是这样分配空间的，首先会去常量池中找”abc”如果找到了再创建一个”abc”对象存到堆中，并且他的值指向堆中的”abc”，如果没有找到则先在常量池中创建”abc”，再在堆内存开辟一块内存空间创建”abc”，并且他的值指向堆中的”abc”。

<2>再来看”equals”:

Equals方法是在Object类中定义的，所有的类都继承于Object类，所以所有的类都有equals方法。

我们来看看equals方法的源码：

可以看到在Object类的equals方法中也是用的”==”来进行比较，所以在进行比较时它和”==”应该时等价的，但是为什么我们在做 字符串比较的时候 两者比较出来的结果不一样呢？

原因就是 String类型对equals方法进行了重写。我们来看源码：

从源码我们可以看出，在String的equals方法中对字符串的字符进行了逐一比较如果都相同则返回true.所以对于String中的equals方法比较的是两个字符串的内容对于：

String a = new String(“abc”) ; String b = new String(“abc”);

由于a和b的内容相同，返回true.

28、final、finally、finalize的区别

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

29、数据库中char与varchar的区别：

char是一种固定长度的类型，varchar是一种可变长度的类型。

• char如果存入数据的实际长度比指定长度要小，会补空格至指定长度，如果存入的数据的实际长度大于指定长度，低版本会被截取，高版本会报错。
• varchar类型的数据如果存入的数据的实际长度比指定的长度小，会缩短到实际长度，如果存入数据的实际长度大于指定长度，低版本会被截取，高版本会报错。

char效率会更高，但varchar更节省空间。

30、String、StringBuilder、StringBuffer的区别：

1.String对象一旦创建之后就是不可变的！而StringBuilder，StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用。

2.StringBuilder是一个可变的字符串类！可以把它看作一个容器。

• StringBuilder 可以通过 toString()方法转换成 String
• String 可以通过 StringBuilder 的构造方法，转换成 StringBuilder

String string = new StringBuffer().toString();
StringBulider stringBuilder = new StringBulider(new String());

StringBuilder 拼接字符串的效率较高，但是它不是线程安全的！

3.StringBuffer 同样是一个可变的字符串类！也可以被看作是一个容器。

• StringBuffer 可以通过 toString()方法转换成 String
• String 可以通过 StringBuffer 的构造方法，转换成 StringBuffer

String string = new StringBuffer().toString();
StringBuffer stringBuffer = new StringBuffer(new String());

Stringbuffer拼接字符串的效率相对于 StringBuilder 较低，但是它是线程安全的！（加了synchronized）
 

31、Java的容器：

容器是一个java所编写的程序，原先必须自行编写程序以管理对象关系，容器会自动帮您做好。

• 常用的容器：WebSphere，Weblogic,Resinm，Tomcat,Glassfish，spring
• Java容器类包含：数组和集合容器：list ,Arraylist,Vector及map, hashTable, HashMap, HashSet

 32、怎么快速的把一个list集合中的元素去重？

https://blog.csdn.net/Mcdull__/article/details/118493866

33、二叉树，多叉树，B树，B+树，B*树，二叉搜索树，红黑树

索引是怎么实现的？为什么是B+树？为什么不用二叉树？为什么不用平衡二叉树?

二叉树的操作效率较高，但存在问题。

1. 二叉树需要加载到内存，如果二叉树的节点少，那没什么问题，但是如果二叉树的节点很多（1亿），就会出现问题。
2. 问题1：在构建二叉树时，需要多次进行I/O操作（海量数据存在数据库或者文件中），节点海量，构建二叉树时，速度有影响。
3. 问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度。

多叉树：在二叉树中，每个节点有数据项，最多有两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点，就是多叉树。多叉树通过重新组织节点，减少树的高度，能对二叉树进行优化。（2-3树，2-3-4树）

B树（B-tree/B-树）（就是多叉树的一种）：B树通过重新组织节点，降低了树的高度，广泛应用于文件系统和数据库系统中。

B即Balanced,平衡的意思。

特点：在叶子节点和非叶子节点都存放数据。

B树为什么要设置成多路？

答：为了进一步降低树的高度。但不能设计成无限多路，因为如果不限制路数，B树就退化成一个有序数组了，而文件系统和数据库索引都是存在硬盘上的，并且数据量大的话，不一定能一次性加载到内存中。

B树做文件系统的索引比较多，MongoDB数据库索引用B树实现，MySQL的Innodb 存储引擎用B+树存放索引。

B+树（B树的变体）（也是多一种多路搜索树）：

特点：（1）所有的数据（关键字）都放在叶子节点上。

          

B+树做数据库的索引比较多。

这是和业务场景相关的，数据库中select数据，不一定只选一条，很多时候会选多条，比如按照id排序后选10条。使用B树需要做局部的中序遍历，可能要跨层访问。而B+树由于所有数据都在叶子结点，不用跨层，同时由于有链表结构，只需要找到首尾，通过链表就能把所有数据取出来了。

面试题：B+树查询的时间和树的高度有关，大概是log(n),而使用hash存储索引，查询的平均时间是O(1),既然hash比B+树更快，为啥mysql还用b+树来存索引呢？

答：这和业务场景有关。如果只选一个数据，那确实是hash更快。但是数据库中经常会选择多条，这时候由于B+树索引有序，并且又有链表相连，它的查询效率比hash就快很多了。而且数据库中的索引一般是在磁盘上，数据量大的情况可能无法一次装入内存，B+树的设计可以允许数据分批加载，同时树的高度较低，提高查找效率。

B*树（B+树的变体）（在B+树的非根和非叶子结点再增加指向兄弟的指针）：

二叉搜索树、红黑树

https://blog.csdn.net/Mcdull__/article/details/118493781

34、ThreadLocal是什么？有哪些使用场景？

定义：ThreadLocal 类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程的变量。

作用：减少同一个线程内多个函数或组件之间公共变量传递的复杂度。

应用场景：ThreadLocal的应用场合，最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

特点：

 ThreadLocal和Synchronized的区别：

虽然ThreadLocal和Synchronized关键字都用于处理多线程并发访问变量的问题，不过两者处理问题的角度和思路不同

 内部结构：

• JDK 早期设计:每个ThreadLocal都创建一个Map, 然后用Thread(线程) 作为Map的key, 要存储的局部变量作为Map的value, 这样就能达到各个线程的局部变量隔离的效果, 这是最简单的设计方法。
• JDK8 优化设计(现在的设计)：每个Thread维护一个ThreadLocalMap, 这个Map的key是ThreadLocal实例本身,value才是真正要存储的值Object

如今设计的好处:

1. 每个Map存储的Entry数量变少
2. 当Thread销毁的时候, THreadLocalMap也会随之销毁, 减少内存的使用.(之前以Thread为key会导致ThreadLocalMap的生命周期很长)

 面试题：强弱引用和内存泄漏

(ThreadLocal) key是弱引用, 其目的就是将ThreadLocal对象的生命周期和和线程的生命周期解绑， 减少内存使用。

内存泄漏相关概念
内存溢出: Memory overflow 没有足够的内存提供申请者使用.
内存泄漏: Memory Leak 程序中已经动态分配的堆内存由于某种原因, 程序未释放或者无法释放, 造成系统内部的浪费, 导致程序运行速度减缓甚至系统崩溃等严重结果. 内存泄漏的堆积终将导致内存溢出。

面试题1：假设ThreadLocalMap中的key使用了强引用, 那么会出现内存泄漏吗?

 面试题2：假设ThreadLocalMap中的key使用了弱引用, 那么会出现内存泄漏吗?

面试题3： 内存泄漏的真实原因

 面试题4：那为什么key还要使用弱引用呢？

无论 ThreadLocalMap 中的 key 使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。

​ 要避免内存泄漏有两种方式：
​ 1 ．使用完 ThreadLocal ，调用其 remove 方法删除对应的 Entry
​ 2 ．使用完 ThreadLocal ，当前 Thread 也随之运行结束

相对第一种方式，第二种方式显然更不好控制，特别是使用线程池的时候，线程结束是不会销毁的．

​ 也就是说，只要记得在使用完ThreadLocal 及时的调用 remove ，无论 key 是强引用还是弱引用都不会有问题.

那么为什么 key 要用弱引用呢

 事实上，在 ThreadLocalMap 中的set/getEntry 方法中，会对 key 为 null （也即是 ThreadLocal 为 null ）进行判断，如果为 null 的话，那么是会对 value 置为 null 的．

这就意味着使用完 ThreadLocal , CurrentThread 依然运行的前提下．就算忘记调用 remove 方法，弱引用比强引用可以多一层保障：弱引用的 ThreadLocal 会被回收．对应value在下一次 ThreadLocaIMap 调用 set/get/remove 中的任一方法的时候会被清除，从而避免内存泄漏．（弱引用的特点：如果一个对象持有弱引用，那么下一次垃圾回收的时候必然会被清理掉。）

面试题：如何使用？

 1）存储用户Session

​ 2）解决线程安全的问题

ThreadLocal具体源码讲解：

https://csp1999.blog.csdn.net/article/details/116604283