java 基础面试题

JAVA 基础

1. JAVA 中的几种基本数据类型是什么，各自占用多少字节。

 

数据类型	关键字	内置类	内存占用字节数
布尔型	boolean	Boolean	1字节
字符型	char	Character	2字节
字节型	byte	Byte	1字节
短整型	short	Short	2字节
整形	int	Integer	4字节
长整型	long	Long	8字节
单精度型	float	Float	4字节
双精度型	double	Double	8

 

2. String 类能被继承吗，为什么。

 

3. String，Stringbuffer，StringBuilder的区别。

 

4. ArrayList 和 LinkedList 有什么区别。

 

5. 讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，当 new 的时候，他们的执行顺序。

 

6. 用过哪些 Map 类，都有什么区别，HashMap 是线程安全的吗,并发下使用的 Map 是什么，他们内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。

 

1. 当 HashMap 中的元素个数超过数组大小 loadFactor时，就会进行数组扩容，loadFactor的默认值为 0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为 16，那么当 HashMap 中元素个数超过 16*0.75=12 的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知 HashMap 中元素的个数，那么预设元素的个数能够有效的提高 HashMap 的性能。  
2.    
3. HashMap 的性能参数  
4. HashMap 包含如下几个构造器：  
5.    
6. HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。  
7. HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap  
8.    
9. ConcurrentHashMap适用于读者数量超过写者时，当写者数量大于等于读者时，CHM的性能是低于Hashtable和synchronized Map的。这是因为当锁住了整个Map时，读操作要等待对同一部分执行写操作的线程结束。CHM适用于做cache,在程序启动时初始化，之后可以被多个请求线程访问。正如Javadoc说明的那样，CHM是HashTable一个很好的替代，但要记住，CHM的比HashTable的同步性稍弱  
10.    
11. ArrayList：默认长度是10  一次扩容50%  
12. 默认长度是10  一次扩容50%  

 

7. JAVA8 的 ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计，你如何设计。

 

[plain] view plain copy

1. 从Java 8开始，HashMap，ConcurrentHashMap和LinkedHashMap在处理频繁冲突时将使用平衡树来代替链表，  
2. 当同一hash桶中的元素数量超过特定的值便会由链表切换到平衡树，这会将get()方法的性能从O(n)提高到O(logn)。  

8. 有没有有顺序的Map 实现类，如果有，他们是怎么保证有序的。

 

 

9. 抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口么。

 

10. 继承和聚合的区别在哪。

 

[plain] view plain copy

1. 一、聚合  
2. 为了能够使用一条命令就能构建 account-email和 account-persist两个模块，我们需要建立一个额外的名为 account-aggregator的模块，然后通过该模块构建整个项目的所有模块。 account-aggregator本身也是个 Maven项目，它的 POM如下  
3. Xml代码  收藏代码  
4.    
5.     <project>    
6.         <modelVersion>4.0.0</modelVersion>    
7.         <groupId>com.juvenxu.mvnbook.account</groupId>    
8.         <artifactId>account-aggregator</artifactId>    
9.         <version>1.0.0-SNAPSHOT</version>    
10.         <packaging> pom </packaging>    
11.         <name>Account Aggregator</name>    
12.          <modules>    
13.             <module>account-email</module>    
14.             <module>account-persist</module>    
15.          </modules>    
16.     </project>    
17.    
18.  注意：packaging的类型为pom ，module的值是一个以当前POM为主目录的相对路径。  
19.    
20. 二、继承  
21.    
22. 可声明父POM供子 POM继承  
23.    
24. 父模块POM如下：  
25.    
26.    
27. Xml代码     
28.     <project>    
29.         <modelVersion>4.0.0</modelVersion>    
30.         <groupId>com.juvenxu.mvnbook.account</groupId>    
31.         <artifactId> account-parent </artifactId>    
32.         <version>1.0.0-SNAPSHOT</version>    
33.         <packaging>pom</packaging>    
34.         <name>Account Parent</name>    
35.     </project>    
36.    
37.  子模块声明继承如下：  
38.    
39.    
40. Xml代码     
41.     <project>    
42.         <modelVersion>4.0.0</modelVersion>    
43.             
44.         < parent >    
45.             <groupId>com.juvenxu.mvnbook.account</groupId>    
46.             <artifactId> account-parent </artifactId>    
47.             <version>1.0.0-SNAPSHOT</version>    
48.             < relativePath >../account-parent/pom.xml</ relativePath>    
49.         </ parent >    
50.             
51.         <artifactId> account-email </artifactId>    
52.         <name>Account Email</name>    
53.       ...    
54.     </project>    
55.    
56.  最后，同样还需要把 account-parent加入到聚合模块account-aggregator中。聚合的 POM如下：  
57.    
58.    
59. Xml代码     
60.    
61.     <project>    
62.         <modelVersion>4.0.0</modelVersion>    
63.         <groupId>com.juvenxu.mvnbook.account</groupId>    
64.         <artifactId>account-aggregator</artifactId>    
65.         <version>1.0.0-SNAPSHOT</version>    
66.         <packaging> pom </packaging>    
67.         <name>Account Aggregator</name>    
68.         <modules>    
69.             <module>account-email</module>    
70.             <module>account-persist</module>    
71.             <module> account-parent</module>    
72.         </modules>    
73.     </project>    

 

11. 讲讲你理解的 nio。他和 bio 的区别是啥，谈谈 reactor 模型。 

 

[plain] view plain copy

1. Reactor模式首先是事件驱动的，有一个或多个并发输入源，有一个Service Handler，有多个Request Handlers；这个Service Handler会同步的将  
2. 输入的请求（Event）多路复用的分发给相应的Request Handle  
3. http://www.blogjava.net/DLevin/archive/2015/09/02/427045.html  

 

12. 反射的原理，反射创建类实例的三种方式是什么。

 

13. 反射中，Class.forName 和 ClassLoader 区别。

 

14. 描述动态代理的几种实现方式，分别说出相应的优缺点。

 

15. 动态代理与cglib 实现的区别。

 

16. 为什么CGlib 方式可以对接口实现代理。

 

17. final的用途。

 

1. final类不能被继承，没有子类，final类中的方法默认是final的。  
2. final方法不能被子类的方法覆盖，但可以被继承。  
3. final成员变量表示常量，只能被赋值一次，赋值后值不再改变。  
4. final不能用于修饰构造方法  

 

 

18. 出三种单例模式实现。

 

19. 如何在父类中为子类自动完成所有的 hashcode 和 equals 实现？这么做有何优劣。

 

20. 请结合 OO 设计理念，谈谈访问修饰符 public、private、protected、default 在应用设计中的作用。

 

21. 深拷贝和浅拷贝区别。

 

22. 数组和链表数据结构描述，各自的时间复杂度。

 

23. error 和 exception 的区别，CheckedException，RuntimeException 的区别。

 

24. 请列出 5 个运行时异常。

 

25. 在自己的代码中，如果创建一个 java.lang.String 对象，这个对象是否可以被类加载器加载？为什么。

 

[plain] view plain copy

1. http://blog.csdn.net/bbirdsky/article/details/8283143  
2. 字符串类(Java.lang.String)是Java中使用最多的类，也是最为特殊的一个类，很多时候，我们对它既熟悉又陌生。在很多面试题中经常用String大做文章，只要掌握了String特性，对付它们就不再是困难了。  
3. 1、从根本上认识java.lang.String类和String池  
4. 首先，我建议先看看String类的源码实现，这是从本质上认识String类的根本出发点。  
5. 从源码中可以看到：  
6. String类是final的，不可被继承。public final class String。  
7. String类是的本质是字符数组char[], 并且其值不可改变。private final char value[];  
8.    
9. 然后打开String类的API文档，从API中可以发现：  
10. String类对象有个特殊的创建的方式，就是直接指定比如String x = "abc"，"abc"就表示一个字符串对象。而x是"abc"对象的地址，也叫做"abc"对象的引用。  
11. String对象可以通过“+”串联。串联后会生成新的字符串。也可以通过concat()来串联，这个后面会讲述。  
12. Java运行时会维护一个String Pool（String池），JavaDoc翻译很模糊“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。而一般对象不存在这个缓冲池，并且创建的对象仅仅存在于方法的堆栈区。  
13.    
14. 2、创建字符串的方式  
15. 创建字符串的方式很多，归纳起来有三类：  
16. 使用new关键字创建字符串，比如String s1 = new String("abc");  
17. 直接指定。比如String s2 = "abc";  
18. 使用串联生成新的字符串。比如String s3 = "ab" + "c"。  
19.    
20. 3、String对象的创建的特性  
21. String对象的创建也很讲究，关键是要明白其原理。  
22.    
23. 特性1：  
24. 当使用任何方式来创建一个字符串对象s时，Java运行时（运行中JVM）会拿着这个字符串的内容在String池中找是否存在内容相同的字符串对象，如果不存在，则在池中创建一个字符串s，否则，不在池中添加。  
25.    
26. 特性2：  
27. Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对象。  
28.    
29. 特性3：  
30. 使用直接指定、使用纯字符串串联或者在编译期间可以确定结果的变量表达式来创建String对象，则仅仅会检查维护String池中的字符串，池中没有就在池中创建一个，有则罢了！但绝不会在堆栈区再去创建该String对象；  
31. 1、 直接指定，例如：下面代码运行结果为true；  
32. String str1 = "abc";  
33. String str2 = "abc";  
34. System.out.println(str1 == str2);  
35. 2、 使用纯字符串串联，例如：下面代码运行结果为true；  
36. String str1 = "abc";  
37. String str2 = "ab" + "c";  
38. System.out.println(str1 == str2);  
39. 3、 在编译期间可以确定结果的变量表达式，例如：下面代码运行结果为true。  
40. final String str1 = "c"; //final类型的变量在编译时当常量处理  
41. String str2 = "ab" + "c";  
42. String str3 = "ab" + str1;  
43. System.out.println(str2==str3);  
44.    
45. 否则使用包含编译期间无法确定结果的变量的表达式来创建String对象，则不仅会检查维护String池，而且还会在堆栈区创建一个String（由StringBuilder.toString()生成）对象。  
46. 1、普通变量表达式进行创建字符串，例如：下面代码运行结果为false；  
47. String str1 = "c";  
48. String str2 = "ab" + "c";  
49. String str3 = "ab" + str1;  
50. System.out.println(str2==str3);  

 

26. 说一说你对 java.lang.Object 对象中 hashCode 和 equals 方法的理解。在什么场景下需要重新实现这两个方法。

 

27. 在 jdk1.5 中，引入了泛型，泛型的存在是用来解决什么问题。

 

28. 这样的 a.hashcode() 有什么用，与 a.equals(b)有什么关系。

 

[plain] view plain copy

1. 1、equals方法用于比较对象的内容是否相等（覆盖以后）  
2. 2、hashcode方法只有在集合中用到  
3. 3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。  
4. 4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。  
5. 如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。  

 

 

29. 有没有可能 2 个不相等的对象有相同的 hashcode。

 

1. equals()相等的两个对象，hashcode()一定相等；  
2. equals（）不相等的两个对象，却并不能证明他们的hashcode()不相等。换句话说，equals()方法不相等的两个对象，hashcode()有可能相等。