java基础

准备书目：深入理解java虚拟机， JVM高级特性与最佳实践（周志明）

JVM结构原理、GC工作机制详解 （垃圾回收，内存分配）
答：具体参照：JVM结构、GC工作机制详解 ，
说到GC，记住两点：1、GC是负责回收所有无任何引用对象的内存空间。 注意:垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身，2、GC回收机制的两种算法，a、引用计数法 b、可达性分析算法（ 这里的可达性，大家可以看基础2 Java对象的什么周期），至于更详细的GC算法介绍，大家可以参考：Java GC机制算法

Java对象的生命周期
答：创建阶段 、 应用阶段 、不可见阶段 、不可达阶段 、收集阶段 、终结阶段、 对象空间重新分配阶段等等，
具体参照：Java 对象的生命周期

Map或者HashMap的存储原理
答：HashMap是由数组+链表的一个结构组成，具体参照：HashMap的实现原理
JUC基础 ConcurrentHashMap

Java Object类中有哪些方法？
答：Object有哪些方法
多线程加锁，notify，notifyAll的方法是属于Object

voilate
volatile变量只能保证可见性，但是不能保证运算原子性。

三、三大框架方面问题
1、Spring 事务的隔离性，并说说每个隔离性的区别
解答：Spring事务详解
2、Spring事务的传播行为，并说说每个传播行为的区别
解答：Spring事务详解
3、hibernate跟Mybatis/ ibatis 的区别，为什么选择？
解答：Hibernate与Mybatis的比较
4、Struts跟Spring mvc的优缺点，让你选会如何选
解答：Spring MVC 与 Struts的区别
5、简单说说Spring 事务机制
解答：Spring事务机制
6、Spring 4.0新特性
解答：Spring4新特性

八、Java底层基础题
1、SpringMVC的原理以及返回数据如何渲染到jsp/html上？
答：Spring MVC的核心就是 DispatcherServlet ， 一个请求经过 DispatcherServlet ，转发给HandlerMapping ,然后经反射，对应 Controller及其里面方法的@RequestMapping地址，最后经ModelAndView和ViewResoler返回给对应视图 。 具体可参考：Spring MVC的工作原理
2、一个类对象属性发生改变时，如何让调用者知道？
答：Java event时间监听 ，即在set方法改变属性时，触发 ，这种模式也可以理解为观察者模式，具体查看：观察者模式简单案例和说明
3、重写equals为何要重写hashCode？
答：判断两个对象是否相等，比较的就是其hashCode, 如果你重载了equals，比如说是基于对象的内容实现的，而保留hashCode的实现不变，那么很可能某两个对象明明是“相等”，而hashCode却不一样。 hashcode不一样，就无法认定两个对象相等了
4、谈谈你对JVM的理解？
答： Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。Java编译器只要面向JVM，生成JVM能理解的代码或字节码文件。Java源文件经编译成字节码程序，通过JVM将每一条指令翻译成不同平台机器码，通过特定平台运行。
JVM执行程序的过程 ：I.加载。class文件 ，II.管理并分配内存 ，III.执行垃圾收集

JRE（java运行时环境）由JVM构造的java程序的运行环境

具体详情：JVM原理和调优

6、Spring的原理
答：Spring的核心是IOC和AOP ，IOC是依赖注入和控制反转， 其注入方式可分为set注入、构造器注入、接口注入等等。IOC就是一个容器，负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。简单理解就是：JAVA每个业务逻辑处理至少需要两个或者以上的对象协作进行工作，但是每个对象在使用它的合作对象的时候，都需要频繁的new 对象来实现，你就会发现，对象间的耦合度高了。而IOC的思想是：Spring容器来管理这些，对象只需要处理本身业务关系就好了。至于什么是控制反转，就是获得依赖对象的方式反转了。
AOP呢，面向切面编程，最直接的体现就是Spring事物管理。至于Spring事物的相关资料，就不细说了，参考：Spring注解式事物管理
7、谈谈你对NIO的理解
答：IO是面向流，NIO是面向缓冲 ，这里不细讲了，具体参照：Java NIO和IO的区别
8、ArrayList和LinkedList、Vector的区别？
答：总得来说可以理解为：.
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据
Vector和ArrayList类似,但属于强同步类，即线程安全的，具体比较参照：比较ArrayList、LinkedList、Vector
9、随便说说几个单例模式，并选择一种线程安全的
答：单例的类别：懒汉、饿汉、枚举、静态内部类、双重校验锁 等等 ， 选择线程安全我选最后一种，双重校验锁。 具体实现方式参照：Java：单例模式的七种写法
10、谈谈红黑树
答：算法和数据结构一直是我薄弱之处，这方面说自己补吧，成效不大，这里我就推荐一个：红黑树
11、举例说说几个排序，并说明其排序原理
答：这里我就不细说了，大家自己看看 Java实现几种常见的排序算法
12、Mysql索引的原理
答：索引的作用大家都知道，就是加快查询速度，但是原理，我说不上来，这里直接看吧：Mysql索引工作原理
13、序列化的原理和作用
答：Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程，主要用于HTTP或者WebService接口传输过程中对象参数的传播，具体可参看：Java序列化机制和原理

十、手写代码题（包含sql题）
1、假设商户表A（id , city ） ,交易流水表B （aid, amount , time） 这里的time代表交易时间， 请用sql写出查询每个城市每个月的销售业绩（答案可在评论里回复）
2、假设有一个数组 A ，int[] A = { 1 , 3 , -1 ,0 , 2 , 1 , -4 , 2 , 0 ,1 … N}; 原来是需要查出大于0的数组，但是由于传参错误或者其他原因，导致查出0和负数了，现在要求在不使用新数组和新集合的情况下（即只使用这个A数组，因数组数据比较大，且只能用一次循环） 实现正数放到数组的前面，小于等于0的数放到数组的末尾（答案可在评论里回复）
十一、设计方案相关
面试还会问到一些关于设计方案相关的问题，比如
1、你的接口服务数据被人截包了，你如何防止数据恶意提交？
答：我们可以在接口传输参数里面设置一个业务编号，这个编号用来区分是否重复提交。这样即使数据被抓包了，对方也无法区分每个字段你的含义，这时，这个业务编号的作用就来了
2、假设服务器经常宕机，你从哪些方面去排查问题？
答：这个就留个各位看官补充了，可评论回复

集锦二：
一、Java基础

1. String类为什么是final的。

2. HashMap的源码，实现原理，底层结构。

3. 说说你知道的几个Java集合类：list、set、queue、map实现类咯。。。

4. 描述一下ArrayList和LinkedList各自实现和区别

5. Java中的队列都有哪些，有什么区别。

6. 反射中，Class.forName和classloader的区别

7. Java7、Java8的新特性(baidu问的,好BT)

8. Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高

9. Java内存泄露的问题调查定位：jmap，jstack的使用等等

10. string、stringbuilder、stringbuffer区别

11. hashtable和hashmap的区别
    13 .异常的结构，运行时异常和非运行时异常，各举个例子

12. String a= “abc” String b = “abc” String c = new String(“abc”) String d = “ab” + “c” .他们之间用 == 比较的结果

13. String 类的常用方法

14. Java 的引用类型有哪几种

15. 抽象类和接口的区别

16. java的基础类型和字节大小。

17. Hashtable,HashMap,ConcurrentHashMap 底层实现原理与线程安全问题（建议熟悉 jdk 源码，才能从容应答）

18. 如果不让你用Java Jdk提供的工具，你自己实现一个Map，你怎么做。说了好久，说了HashMap源代码，如果我做，就会借鉴HashMap的原理，说了一通HashMap实现

19. Hash冲突怎么办？哪些解决散列冲突的方法？

20. HashMap冲突很厉害，最差性能，你会怎么解决?从O（n）提升到log（n）咯，用二叉排序树的思路说了一通

21. rehash

22. hashCode() 与 equals() 生成算法、方法怎么重写
    二、Java IO

23. 讲讲IO里面的常见类，字节流、字符流、接口、实现类、方法阻塞。

24. 讲讲NIO。

25. String 编码UTF-8 和GBK的区别?

26. 什么时候使用字节流、什么时候使用字符流?

27. 递归读取文件夹下的文件，代码怎么实现
    三、Java Web

28. session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。

29. servlet的一些相关问题

30. webservice相关问题

31. jdbc连接，forname方式的步骤，怎么声明使用一个事务。举例并具体代码

32. 无框架下配置web.xml的主要配置内容

33. jsp和servlet的区别
    四、JVM

34. Java的内存模型以及GC算法

35. jvm性能调优都做了什么

36. 介绍JVM中7个区域，然后把每个区域可能造成内存的溢出的情况说明

37. 介绍GC 和GC Root不正常引用。

38. 自己从classload 加载方式，加载机制说开去，从程序运行时数据区，讲到内存分配，讲到String常量池，讲到JVM垃圾回收机制，算法，hotspot。反正就是各种扩展

39. jvm 如何分配直接内存， new 对象如何不分配在堆而是栈上，常量池解析

40. 数组多大放在 JVM 老年代（不只是设置 PretenureSizeThreshold ，问通常多大，没做过一问便知）

41. 老年代中数组的访问方式

42. GC 算法，永久代对象如何 GC ， GC 有环怎么处理

43. 谁会被 GC ，什么时候 GC

44. 如果想不被 GC 怎么办

45. 如果想在 GC 中生存 1 次怎么办
    五、开源框架

46. hibernate和ibatis的区别

47. 讲讲mybatis的连接池。

48. spring框架中需要引用哪些jar包，以及这些jar包的用途

49. springMVC的原理

50. springMVC注解的意思

51. spring中beanFactory和ApplicationContext的联系和区别

52. spring注入的几种方式（循环注入）

53. spring如何实现事物管理的

54. springIOC

55. spring AOP的原理

56. hibernate中的1级和2级缓存的使用方式以及区别原理（Lazy-Load的理解）

57. Hibernate的原理体系架构，五大核心接口，Hibernate对象的三种状态转换，事务管理。
    六、多线程

58. Java创建线程之后，直接调用start()方法和run()的区别

59. 常用的线程池模式以及不同线程池的使用场景

60. newFixedThreadPool此种线程池如果线程数达到最大值后会怎么办，底层原理。

61. 多线程之间通信的同步问题，synchronized锁的是对象，衍伸出和synchronized相关很多的具体问题，例如同一个类不同方法都有synchronized锁，一个对象是否可以同时访问。或者一个类的static构造方法加上synchronized之后的锁的影响。

62. 了解可重入锁的含义，以及ReentrantLock 和synchronized的区别

63. 同步的数据结构，例如concurrentHashMap的源码理解以及内部实现原理，为什么他是同步的且效率高

64. atomicinteger和Volatile等线程安全操作的关键字的理解和使用

65. 线程间通信，wait和notify

66. 定时线程的使用

67. 场景：在一个主线程中，要求有大量(很多很多)子线程执行完之后，主线程才执行完成。多种方式，考虑效率。

68. 进程和线程的区别

69. 什么叫线程安全？举例说明

70. 线程的几种状态

71. 并发、同步的接口或方法

72. HashMap 是否线程安全，为何不安全。 ConcurrentHashMap，线程安全，为何安全。底层实现是怎么样的。

73. J.U.C下的常见类的使用。 ThreadPool的深入考察； BlockingQueue的使用。（take，poll的区别，put，offer的区别）；原子类的实现。

74. 简单介绍下多线程的情况，从建立一个线程开始。然后怎么控制同步过程，多线程常用的方法和结构

75. volatile的理解

76. 实现多线程有几种方式，多线程同步怎么做，说说几个线程里常用的方法
    七、网络通信

77. http是无状态通信，http的请求方式有哪些，可以自己定义新的请求方式么。

78. socket通信，以及长连接，分包，连接异常断开的处理。

79. socket通信模型的使用，AIO和NIO。

80. socket框架netty的使用，以及NIO的实现原理，为什么是异步非阻塞。

81. 同步和异步，阻塞和非阻塞。

82. OSI七层模型，包括TCP,IP的一些基本知识

83. http中，get post的区别

84. 说说http,tcp,udp之间关系和区别。

85. 说说浏览器访问www.taobao.com，经历了怎样的过程。

86. HTTP协议、 HTTPS协议，SSL协议及完整交互过程；

87. tcp的拥塞，快回传，ip的报文丢弃

88. https处理的一个过程，对称加密和非对称加密

89. head各个特点和区别

90. 说说浏览器访问www.taobao.com，经历了怎样的过程。
    八、数据库MySql

91. MySql的存储引擎的不同

92. 单个索引、联合索引、主键索引

93. Mysql怎么分表，以及分表后如果想按条件分页查询怎么办(如果不是按分表字段来查询的话，几乎效率低下，无解)

94. 分表之后想让一个id多个表是自增的，效率实现

95. MySql的主从实时备份同步的配置，以及原理(从库读主库的binlog)，读写分离

96. 写SQL语句。。。

97. 索引的数据结构，B+树

98. 事务的四个特性，以及各自的特点（原子、隔离）等等，项目怎么解决这些问题

99. 数据库的锁：行锁，表锁；乐观锁，悲观锁

100. 数据库事务的几种粒度；

101. 关系型和非关系型数据库区别
     九、设计模式

102. 单例模式：饱汉、饿汉。以及饿汉中的延迟加载,双重检查

103. 工厂模式、装饰者模式、观察者模式。

104. 工厂方法模式的优点（低耦合、高内聚，开放封闭原则）
     十、算法

105. 使用随机算法产生一个数，要求把1-1000W之间这些数全部生成。（考察高效率，解决产生冲突的问题）

106. 两个有序数组的合并排序

107. 一个数组的倒序

108. 计算一个正整数的正平方根

109. 说白了就是常见的那些查找、排序算法以及各自的时间复杂度

110. 二叉树的遍历算法

111. DFS,BFS算法

112. 比较重要的数据结构，如链表，队列，栈的基本理解及大致实现。

113. 排序算法与时空复杂度（快排为什么不稳定，为什么你的项目还在用）

114. 逆波兰计算器

115. Hoffman 编码

116. 查找树与红黑树
     十一、并发与性能调优

117. 有个每秒钟5k个请求，查询手机号所属地的笔试题(记得不完整，没列出)，如何设计算法?请求再多，比如5w，如何设计整个系统?

118. 高并发情况下，我们系统是如何支撑大量的请求的

119. 集群如何同步会话状态

120. 负载均衡的原理
     5 .如果有一个特别大的访问量，到数据库上，怎么做优化（DB设计，DBIO，SQL优化，Java优化）

121. 如果出现大面积并发，在不增加服务器的基础上，如何解决服务器响应不及时问题“。

122. 假如你的项目出现性能瓶颈了，你觉得可能会是哪些方面，怎么解决问题。

123. 如何查找 造成 性能瓶颈出现的位置，是哪个位置照成性能瓶颈。

124. 你的项目中使用过缓存机制吗？有没用用户非本地缓存
     十二、其他
     1.常用的linux下的命令

125.  sleep()和wait()有什么区别?
     

答：Sleep() 是线程类的方法 wait()是object类的方法。Sleep（） 不会释放对象锁 到时自动恢复 ，wait（）会释放对象锁 进入等待此对象的等待锁定池 发出notify（）方法后 才进入等待锁定池准备对象锁的获取进入运行状态
2. 分析是否存在使i + 1 < i的数？
答：存在。如果i为int型，那么当i为int能表示的最大整数时，i+1就溢出变成负数了，此时就<i了。
3. 0.6332的数据类型
答：Double
4. Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式，请简述两种方法
答：面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。
5. Java接口的修饰符可以为？
答：final abstract
6. Math.round(11.5) 等于多少? Math.round(-11.5)等于多少?
答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。
7.公开的静态方法能被继承吗？能被改写吗？
答：能被继承，不能被改写。
8 .Java有没有goto?
答：Goto—java中的保留字，现在没有在java中使用.
9 .数组有没有length()这个方法? String有没有length()这个方法？
答：数组没有length()这个方法，有length的属性。
String有length()这个方法。
10. 用最有效率的方法算出2乘以8等於几?
答：2 << 3
中等类题目
11. GC线程是否为守护线程？
答：线程分为守护线程和非守护线程（即用户线程）。
只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
守护线程最典型的应用就是 GC (垃圾回收器)
13. 下面的方法，当输入为2的时候返回值是多少?（）

publicstaticint getValue(int i) {

int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
答：10
解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。
14. Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。
15. List, Set, Map是否继承自Collection接口?
答：List，Set是，Map不是，Map是键值对映射容器，与List和Set有明显的区别，而Set存储的零散的元素且不允许有重复元素（数学中的集合也是如此），List是线性结构的容器，适用于按数值索引访问元素的情形。
16. String 和StringBuilder、StringBuffer 的区别?
答：Java 平台提供了两种类型的字符串：String和StringBuffer / StringBuilder，它们可以储存和操作字符串。其中String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。而 StringBuffer和StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是JDK 1.5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方面都没有被synchronized修 饰，因此它的效率也比StringBuffer略高。
17. 不通过构造函数也能创建对象吗？Java创建对象的几种方式
答：是
Java创建对象的几种方式（重要）：
(1) 用new语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
(1)和(2)都会明确的显式的调用构造函数 ；(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函数。

18. 构造器Constructor是否可被override?
    答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading
    19． 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
    答：是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
    20． 类ExampleA 继承Exception，类ExampleB 继承ExampleA。
    有如下代码片断：
    try{
    throw new ExampleB(“b”)
    }catch（ExampleA e）{
    System.out.println(“ExampleA”);
    }catch（Exception e）{
    System.out.println(“Exception”);
    }
    请问执行此段代码的输出是什么？
    答：输出：ExampleA。（根据里氏代换原则[能使用父类型的地方一定能使用子类型]，抓取ExampleA类型异常的catch块能够抓住try块中抛出的ExampleB类型的异常）
    困难类题目

19. volatile关键字是否能保证线程安全？
    答：无法保证线程安全。volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对
    volatile的写操作，无法保证线程安全。例 如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1堆count进行修改之后，会write到主内存中，主内存中的 count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时用 volatile关键字修改之后，还是会存在并发的情况。

20. 简述什么是接口以及接口的特性
    答：（1）接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是公开(public)类型的,确保外部使用者能访问它们；
    （2）接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象(abstract)方法；
    （3）接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实例变量，只有静态（static）变量；
    （4）接口的中的变量是所有实现类共有的，既然共有，肯定是不变的东西，因为变化的东西也不能够算共有。所以变量是不可变(final)类型，也就是常量了。
    （5） 接口中不可以定义变量？如果接口可以定义变量，但是接口中的方法又都是抽象的，在接口中无法通过行为来修改属性。有的人会说了，没有关系，可以通过 实现接口的对象的行为来修改接口中的属性。这当然没有问题，但是考虑这样的情况。如果接口 A 中有一个public 访问权限的静态变量 a。按照 Java 的语义，我们可以不通过实现接口的对象来访问变量 a，通过 A.a = xxx; 就可以改变接口中的变量 a 的值了。正如抽象类中是可以这样做的，那么实现接口 A 的所有对象也都会自动拥有这一改变后的 a 的值了，也就是说一个地方改变了 a，所有这些对象中 a 的值也都跟着变了。这和抽象类有什么区别呢，怎么体现接口更高的抽象级别呢，怎么体现接口提供的统一的协议呢，那还要接口这种抽象来做什么呢？所以接口中 不能出现变量，如果有变量，就和接口提供的统一的抽象这种思想是抵触的。所以接口中的属性必然是常量，只能读不能改，这样才能为实现接口的对象提供一个统 一的属性。
    通俗的讲，你认为是要变化的东西，就放在你自己的实现中，不能放在接口中去，接口只是对一类事物的属性和行为更高层次的抽象。对修改关闭，对扩展（不同的实现 implements）开放，接口是对开闭原则的一种体现。

21. 请说出常见的排序算法都有哪些
    答：常用的排序算法有：插入、选择、冒泡
    快速、希尔、归并、堆

22. 下面程序的运行结果是什么（）

class HelloA {

public HelloA() {
System.out.println(“HelloA”);
}

{ System.out.println("I'm A class"); }

static { System.out.println(“static A”); }

}

publicclass HelloB extends HelloA {
public HelloB() {
System.out.println(“HelloB”);
}

{ System.out.println("I'm B class"); }

static { System.out.println(“static B”); }

publicstaticvoid main(String[] args) {
　　　　 new HelloB();
　　 }

}
答：atic A
static B
I’m A class
HelloA
I’m B class
HelloB
解析：考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。
对象的初始化顺序：（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；（2）当static语句执行完之后,再执行main方法；（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。
25. 说出ArrayList、Vector、LinkedList 的存储性能和特性？
答：ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元 素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized 方法（线程安全），通常性能上较ArrayList 差，而LinkedList 使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比， 其实对内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。Vector属于遗留 容器（早期的JDK中使用的容器，除此之外Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器）， 现在已经不推荐使用，但是由于ArrayList和LinkedListed都是非线程安全的，如果需要多个线程操作同一个容器，那么可以通过工具类 Collections中的synchronizedList方法将其转换成线程安全的容器后再使用（这其实是装潢模式最好的例子，将已有对象传入另一个 类的构造器中创建新的对象来增加新功能）。
26. List、Map、Set 三个接口，存取元素时，各有什么特点？
答：List以特定索引来存取元素，可有重复元素。Set不能存放重复元素（用对象的equals()方法来区分元素是否重复）。Map保存键值对 （key-value pair）映射，映射关系可以是一对一或多对一。Set和Map容器都有基于哈希存储和排序树的两种实现版本，基于哈希存储的版本理论存取时间复杂度为 O(1)，而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键（key）构成排序树从而达到排序和去重的效果。
27. TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？
答：TreeSet要求存放的对象所属的类必须实现Comparable接口，该接口提供了比较元素的compareTo()方法，当插入元素时会 回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections 工具类的sort方法有两种重载的形式，第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较；第二种不强制性的要 求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator接口的子类型（需要重写compare方法实现元素的比较），相当于一个 临时定义的排序规则，其实就是是通过接口注入比较元素大小的算法，也是对回调模式的应用。
28．什么是进程，什么是线程？为什么需要多线程编程？
答：进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位；线程是进程的一个实体，是CPU调 度和分派的基本单位，是比进程更小的能独立运行的基本单位。线程的划分尺度小于进程，这使得多线程程序的并发性高；进程在执行时通常拥有独立的内存单元， 而线程之间可以共享内存。使用多线程的编程通常能够带来更好的性能和用户体验，但是多线程的程序对于其他程序是不友好的，因为它占用了更多的CPU资源。
29. sleep()和yield()有什么区别?
答：sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；
sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常； sleep()方法比yield()方法（跟操作系统相关）具有更好的可移植性。
30. 什么情况用+做字符串连接比调用StringBuffer / StringBuilder对象的append方法性能更好？
答：串接后得到的字符串在静态存储区中是早已存在的，那么用+做字符串连接是优于 StringBuffer / StringBuilder的append方法的。

1. &和&&的区别
   答：&和&&都是逻辑运算符，都是判断两边同时真则为真，否则为假；但是&&当第一个条件不成立后，后面的条件都不执行了，而&则还是继续执行，直到整个条件语句执行完为止。
   2．八种基本数据类型? int存储的字节数是多少？
   答：int char short long Boolean double folat byte. 4
   3．String类可以被继承吗？
   答：不可以,因为String是final类故不能被继承
   4 .Integer a = new Integer (23+5); String b = “01”+a; b=__________
   答：0128
   5．String是基本数据类型吗?int 和Integer的区别是什么？
   答：不是，String是引用类型。
   int 是基本数据类型，Integer 是一个类，是int的扩展，定义了很多的转换方法。
   int 是基本类型，直接存数值，而integer是对象，用一个引用指向这个对象，
   因此在类进行初始化时int类的变量初始为0.而Integer的变量则初始化为null.
   6 . Java中Exception和Error有什么区别？
   答：Exception和Error都是Throwable的子类。Exception用于用户程序可以捕获的异常情况。Error定义了不期望被用户程序捕获的异常。

2. 多态的实现
   答：要有封装，要有继承，父类引用指向子类对象
   8.创建线程有几种不同的方式
   答：（1）继承Thread类（2）实现Runnable接口（3）应用程序可以使用Executor框架来创建线程池实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而Java不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。
   9．Java支持多继承么？
   答：不支持，Java不支持多继承。每个类都只能继承一个类，但是可以实现多个接口。
   10.collection a = new ArrayList(); 和 Arraylist a = new ArrayList()的区别
   答:第一种方法父类的引用指向了子类的对象,但是该对象a只能调用接口collection所声明的方法；
   第二种方法声明了arraylist对象,该对象还可以调用使用ArrayList类中特有的方法
   中等类题目
   11．什么是JDBC？
   答：JDBC是允许用户在不同数据库之间做选择的一个抽象层。JDBC允许开发者用JAVA写数据库应用程序，而不需要关心底层特定数据库的细节。
   12.什么是java序列化，如何实现java序列化？
   答：java序列化就是将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象，需要被序列化的类必须实现Serializable接口
   13.collection和collections的区别
   答：collection是集合类的上级接口,它的子类有set和list,collections是针对集合类的一个帮助类，它提供了一些静态方法实现对各种集合。、线程安全化的操作

3. 谈谈final, finally, finalize
   （1）final是全局变量声明的时候使用，意思是这个变量不可被修改，不可被override，一般用于声明常量，或者系统设置的值。
   （2）finally是在try-catch-finally块中配套使用，作用是，不管代码执行了try还是catch，最后一定会执行finally里面的代码。
   （3）inalize是召唤垃圾收集器的命令，使用后，系统就安排一次垃圾回收，
   但是不是立即执行，执行的时间点是无法确定的。没有特别的要求的话一般不需要使用finalize，交给gc自己管理就好。

4. abstract class和interface有什么区别
   答：
   （1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
   （2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
   （3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
   （4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"has-a"关系。
   （5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。
   （6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值。

5. HashSet和TreeSet有什么区别？
   HashSet是由一个hash表来实现的，因此，它的元素是无序的add()，remove()，contains()方法的时间复杂度是O(1)。
   TreeSet是由一个树形的结构来实现的，它里面的元素是有序的。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。

6. SQl查询，修改语句的写法。
   答：查询语法：SELECT column1, column2, columnN FROM table_name;
   修改语法：UPDATE table_nameSET column1 = value1, column2 = value2…columnN=valueN
   [ WHERE CONDITION ];

public static void main(String[] args){
int i=0;
int j=10;
do{
if(i++>–j){
continue;
}
}while(i<5);
System.out.println(“i=”+i+" and "+“j=”+j);这段代码输出结果：

答：i=5 and j=5

19. public、protected、private、默认的作用域；
    答：
    private ：本类访问；
    default ：表示默认，不仅本类访问，而且是同包可见。
    Protected：同包可见+不同包的子类可见
    Public ：表示所有的地方均可见。
20. 概括的解释下线程的几种可用状态。
    答：线程在执行过程中，可以处于下面几种状态：
    就绪(Runnable):线程准备运行，不一定立马就能开始执行。
    运行中(Running)：进程正在执行线程的代码。
    等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
    睡眠中(Sleeping)：线程被强制睡眠。
    I/O阻塞(Blocked on I/O)：等待I/O操作完成。
    同步阻塞(Blocked on Synchronization)：等待获取锁。
    死亡(Dead)：线程完成了执行。
    困难类题目
    21.字节流与字符流的区别
    答：计算机中的一切最终都是二进制的字节形式存在，字节流要把二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取二进制数据；会用到抽象类为OutputStream和InputStream，它们是对字节进行操作；
    字符流输出时是先要得到字符对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符；会用到字节流的包装类，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备。
    22.同步和异步的区别,举例说明
    答：同步：如果数据需要在线程间被共享；例如:A线程正在对数据进行占有,而程序需要保证其它线程无获得数据的操作权的可能性，则必须进行同步存取。
    异步：当对象调用了一个需要花费长时间来执行的方法，并且不希望让程序等待此方法的返回结果,就需要使用异步操作
    23.HashMap和Hashtable的区别
    答： hashmap是线程不安全的,允许null key和null value,效率高于HashTable,方法不是Synchronize的要提供外同步
    HashTable是线程安全的，不允许null key和null value,效率低于hashmap方法是Synchronize的要提供外同步
    24 .Array和ArrayList有何区别？什么时候更适合用Array？
    答：Array可以容纳基本类型和对象，而ArrayList只能容纳对象。
    Array是指定大小的，而ArrayList大小是固定的。
    Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。尽管ArrayList明显是更好的选择，但也有些时候Array比较好用。
    （1）如果列表的大小已经指定，大部分情况下是存储和遍历它们。
    （2）对于遍历基本数据类型，尽管Collections使用自动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得很慢。
    （3）如果你要使用多维数组，使用[][]比List<List<>>更容易。
21. Iterator和ListIterator的区别是什么？
    答：他们的区别：
    （1）Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。
    （2）Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。
    （3）ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引。
22. hashCode()和equals()方法的重要性体现在什么地方？
    答：Java中的HashMap使用hashCode()和equals()方法来确定键值对的索引，当根据键获取值的时候也会用到这两个方法。如果没 有正确的实现这两个方法，两个不同的键可能会有相同的hash值，因此，可能会被集合认为是相等的。而且，这两个方法也用来发现重复元素。所以这两个方法 的实现对HashMap的精确性和正确性是至关重要的。
    27．finalize()方法什么时候被调用？
    答:在释放对象占用的内存之前，垃圾收集器会调用对象的finalize()方法。一般建议在该方法中释放对象持有的资源。
    28.如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？
    答：不会，在下一个垃圾回收周期中，这个对象将是可被回收的。
23. 数据库连接池是什么意思？
    答：像打开关闭数据库连接这种和数据库的交互可能是很费时的，尤其是当客户端数量增加的时候，会消耗大量的资源，成本是非常高的。可以在应用服务器启动 的时候建立很多个数据库连接并维护在一个池中。连接请求由池中的连接提供。在连接使用完毕以后，把连接归还到池中，以用于满足将来更多的请求。
    30能否使用任何类作为Map的key？
    答：我们可以使用任何类作为Map的key，然而在使用它们之前，需要考虑以下几点：
    （1）如果类重写了equals()方法，它也应该重写hashCode()方法。
    （2）类的所有实例需要遵循与equals()和hashCode()相关的规则。请参考之前提到的这些规则。
    （3）如果一个类没有使用equals()，你不应该在hashCode()中使用它。
    （4）用户自定义key类的最佳实践是使之为不可变的，这样，hashCode()值可以被缓存起来，拥有更好的性能。不可变的类也可以确保hashCode()和equals()在未来不会改变，这样就会解决与可变相关的问题了。