java面试题

总结的一些java面试题，后续会继续更新

1.重写与重载的区别？

答：
1.重载发生在单类当中，重写是发生在父类子类之间
2.如果一个类中多个方法名相同，参数个数，数据类型不同则称之为重载（重载可以改变返回值类型）
3.如果子类中的方法名、参数类型与父类中相同则称之为重写

2.接口与抽象类的区别？

答：
1.接口与抽象类不可以实例化。

2.接口只能被实现，抽象类只能被继承。

3.接口不能有方法体，抽象类可以有方法体。

4.接口的关键字是interface，抽象类的关键字是abstract。

5.接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量

3.list、Map、Set的特点？

答：
1.list有索引，有序，数据可以重复

2.set没有索引，无序，数据不可以重复

3.map是键值对的存值方式，Map集合中的键不允许重复，值可以重复

4.map的数据结构？

答：数组每个元素都是个单向链表

5.什么是单例模式？

答：使一个类有且只有一个实例

6.单例模式有哪些类型？

答：饿汉式、懒汉式

7.单例模式的写法逻辑

答：
1.创建本类私有化静态final类对象

2.私有化构造方法

3.创建静态方法创建好的类对象返回出去

8.单例模式的代码？

答：

//饿汉式单例模式
public class Singleton {
    private final static Singleton INSTANCE = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

9.线程的实现方式？

答：
1.继承Thread类创建

2.实现Runnable接口创建

10.如何启动线程？

答：通过start方法对线程进行启动

11.HashTable和HashMap区别？

答：相同点：底层都是数组+链表实现，都是双列集合

​ 主要区别在于：

​ 1.HashMap由于非线程安全，效率上可能高于Hashtable。
​ 2.HashMap允许key或者value为null，而Hashtable不允许。

​ 3.HashMap是线程不同步的，Hashtable是线程同步的。

12.说出ArrayList,Vector, LinkedList的区别？

答：
1.Vector、ArrayList底层都是都是用数组实现的，LinkedList则是双向链表。

2.Vector线程同步，ArrayList、LinkedList线程不同步。

3.Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差

4.LinkedList适合指定位置插入、删除操作，不适合查找；ArrayList、Vector适合查找，不适合指定位置的插入、删除操作。
PS：
1.ArrayList 是用数组来实现，LinkedList是用链表实现的；数组和链表的最大区别就是数组是可以随机访问的，这个特点造成了在数组里可以通过下标拿到任何位置的数，而链表则做不到，只能从头开始逐个遍历。也就是说在「改查」这两个功能上，因为数组能够随机访问，所以 ArrayList 的效率高。
2.在数组中，当要增删元素时，在尾部还好，但是在其他地方增删就会导致后续元素都要移动，所以效率较低；而链表则可以轻松的断开和下一个元素的连接，直接插入新元素或者移除旧元素。但是如果是在尾部操作，数据量大时 ArrayList 会更快的。
所以说：
改查选择 ArrayList；
增删在尾部的选择 ArrayList；
其他情况下，在考虑用LinkedList
3.而Vector用了太多 synchronized，但是线程安全的成本就是效率低，不怎么适合用了，我们可以在代码上增加线程安全。

13.string stringbuffer StringBuilder 有什么区别

答：
1.String是不可改变的对象，对字符串的修改操作都会新的对象。（经常改变内容的字符串最好不要用 String ，所谓不可变意思就是对String的内容改变都会引发新的String对象的生成，会对系统性能造成影响）

2.StringBuffer与StringBuilder，他们是可改变的对象，对字符串的修改操作不会生成新的对象。

3.字符串的主要操作还是String，StringBuffer与StringBuilder主要还是用来拼接字符串的。

4.StringBuffer是线程安全的,StringBuilder是线程非安全的

使用场景：
1.如果要操作少量的数据用 = String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

14.int 和 Integer 有什么区别？

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

15.java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

答：
1.字节流，字符流。

2.字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter

16.怎么遍历HashMap集合？

答：首先要通过keySet()方法得到键的集合，再得到键集合的迭代器，进行迭代，通过get(key)得到值

17.Collection与Collections区别？

答：Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
​ Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

18.什么叫工厂模式？

答：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

19.访问修饰符有哪些？分别的作用？

答：
public ：能被所有的类(接口、成员)访问。
protected：只能被本类、同一个包中的类访问；如果在其他包中被访问，则必须是该成员所属类的子类。
private：成员变量和方法都只能在定义它的类中被访问，其他类都访问不到。对成员变量的进行获取和更改，一般用get()，set() ，public 方法。实现了Java面向对象的封装思想。
缺省：访问权限与protected相似，但修饰类成员时不同包中的子类不能访问。

20.servlet的生命周期阶段？ servlet执行流程？

答：
servlet的生命周期阶段？
1.init()方法：服务器初始化Servlet。
2.service()方法：初始化完毕，Servlet对象根据请求来选择doGet \ doPost。
3.destroy()方法：调用该方法消灭Servlet对象。

servlet执行流程？
1.Web容器加载对应的Servlet类,加载后进行init()初始化。
2. 接收到请求，容器根据配置将请求交给对应的Servlet，同时创建HttpServletRequest 和 HttpServletResponse 对象，一并交给Servlet。
3. 在service()中根据HttpServletRequest得请求类型等信息，调用doGet\doPost 进行业务处理。
4. 处理后通过HttpServletResponse获得相应信息，返回给Web容器。
5. Web容器再将响应返回给客户端。

21.jsp有哪些内置对象?作用分别是什么?

答：
JSP共有以下9种基本内置组件：
1.request对象
客户端请求信息，其中包括http头信息、cookie、请求参数信息等。
2.response对象
服务端响应客户端请求，返回信息
3.page对象
JSP页面本身
4.pageContext对象
管理网页属性，为jsp页面包装页面的上下文
5.session对象
客户端和服务端的会话
6.out对象
用于向客户端输出数据
7.application对象
用于获取服务端应用生命周期的信息。
8.config对象
初始化时，jsp引擎向jsp页面传递的信息
9.exception对象
页面发生异常，产生的异常对象

22.转发和重定向的区别？

答：
1.请求转发(redirect)只发送一次请求。重定向(forward)会发送两次请求 2.请求转换是服务器内部跳转，所有地址栏上的路径不会改变,重定向是浏览器在次发送请求，地址栏上的路径会发生改变. 3.请求转发，可以共享reqeust,重定向每一次都是一个新的request。

23.有哪几种事务隔离级别，他们都什么区别？

答：
RACLE中有两种事务 只读事务与读写事务。
1.隔离级别为读未提交
2.读已提交
3.可重复读
4.串行读

24.数据库事务的特性？

答:原子性、一致性、隔离性、持久性

25.sql优化？

答：
1.查询语句中不要使用 *，具体到字段
2.应尽量避免全表扫描，考虑在 where 及 order by 涉及的列上添加索引
3.避免索引失效的情况，比如不使用对字段进行 null 值判断，不使用‘!=’，‘or’，在LIKE以通配符%和_开头作查询时，不要在列上进行运算
4.尽量减少子查询，使用关联查询（left join,right join,inner join）替代
5.少使用IN或者NOT IN ,使用exists，not exists或者关联查询语句替代

26.spring的特点？

答：
一、IOC
控制反转与依赖注入
1、控制反转
把对象的创建交给外部的容器，程序中只需要接收获取对象即可，不需要关注对象由谁创建创建的细节。降低类与类之间的耦合度
2、依赖注入
通过spring核心配置文件将被调用的对象注入到调用中
二、AOP ：面向切面
将与核心业务无关的服务型功能（日志、事务）模块化，做成一个切面，再植入到核心业务中去，
减少耦合度，程序员可以只关心核心业务

• Spring怎么使用AOP 做日志 有两种方式，注解方式和xml方式 实现方式为
  • 1.做一个日志切面类
  • 2.做一个切入点
  • 3.把日志植入到目标对象中 aop的通知类型： 前置、后置、异常、最终、环绕通知 扩展： 1.创建对象的注解
    创建对象的注解有下面四个：
    @Component： 创建对象，加入ioc容器。举例：工具类

@Controller： 同@Component 一般用于表现层的注解。
@Service： 同@Component 一般用于业务层的注解。
@Repository： 同@Component 一般用于持久层的注解。

27.使用Spring框架的好处？

答：
轻量：Spring 是轻量的，基本的版本大约2MB。
控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
容器：Spring 包含并管理应用中对象的生命周期和配置。
MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。

28.Spring的事务管理？

答：
事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。 这样可以防止出现脏数据，防止数据库数据出现问题。 开发中为了避免这种情况一般都会进行事务管理。Spring中也有自己的事务管理机制，一般是使用TransactionMananger进行管理，可以通过Spring的注入来完成此功能

29.什么是MVC模式？

答：M数据持久层 V视图层 C控制层

30.hibernate的特点？

答：
1、轻量级的框架
2、是持久层框架
3、内置简单的sql语句
4、是实体类与数据库表字段的关系型映射
5、移植性强
6、全自动

31.mybatis的特点？

答：
1、手动编写sql语句
2、动态实现sql
3、是实体类与sql语句的关系映射
4、也是持久层框架
5、半自动

32.mybatis与hibernate的区别？

答：
特点即区别，其次使用选择方面
1、数据库表数量较多，需要批量处理 推荐使用mybatis框架
2、数据库表结构复杂，推荐使用mybatis框架
3、人员方面不是经常使用hibernate的情况下，使用mybatis框架简单易学

33.SpringMVC的原理（流程）？

答：
第一步:用户发起请求到前端控制器（DispatcherServlet）
第二步：前端控制器请求处理器映射器（HandlerMappering）去查找处理器（Handle）：通过xml配置或者注解进行查找
第三步：找到以后，处理器映射器（HandlerMappering）向前端控制器返回执行链（HandlerExecutionChain）
第四步：前端控制器（DispatcherServlet）调用处理器适配器（HandlerAdapter）去执行处理器（Handler）
第五步：处理器适配器去执行Handler
第六步：Handler执行完给处理器适配器返回ModelAndView
第七步：处理器适配器向前端控制器返回ModelAndView
第八步：前端控制器请求视图解析器（ViewResolver）去进行视图解析
第九步：视图解析器向前端控制器返回View
第十步：前端控制器对视图进行渲染
第十一步：前端控制器向用户响应结果

34.悲观锁和乐观锁的区别？

答：
悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现
乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新数据的时候需要判断该数据是否被别人修改过。如果数据被其他线程修改，则不进行数据更新，如果数据没有被其他线程修改，则进行数据更新。由于数据没有进行加锁，期间该数据可以被其他线程进行读写操作。

35.Mybatis中#与$的区别？

答：
1 #是把传入的数据当作字符串，如#field#传入的是id,则生成sql语句:order by “id”;
2 $传入的数据直接生成在sql里，如#field#传入的是id,则sql语句生成是这样，order by id ;
3 #方式能够很大程度防止sql注入, 但 $方式无法防止sql注入;
场景：
1.${} 比较特殊， 他的应用场景是需要动态传入表名或列名时使用， 如果使用#{}， 解析出来后是一个带着双引号的字符串，数据库找不到这样的列名。

36.spring与struts的区别？

答：
struts是类级别的拦截，spring是方法级别的拦截
SpringMVC的方法之间基本上独立的，独享request response数据,而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码 读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。
SpringMVC的入口是servlet，而Struts2是filter
SpringMVC开发效率和性能高于Struts2

37.什么是线程安全？

答：
当多个线程访问某个方法时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类时线程安全的。

38.wait方法和sleep方法的区别？

答：
相同点：两个方法都使程序进入一个暂停的状态
不同点：
1.wait是Object类中定义的方法，sleep是Thread类的方法。
2.wait方法会放弃持有的对象锁，进入等待队列，当该对象调用notify/notifyAll方法后才能去获取对象锁，进入运行状态。否则该线程永远处于挂起状态。
sleep方法会暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态，在调用sleep()方法的过程中，线程不会释放对象锁。
3.在过程中，wait方法会释放对象锁，而sleep方法，不会释放对象锁。

39.介绍下垃圾收集机制？

答：
java中的垃圾回收机制(Garbage Collection, GC)使得我们程序员写程序时不用去关心内存动态分配和垃圾回收的问题，这一切工作都由JVM来处理。

40.sql的执行顺序？

答：
where—>group by ----->having----->order by

41.Spring用了哪些设计模式？

答：
1.工厂模式，这个很明显，在各种BeanFactory以及ApplicationContext创建中都用到了；
2.模版模式，这个也很明显，在各种BeanFactory以及ApplicationContext实现中也都用到了；
3.代理模式，在Aop实现中用到了JDK的动态代理；
4.单例模式，这个比如在创建bean的时候。
5.Tomcat中有很多场景都使用到了外观模式，因为Tomcat中有很多不同的组件，每个组件需要相互通信，但又不能将自己内部数据过多地暴露给其他组件。用外观模式隔离数据是个很好的方法。
6.策略模式在Java中的应用，这个太明显了，因为Comparator这个接口简直就是为策略模式而生的。Comparable和Comparator的区别一文中，详细讲了Comparator的使用。比方说Collections里面有一个sort方法，因为集合里面的元素有可能是复合对象，复合对象并不像基本数据类型，可以根据大小排序，复合对象怎么排序呢？基于这个问题考虑，Java要求如果定义的复合对象要有排序的功能，就自行实现Comparable接口或Comparator接口.
7.原型模式：使用原型模式创建对象比直接new一个对象在性能上好得多，因为Object类的clone()方法是一个native方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。
8.迭代器模式：Iterable接口和Iterator接口 这两个都是迭代相关的接口，可以这么认为，实现了Iterable接口，则表示某个对象是可被迭代的；Iterator接口相当于是一个迭代器，实现了Iterator接口，等于具体定义了这个可被迭代的对象时如何进行迭代的

42.cookie与session的区别？

答：
1、cookie数据存放在客户的浏览器上，session数据放在服务器上。
2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗考虑到安全应当使用session。　
3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能考虑到减轻服务器性能方面，应当使用COOKIE。
4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

43. ==和equals的区别？

答：
1）对于“==”， 如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；如果作用于引用类型的变量，则比较的是所指向的对象的地址；

2）对于equals方法，不能作用于基本数据类型的变量，如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；但String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

44. 索引

答：
索引就一种特殊的查询表，数据库的搜索可以利用它加速对数据的检索。它很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。索引可以是唯一的，创建索引允许指定单个列或者是多个列。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。

45. 数据库三范式是什么？

答：
第一范式：列不可再分。
第二范式：行可以唯一区分，主键约束。
第三范式：表的非主属性不能依赖与其他表的非主属性，外键约束。
且三大范式是一级一级依赖的，第二范式建立在第一范式上，第三范式建立第一第二范式。

46. 什么是内联接、左外联接、右外联接？

答：
内联接（Inner Join）：匹配2张表中相关联的记录。
左外联接（Left Outer Join）：除了匹配2张表中相关联的记录外，还会匹配左表中剩余的记录，右表中未匹配到的字段用NULL表示。
右外联接（Right Outer Join）：除了匹配2张表中相关联的记录外，还会匹配右表中剩余的记录，左表中未匹配到的字段用NULL表示。
在判定左表和右表时，要根据表名出现在Outer Join的左右位置关系

47. spring如何统一处理异常？

答：
使用 @ ExceptionHandler 注解
实现 HandlerExceptionResolver 接口
使用 @ControllerAdvice+ @ ExceptionHandler 注解

48. 多态怎么理解？

答：
多态可以理解为一个对象有多种形态,也就是一个动物有多种的表现形式,其中,狗,猪,猫,等都是它的表现形式,这就是多态；重载也是它的表现形式； 还比如说一个相同函数名的函数提供了几种参数列表也可以说体现了不同的表现形式,也是多态；eg:public void f();和public void f(int a);

49. 反射怎么理解？

答：
反射就是在程序的运行过程中允许对程序本身进行操作，比如获取类本身，类的所有成员变量和方法，类的对象，还可以在运行过程中动态的创建类的实例，通过实例来调用类的方法，这就是反射机制一个比较重要的功能了。简单来说，反射就是创建对象，调用方法，给成员变量赋值和取值的另一种方式； 反射可以通过三种方法获取类对象，
1.类名.class()

2.对象名.getClass()

3.Class.forName(具体的类名)
其中，class.forName这个方法是我们在框架中的平常用的； 比如我们在Spring中Bean的注入，bean总是先声明class路径，然后依次生成就可以了；数据库切换 反射的好处：解耦
PS：反射就是动态执行某个类到class文件中，不需要重新编译；

50. 动态代理怎么理解？

答：
动态代理：动态代理就是在不修改原业务的基础上，基于原业务方法，进行重新的扩展，实现新的业务。 动态代理的原理：首先通过newProxyInstance方法获取代理类实例，而后我们便可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类（调用处理器）的invoke方法，在invoke方法中我们调用委托类的相应方法，并且可以添加自己的处理逻辑。

51. 线程和进程的区别？

答：
1.进程是资源分配的最小单位，线程是程序执行的最小单位;
2.同一个进程中可以包括多个线程，并且线程共享整个进程的资源，一个进行至少包括一个线程。

52. 拦截器(spring)和过滤器(jdk自带的)的区别？

答：
1.拦截器基于Java反射机制，过滤器基于函数回调 2.拦截器不依赖Servlet容器 ，过滤器依赖Servlet容器 3.拦截器只能对action（controller控制层）起作用，过滤器几乎对所有请求起作用

53. 冒泡排序的代码？

答：

将序列中所有元素两两比较，将最大的放在最后面。
将剩余序列中所有元素两两比较，将最大的放在最后面。
public void bubbleSort(int[] a){
        int length=a.length;
        int temp;
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a.length-i-1;j++){
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }

54. String面试题1？

答：
1.String的判断
String s1 = “abc”;
String s2 = “abc”;
String s3= new String(“abc”);
System.out.println(s1 == s2); // true
System.out.println(s1==s3)); //false
System.out.println(s1.equals(s3)); //true 2.判断String对象的创建
1）String str2 = new String(“abc”);
如果abc 字符串之前没有用过，就创建了两个对象，一个是new String创建的一个新的对象，一个是常量“abc”对象的内容创建出的一个新的String对象 2）String str1 = “abc”;
String str2 = new String(“abc”);
如果有使用相同的字符串值，则继续指向同一个字符串值，所以String str2 = new String(“abc”); 此时就创建一个对象，而abc 则是从字符串常量缓冲区中取出来的。 总结：String str = new String(“abc”); 首先要看常量池里是否有“abc”这个字符串，如果有，则创建一个，如果没有，则创建两个。

55. String面试题2？

答：
代码片段1：
String str1 = “ab”;
String str2 = “ab”;
//str1 == str2 为true
代码片段2：
String str3 = new String(“ab”);
String str4 = new String(“ab”);
//str3==str4 为false
代码片段3：
String str5 = “ab”+“cd”;
结论：
代码片段1：
String str1 = “ab”;在字符串常量池创建一个对象"ab"，后面str2时直接引用该对象，不用再创建，共创建一个对象

代码片段2：
先在字符串常量池创建一个对象"ab",然后在堆空间创建两个对象，使str3和str4分别指向它们，共创建3个对象

代码片段3:
在字符串常量区创建1个对象，由于常量的值在编译时已经确定了，所以等价于String str5 = “abcd”;，所以只创建一个对象，并保存在字符串池中；

56. 简单说一说drop、delete与truncate的区别？

答：
SQL中的drop,delete,truncate都表示删除，但是三者有一些差别：
1.delete用来删除表的全部或者一部分数据行，执行delete之后，（操作会记录在日志中）用户需要提交(commmit)或者回滚(rollback)来执行删除或者撤销删除， delete命令会触发这个表上所有的delete触发器；
2.truncate删除表中的所有数据，这个操作不能回滚，也不会触发这个表上的触发器；
3.drop命令从数据库中删除表，所有的数据行，索引和权限也会被删除，触发器也不会被触发，这个命令也不能回滚。
总结:在不再需要一张表的时候，用drop；在想删除部分数据行时候，用delete；在保留表而删除所有数据的时候用truncate。

57.Java中List集合去除重复数据的方法？

答：
1.通过HashSet踢除重复元素

 /**
     * 功能描述: 通过HashSet踢除重复元素
     */
    public static List removeDuplicate2(List list){
        HashSet set = new HashSet(list);
        list.clear();
        list.addAll(set);
        return list;
    }

总结：
此种方式是利用了Set的特性：元素不可重复，其底层原理是先计算每个对象的hash值，再比较元素值是否相同，如果相同，则保留最新的。

2.把list里的对象遍历一遍，用list.contain()，如果不存在就放入到另外一个list集合中

/**
     * 功能描述:.把list里的对象遍历一遍，用list.contain()，如果不存在就放入到另外一个list集合中
     *
     * @param:  有重复数据的List
     * @return: 数据不重复的List
     * @auther: 
     */
    public static List removeDuplicate(List list){
        ArrayList newList = new ArrayList();
        for(int i=0;i<list.size();i++){
            if(!newList.contains(list.get(i))){
                newList.add(list.get(i));
            }
        }
        return newList;
    }

58.finally与return

答：
（1）在try中没有异常的情况下try、catch、finally的执行顺序 try — finally

（2）如果try中有异常，执行顺序是try — catch — finally

（3）如果try中没有异常并且try中有return这时候正常执行顺序是try ---- finally — return

（4）如果try中有异常并且try中有return这时候正常执行顺序是try----catch—finally— return

（5）总之 finally 永远执行！

59.final和static

1.final
final特点：
1.final类不能被继承，没有子类，final类中的方法默认是final的。
2.final方法不能被子类的方法覆盖，但可以被继承。
3.final成员变量表示常量，必须在声明时给定初始值或者在构造方法内设置初始值，只能被赋值一次，赋值后值不再改变。
4.final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
2.static
static的特点：
1.static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以用类名.静态属性/方法名访问
2.static修饰的代码块表示静态代码块，运行时会执行该代码块，只会执行一次
3.static修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，只会被创建一次
4.static修饰的变量可以重新赋值
5.static方法中不能用this和super关键字
6.static方法不能重写

static和final一块用表示什么？
1.static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
2. 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
3.对于方法，表示不可覆盖，并且可以通过类名直接访问。

60.二分法算法

采用二分法查找时，数据需是有序不重复的。 
基本思想：假设数据是按升序排序的，对于给定值 x，
从序列的中间位置开始比较，如果当前位置值等于 x，
则查找成功；
若 x 小于当前位置值，则在数列的前半段中查找；
若 x 大于当前位置值则在数列的后半段中继续查找，
直到找到为止。

假设有一个数组 { 12, 23, 34, 45, 56, 67, 77, 89, 90 }，
现要求采用二分法找出指定的数值并将其在数组的索引返回，
如果没有找到则返回 -1。
代码如下


public class DichotomySearch {
   public static void main(String[] args) {
       int[] arr = new int[] { 12, 23, 34, 45, 56, 67, 77, 89, 90 };
       System.out.println(search(arr, 12));
       System.out.println(search(arr, 45));
       System.out.println(search(arr, 67));
       System.out.println(search(arr, 89));
       System.out.println(search(arr, 99));
   }

   public static int search(int[] arr, int key) {
       int start = 0;
       int end = arr.length - 1;
       while (start <= end) {
           int middle = (start + end) / 2;
           if (key < arr[middle]) {
               end = middle - 1;
           } else if (key > arr[middle]) {
               start = middle + 1;
           } else {
               return middle;
           }
       }
       return -1;
   }
}

61.多态存在的三个条件

1.有继承关系
2.子类重写父类的方法
3.父类的引用变量指向子类对象