JAVA基础中最常见面试题

今天药忘吃喽~ 2022-12-28 00:35 40阅读 0赞

### JAVA中最常见面试题 ###

*  1.面向对象的三个特征
 *  2.什么是面向对象？
 *  3.多态的好处
 *  4.面向对象和面向过程的区别？
 *  5.什么是值传递和引用传递？
 *  6.代码中如何实现多态
 *  7.接口的意义
 *  8.抽象类的意义
 *  9.接口和抽象类的对比
 *  10.父类的静态方法能否被子类重写
 *  11.什么是不可变对象
 *  12.静态变量和实例变量的区别?
 *  13.能否创建一个包含可变对象的不可变对象?
 *  14.java 创建对象的几种方式
 *  15.switch（）中能否使用string做参数
 *  16.switch能否作用在byte, long上?
 *  17.String s1=”ab”, String s2=”a”+”b”, String s3=”a”, String s4=”b”, s5=s3+s4请问s5==s2返回什么？
 *  18.你对String对象的intern()熟悉么?
 *  19.Object中有哪些公共方法?
 *  20.java当中的四种引用
 *  21.WeakReference与SoftReference的区别?
 *  22.为什么要有不同的引用类型
 *  23.equals()和hashcode()的联系
 *  24.a.hashCode()有什么用?
 *  25.有没有可能两个不相等的对象有相同的hashcode
 *  26.可以在hashcode中使用随机数字吗?
 *  27什么是自动拆装箱？
 *  28.为什么要转换？
 *  29.3\*0.1==0.3返回值是什么
 *  30.short s1= 1; s1 = s1 + 1; 该段代码是否有错,有的话怎么改？
 *  31.数组有没有length()这个方法? String有没有length()这个方法
 *  32.Overload和Override的区别,Overloaded的方法是否可以改变返回值的类型
 *  33.int 和 Integer 有什么区别
 *  34.& 和 &&的区别
 *  34.一个java文件内部可以有类？(非内部类)
 *  35.如何正确的退出多层嵌套循环？
 *  36.内部类的作用
 *  37.clone()是哪个类的方法?
 *  38.深拷贝和浅拷贝的区别是什么?
 *  39.static都有哪些用法?
 *  40.final有哪些用法
 *  41.String, StringBuffer和StringBuilder区别
 *  42.什么是编译器常量？使用它有什么风险？
 *  43.java当中使用什么类型表示价格比较好?
 *  44.如何将byte转为String
 *  45.可以将int强转为byte类型么?会产生什么问题?
 *  46.Java 中 ++ 操作符是线程安全的吗？
 *  47.是否可以在static环境中访问非static变量？
 *  48.Java中，什么是构造方法？什么是构造方法重载？什么是复制构造方法？
 *  49.Java支持多继承么？
 *  50.Java集合框架是什么？说出一些集合框架的优点？
 *  51.集合框架中的泛型有什么优点？
 *  52.Java集合框架的基础接口有哪些？
 *  53.Collection 和 Collections的区别
 *  54.为何Collection不从Cloneable和Serializable接口继承？
 *  55.为何Map接口不继承Collection接口？
 *  56.什么是迭代器(Iterator)？
 *  57.队列和栈是什么，列出它们的区别？
 *  58.Iterator和ListIterator的区别是什么？
 *  59.快速失败(fail-fast)和安全失败(fail-safe)的区别是什么？
 *  60.Java中的HashMap的工作原理是什么？
 *  61.当两个对象的hashcode相同会发生什么？
 *  62.如果两个键的hashcode相同，你如何获取值对象？
 *  63.如何决定选用HashMap还是TreeMap？
 *  64.ArrayList和Vector有何异同点？
 *  65.Array和ArrayList有何区别？什么时候更适合用Array？
 *  66.List 和 Set 区别
 *  67.List 和 Map 区别
 *  68.Arraylist 与 LinkedList 区别
 *  69.Java反射机制的作用：
 *  70.什么是反射机制？
 *  71.哪里用到反射机制？
 *  72.反射机制的优缺点？
 *  73.什么是动态代理
 *  74.error和exception有什么区别
 *  75.运行时异常和一般异常有何不同
 *  76.Java中异常处理机制的原理
 *  77.你平时在项目中是怎样对异常进行处理的。
 *  78.异常处理的时候，finally代码块的重要性是什么？
 *  79.异常的使用的注意地方？
 *  80.反射的功能：
 *  81.反射的用途：
 *  82.反射中，Class.forName 和 ClassLoader 区别
 *  83.Java动态代理的两种实现方法
 *  84.为什么要用动态代理
 *  85.静态代理与动态代理的区别
 *  86.动态代理机制
 *  87.什么是 Java 序列化？
 *  88.如何实现 Java 序列化？
 *  89.Comparable 和 Comparator 的区别?

# 1.面向对象的三个特征 #

> 封装，继承，多态，抽象。

# 2.什么是面向对象？ #

> 面向对象程序设计是以建立模型体现出来的抽象思维过程和面向对象的方法。我们可以将某个事物抽象出来，赋予它自己的特征，并且可以针对这个事物进行相应的操作，以及规定与其他对象之间的关系。可以降低代码的耦合度，使程序更加灵活。

# 3.多态的好处 #

> 允许不同类对象对同一消息做出响应，即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是函数调用)。即父类型的引用指向子类型的对象。主要有以下优点：  
> 可替换性：多态对已存在代码具有可替换性  
> 可扩充性：增加新的子类不影响已经存在的类结构  
> 更加灵活

# 4.面向对象和面向过程的区别？ #

> 面向过程  
> 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源。比如，单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发，性能是最重要的因素。  
> 缺点：没有面向对象易维护、易复用、易扩展。  
> 面向对象  
> 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。  
> 缺点：性能比面向过程低。

# 5.什么是值传递和引用传递？ #

> 值传递，是对基本型变量而言的，传递的是该变量的一个副本，改变副本不影响原变量。  
> 引用传递，一般是对于对象型变量而言的，传递的是该对象地址的一个副本，并不是原对象本身。  
> 一般认为，Java 内的传递都是值传递，Java 中实例对象的传递是引用传递。

# 6.代码中如何实现多态 #

> 实现多态主要有以下三种方式：
> 
> 1.  接口实现
> 2.  继承父类重写方法
> 3.  同一类中进行方法重载

# 7.接口的意义 #

> 规范，扩展，回调。

# 8.抽象类的意义 #

> 为其他子类提供一个公共的类型  
> 封装子类中重复定义的内容  
> 定义抽象方法,子类虽然有不同的实现，但是定义时一致的

# 9.接口和抽象类的对比 #

抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。  
从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。  
相同点：  
接口和抽象类都不能实例化  
都位于继承的顶端，用于被其他实现或继承  
都包含抽象方法，其子类都必须覆写这些抽象方法  
不同点：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70_pic_center]

# 10.父类的静态方法能否被子类重写 #

> 不能。重写只适用于实例方法,不能用于静态方法，而子类当中含有和父类相同签名的静态方法，我们一般称之为隐藏。

# 11.什么是不可变对象 #

> 不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类。

# 12.静态变量和实例变量的区别? #

> 静态变量存储在方法区，属于类所有。实例变量存储在堆当中，其引用存在当前线程栈。

# 13.能否创建一个包含可变对象的不可变对象? #

> 当然可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的引用就可以了，如果需要变化时，就返回原对象的一个拷贝。最常见的例子就是对象中包含一个日期对象的引用。

# 14.java 创建对象的几种方式 #

> new、反射、clone、反序列化机制

# 15.switch（）中能否使用string做参数 #

> 在idk 1.7之前，switch只能支持byte, short, char, int或者其对应的封装类以及Enum类型。从idk 1.7之后switch开始支持String。

# 16.switch能否作用在byte, long上? #

> 可以用在byte上，但是不能用在long上。  
> 在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量，整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合sitch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。

# 17.String s1=”ab”, String s2=”a”+”b”, String s3=”a”, String s4=”b”, s5=s3+s4请问s5==s2返回什么？ #

返回false。在编译过程中，编译器会将s2直接优化为”ab”，会将其放置在常量池当中，s5则是被创建在堆区，相当于s5=new String(“ab”);

# 18.你对String对象的intern()熟悉么? #

> intern()方法会首先从常量池中查找是否存在该常量值，如果常量池中不存在则现在常量池中创建，如果已经存在则直接返回。  
> 比如String s1=”aa”  
> ;String s2=s1.intern();  
> System.out.print(s1==s2);//返回true

# 19.Object中有哪些公共方法? #

> equals()  
> clone()  
> getClass()  
> notify(),notifyAll(),wait()  
> toString

# 20.java当中的四种引用 #

> 强引用，软引用，弱引用，虚引用。不同的引用类型主要体现在GC上:  
> 强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。  
> 软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。  
> 弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象。  
> 虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

# 21.WeakReference与SoftReference的区别? #

> 虽然 WeakReference 与 SoftReference 都有利于提高 GC 和 内存的效率，但是 WeakReference ，一旦失去最后一个强引用，就会被 GC 回收，而软引用虽然不能阻止被回收，但是可以延迟到 JVM 内存不足的时候。

# 22.为什么要有不同的引用类型 #

> 在Java中有时候我们需要适当的控制对象被回收的时机，因此就诞生了不同的引用类型，可以说不同的引用类型实则是对GC回收时机不可控的妥协。有以下几个使用场景可以充分的说明：  
> 利用软引用和弱引用解决OOM问题：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题.

# 23.equals()和hashcode()的联系 #

> hashCode()是Object类的一个方法，返回一个哈希值。如果两个对象根据equal()方法比较相等，那么调用这两个对象中任意一个对象的hashCode()方法必须产生相同的哈希值。  
> 如果两个对象根据eqaul()方法比较不相等，那么产生的哈希值不一定相等(碰撞的情况下还是会相等的。)

# 24.a.hashCode()有什么用? #

> 将对象放入到集合中时，首先判断要放入对象的hashcode是否已经在集合中存在，不存在则直接放入集合。如果hashcode相等，然后通过equal()方法判断要放入对象与集合中的任意对象是否相等：如果equal()判断不相等，直接将该元素放入集合中，否则不放入。

# 25.有没有可能两个不相等的对象有相同的hashcode #

> 有可能，两个不相等的对象可能会有相同的 hashcode 值，这就是为什么在 hashmap 中会有冲突。如果两个对象相等，必须有相同的hashcode 值，反之不成立。

# 26.可以在hashcode中使用随机数字吗? #

> 不行，因为同一对象的 hashcode 值必须是相同的

# 27什么是自动拆装箱？ #

> 自动装箱和拆箱，就是基本类型和引用类型之间的转换。  
> 把基本数据类型转换成包装类的过程就是打包装，为装箱。  
> 把包装类转换成基本数据类型的过程就是拆包装，为拆箱。

# 28.为什么要转换？ #

> 如果你在 Java5 下进行过编程的话，你一定不会陌生这一点，你不能直接地向集合( Collection )中放入原始类型值，因为集合只接收对象。  
> 通常这种情况下你的做法是，将这些原始类型的值转换成对象，然后将这些转换的对象放入集合中。使用 Integer、Double、Boolean 等这些类，我们可以将原始类型值转换成对应的对象，但是从某些程度可能使得代码不是那么简洁精炼。  
> 为了让代码简练，Java5 引入了具有在原始类型和对象类型自动转换的装箱和拆箱机制。  
> 但是自动装箱和拆箱并非完美，在使用时需要有一些注意事项，如果没有搞明白自动装箱和拆箱，可能会引起难以察觉的 Bug 。

# 29.3\*0.1==0.3返回值是什么 #

> false，因为有些浮点数不能完全精确的表示出来。

# 30.short s1= 1; s1 = s1 + 1; 该段代码是否有错,有的话怎么改？ #

> 有错误，short类型在进行运算时会自动提升为int类型，也就是说s1+1的运算结果是int类型。

# 31.数组有没有length()这个方法? String有没有length()这个方法 #

> 数组没有length()这个方法，有length的属性。String有有length()这个方法

# 32.Overload和Override的区别,Overloaded的方法是否可以改变返回值的类型 #

> 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型

# 33.int 和 Integer 有什么区别 #

> Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关

# 34.& 和 &&的区别 #

> &运算符有两种用法：(1)按位与；(2)逻辑与。  
> &&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null &&!username.equals(“”)，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生NullPointerException异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

# 34.一个java文件内部可以有类？(非内部类) #

> 只能有一个public公共类，但是可以有多个default修饰的类。

# 35.如何正确的退出多层嵌套循环？ #

> 使用标号和break;  
> 通过在外层循环中添加标识符

# 36.内部类的作用 #

> 内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立.在单个外围类当中，可以让多个内部类以不同的方式实现同一接口，或者继承同一个类.创建内部类对象的时刻不依赖于外部类对象的创建。内部类并没有令人疑惑的”is-a”管系，它就像是一个独立的实体。  
> 内部类提供了更好的封装，除了该外围类，其他类都不能访问。

# 37.clone()是哪个类的方法? #

> java.lang.Cloneable 是一个标示性接口，不包含任何方法，clone 方法在 object 类中定义。并且需要知道 clone() 方法是一个本地方法，这意味着它是由 c 或 c++ 或 其他本地语言实现的。

# 38.深拷贝和浅拷贝的区别是什么? #

> 浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。  
> 深拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

# 39.static都有哪些用法? #

> 被static所修饰的变量/方法都属于类的静态资源，类实例所共享。  
> static也用于静态块，多用于初始化操作：  
> 此外static也多用于修饰内部类，此时称之为静态内部类。  
> 最后一种用法就是静态导包，可以用来指定导入某个类中的静态资源，并且不需要使用类名。资源名，可以直接使用资源名，比如：

# 40.final有哪些用法 #

final也是很多面试喜欢问的地方，能回答下以下三点就不错了：

1.被final修饰的类不可以被继承

2.被final修饰的方法不可以被重写

3.被final修饰的变量不可以被改变。如果修饰引用，那么表示引用不可变，引用指向的内容可变。

4.被final修饰的方法，JVM会尝试将其内联，以提高运行效率

5.被final修饰的常量，在编译阶段会存入常量池中。

回答出编译器对final域要遵守的两个重排序规则更好：

1.在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。

2.初次读一个包含final域的对象的引用，与随后初次读这个final域,这两个操作之间不能重排序。

# 41.String, StringBuffer和StringBuilder区别 #

> String是字符串常量，final修饰：StringBuffer字符串变量(线程安全)；StringBuilder 字符串变量(线程不安全)。

String和StringBuffer

String和StringBuffer主要区别是性能：String是不可变对象，每次对String类型进行操作都等同于产生了一个新的String对象，然后指向新的String对象。所以尽量不在对String进行大量的拼接操作，否则会产生很多临时对象，导致GC开始工作，影响系统性能。

StringBuffer是对对象本身操作，而不是产生新的对象，因此在有大量拼接的情况下，我们建议使用StringBuffer。

但是需要注意现在JVM会对String拼接做一定的优化：

String s=“This is only ”+”simple”+”test”会被虚拟机直接优化成String s=“This is only simple test”，此时就不存在拼接过程。

StringBuffer和StringBuilder

StringBuffer是线程安全的可变字符串，其内部实现是可变数组。StringBuilder是jdk 1.5新增的，其功能和StringBuffer类似，但是非线程安全。因此，在没有多线程问题的前提下，使用StringBuilder会取得更好的性能。

# 42.什么是编译器常量？使用它有什么风险？ #

公共静态不可变（public static final ）变量也就是我们所说的编译期常量，这里的 public 可选的。实际上这些变量在编译时会被替换掉，因为编译器知道这些变量的值，并且知道这些变量在运行时不能改变。这种方式存在的一个问题是你使用了一个内部的或第三方库中的公有编译时常量，但是这个值后面被其他人改变了，但是你的客户端仍然在使用老的值，甚至你已经部署了一个新的jar。为了避免这种情况，当你在更新依赖 JAR 文件时，确保重新编译你的程序。

# 43.java当中使用什么类型表示价格比较好? #

> 如果不是特别关心内存和性能的话，使用BigDecimal，否则使用预定义精度的 double 类型。

# 44.如何将byte转为String #

> 可以使用 String 接收 byte\[\] 参数的构造器来进行转换，需要注意的点是要使用的正确的编码，否则会使用平台默认编码，这个编码可能跟原来的编码相同，也可能不同。

# 45.可以将int强转为byte类型么?会产生什么问题? #

> 我们可以做强制转换，但是Java中int是32位的而byte是8 位的，所以,如果强制转化int类型的高24位将会被丢弃，byte 类型的范围是从-128到128

# 46.Java 中 ++ 操作符是线程安全的吗？ #

不是线程安全的操作。它涉及到多个指令，如读取变量值，增加，然后存储回内存，这个过程可能会出现多个线程交差。

# 47.是否可以在static环境中访问非static变量？ #

> static变量在Java中是属于类的，它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。

# 48.Java中，什么是构造方法？什么是构造方法重载？什么是复制构造方法？ #

> 当新对象被创建的时候，构造方法会被调用。每一个类都有构造方法。在程序员没有给类提供构造方法的情况下，Java编译器会为这个类创建一个默认的构造方法。  
> Java中构造方法重载和方法重载很相似。可以为一个类创建多个构造方法。每一个构造方法必须有它自己唯一的参数列表。  
> Java不支持像C++中那样的复制构造方法，这个不同点是因为如果你不自己写构造方法的情况下，Java不会创建默认的复制构造方法。

# 49.Java支持多继承么？ #

> Java中类不支持多继承，只支持单继承（即一个类只有一个父类）。 但是java中的接口支持多继承，，即一个子接口可以有多个父接口。（接口的作用是用来扩展对象的功能，一个子接口继承多个父接口，说明子接口扩展了多个功能，当类实现接口时，类就扩展了相应的功能）。

# 50.Java集合框架是什么？说出一些集合框架的优点？ #

集合框架的部分优点如下：

（1）使用核心集合类降低开发成本，而非实现我们自己的集合类。

（2）随着使用经过严格测试的集合框架类，代码质量会得到提高。

（3）通过使用JDK附带的集合类，可以降低代码维护成本。

（4）复用性和可操作性。

# 51.集合框架中的泛型有什么优点？ #

> 泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。

# 52.Java集合框架的基础接口有哪些？ #

Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。

List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List更像长度动态变换的数组。

Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。

一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。

# 53.Collection 和 Collections的区别 #

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

# 54.为何Collection不从Cloneable和Serializable接口继承？ #

> Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。

当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。

在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。

# 55.为何Map接口不继承Collection接口？ #

> 尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。  
> 如果Map继承Collection接口，那么元素去哪儿？Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。

# 56.什么是迭代器(Iterator)？ #

> Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素,但是不可以直接调用集合的remove(Object Obj)删除，可以通过迭代器的remove()方法删除。

# 57.队列和栈是什么，列出它们的区别？ #

1.队列(Queue)：是限定只能在表的一端进行插入和在另一端进行删除操作的线性表

2.栈(Stack)：是限定只能在表的一端进行插入和删除操作的线性表

3.队列先进先出(FIFO)，栈先进后出(FILO)

# 58.Iterator和ListIterator的区别是什么？ #

下面列出了他们的区别：

Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。

Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。

ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。

# 59.快速失败(fail-fast)和安全失败(fail-safe)的区别是什么？ #

快速失败：当你在迭代一个集合的时候，如果有另一个线程正在修改你正在访问的那个集合时，就会抛出一个ConcurrentModification异常。

在java.util包下的都是快速失败。

安全失败：你在迭代的时候会去底层集合做一个拷贝，所以你在修改上层集合的时候是不会受影响的，不会抛出ConcurrentModification异常。

在java.util.concurrent包下的全是安全失败的。

# 60.Java中的HashMap的工作原理是什么？ #

HashMap是基于hashing的原理，我们使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。当我们给put()方法传递键和值时，我们先对键调用hashCode()方法，返回的hashCode用于找到bucket位置来储存Entry对象。

# 61.当两个对象的hashcode相同会发生什么？ #

因为hashcode相同，所以它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。

# 62.如果两个键的hashcode相同，你如何获取值对象？ #

> 当我们调用get()方法，HashMap会使用键对象的hashcode找到bucket位置，然后会调用keys.equals()方法去找到链表中正确的节点，最终找到要找的值对象。

# 63.如何决定选用HashMap还是TreeMap？ #

> 对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。

# 64.ArrayList和Vector有何异同点？ #

ArrayList和Vector在很多时候都很类似。

（1）两者都是基于索引的，内部由一个数组支持。

（2）两者维护插入的顺序，我们可以根据插入顺序来获取元素。

（3）ArrayList和Vector的迭代器实现都是fail-fast的。

（4）ArrayList和Vector两者允许null值，也可以使用索引值对元素进行随机访问。

以下是ArrayList和Vector的不同点。

（1）Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。

（2）ArrayList比Vector快，它因为有同步，不会过载。

（3）ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

# 65.Array和ArrayList有何区别？什么时候更适合用Array？ #

Array可以容纳基本类型和对象，而ArrayList只能容纳对象。

Array是指定大小的，而ArrayList大小是固定的。

Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。尽管ArrayList明显是更好的选择，但也有些时候Array比较好用。

（1）如果列表的大小已经指定，大部分情况下是存储和遍历它们。

（2）对于遍历基本数据类型，尽管Collections使用自动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得很慢。

（3）如果你要使用多维数组，使用\[\]\[\]比List

# 66.List 和 Set 区别 #

List,Set都是继承自Collection接口

List特点：元素有放入顺序，元素可重复

Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉

（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法 ，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）

Set和List对比：

Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。

List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

# 67.List 和 Map 区别 #

List是对象集合，允许对象重复。

Map是键值对的集合，不允许key重复。

# 68.Arraylist 与 LinkedList 区别 #

Arraylist：

优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。

缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。

LinkedList：

优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。LinkedList 适用于要头尾操作或插入指定位置的场景

缺点：因为LinkedList要移动指针,所以查询操作性能比较低。

适用场景分析：

当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。

Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别

答： Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等 equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

# 69.Java反射机制的作用： #

1）在运行时判断任意一个对象所属的类。

2）在运行时判断任意一个类所具有的成员变量和方法。

3）在运行时任意调用一个对象的方法

4）在运行时构造任意一个类的对象

# 70.什么是反射机制？ #

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

# 71.哪里用到反射机制？ #

jdbc中有一行代码：Class.forName(‘com.MySQL.jdbc.Driver.class’).newInstance();那个时候只知道生成驱动对象实例，后来才知道，这就是反射，现在

很多框架都用到反射机制，hibernate，struts都是用反射机制实现的。

# 72.反射机制的优缺点？ #

静态编译：在编译时确定类型，绑定对象，即通过

动态编译：运行时确定类型，绑定对象。动态编译最大限度的发挥了java的灵活性，体现了多态的应用，有利于降低类之间的耦合性。

反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，  
缺点是对性能有影响。

# 73.什么是动态代理 #

> 代理类在程序运行时创建的代理方式被成为 动态代理。 也就是说，这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。

# 74.error和exception有什么区别 #

error表示系统级的错误，是java运行环境内部错误或者硬件问题，不能指望程序来处理这样的问题，除了退出运行外别无选择，它是Java虚拟机抛出的。  
exception 表示程序需要捕捉、需要处理的异常，是由与程序设计的不完善而出现的问题，程序必须处理的问题

# 75.运行时异常和一般异常有何不同 #

Java提供了两类主要的异常：runtimeException和checkedException

一般异常（checkedException）主要是指IO异常、SQL异常等。对于这种异常，JVM要求我们必须对其进行cathc处理，所以，面对这种异常，不管我们是否愿意，都是要写一大堆的catch块去处理可能出现的异常。

运行时异常（runtimeException）我们一般不处理，当出现这类异常的时候程序会由虚拟机接管。比如，我们从来没有去处理过NullPointerException，而且这个异常还是最常见的异常之一。

出现运行时异常的时候，程序会将异常一直向上抛，一直抛到遇到处理代码，如果没有catch块进行处理，到了最上层，如果是多线程就有Thread.run()抛出，如果不是多线程那么就由main.run()抛出。抛出之后，如果是线程，那么该线程也就终止了，如果是主程序，那么该程序也就终止了。

其实运行时异常的也是继承自Exception，也可以用catch块对其处理，只是我们一般不处理罢了，也就是说，如果不对运行时异常进行catch处理，那么结果不是线程退出就是主程序终止。

如果不想终止，那么我们就必须捕获所有可能出现的运行时异常。如果程序中出现了异常数据，但是它不影响下面的程序执行，那么我们就该在catch块里面将异常数据舍弃，然后记录日志。如果，它影响到了下面的程序运行，那么还是程序退出比较好些。

# 76.Java中异常处理机制的原理 #

Java通过面向对象的方式对异常进行处理，Java把异常按照不同的类型进行分类，并提供了良好的接口。当一个方法出现异常后就会抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并对异常进行处理。Java的异常处理是通过5个关键词来实现的：try catch throw throws finally。

一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws），我们可以通过它的类型来捕捉它，或最后由缺省处理器来处理它（finally）。

try：用来指定一块预防所有异常的程序

catch：紧跟在try后面，用来捕获异常

throw：用来明确的抛出一个异常

throws：用来标明一个成员函数可能抛出的各种异常

finally：确保一段代码无论发生什么异常都会被执行的一段代码。

# 77.你平时在项目中是怎样对异常进行处理的。 #

（1）尽量避免出现runtimeException 。例如对于可能出现空指针的代码，带使用对象之前一定要判断一下该对象是否为空，必要的时候对runtimeException

也进行try catch处理。

（2）进行try catch处理的时候要在catch代码块中对异常信息进行记录，通过调用异常类的相关方法获取到异常的相关信息，返回到web端，不仅要给用户良好

的用户体验，也要能帮助程序员良好的定位异常出现的位置及原因。例如，以前做的一个项目，程序遇到异常页面会显示一个图片告诉用户哪些操作导致程序出现

了什么异常，同时图片上有一个按钮用来点击展示异常的详细信息给程序员看的。

# 78.异常处理的时候，finally代码块的重要性是什么？ #

无论是否抛出异常，finally代码块总是会被执行。就算是没有catch语句同时又抛出异常的情况下，finally代码块仍然会被执行。最后要说的是，finally代码块主要用来释放资源，比如：I/O缓冲区，数据库连接。

# 79.异常的使用的注意地方？ #

不要将异常处理用于正常的控制流（设计良好的 API 不应该强迫它的调用者为了正常的控制流而使用异常）。

对可以恢复的情况使用受检异常，对编程错误使用运行时异常。

避免不必要的使用受检异常（可以通过一些状态检测手段来避免异常的发生）。

优先使用标准的异常。

每个方法抛出的异常都要有文档。

保持异常的原子性

不要在 catch 中忽略掉捕获到的异常。

# 80.反射的功能： #

在运行时构造一个类的对象。

判断一个类所具有的成员变量和方法。

调用一个对象的方法。

生成动态代理。

反射的应用很多，很多框架都有用到：

# 81.反射的用途： #

Spring 框架的 IoC 基于反射创建对象和设置依赖属性。

Spring MVC 的请求调用对应方法，也是通过反射。

JDBC 的 Class\#forName(String className) 方法，也是使用反射。

# 82.反射中，Class.forName 和 ClassLoader 区别 #

java中class.forName()和classLoader都可用来对类进行加载。

class.forName()前者除了将类的.class文件加载到jvm中之外，还会对类进行解释，执行类中的static块。

而classLoader只干一件事情，就是将.class文件加载到jvm中，不会执行static中的内容,只有在newInstance才会去执行static块。

# 83.Java动态代理的两种实现方法 #

jdk动态代理是由java内部的反射机制来实现的，cglib动态代理底层则是借助asm来实现的。

总的来说，反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。还有一点必须注意：jdk动态代理的应用前提，必须是目标类基于统一的接口。如果没有上述前提，jdk动态代理不能应用。由此可以看出，jdk动态代理有一定的局限性，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。。

jdk动态代理是jdk原生就支持的一种代理方式，它的实现原理，就是通过让target类和代理类实现同一接口，代理类持有target对象，来达到方法拦截的作用，这样通过接口的方式有两个弊端，一个是必须保证target类有接口，第二个是如果想要对target类的方法进行代理拦截，那么就要保证这些方法都要在接口中声明，实现上略微有点限制。

Cglib是一个优秀的动态代理框架，它的底层使用ASM在内存中动态的生成被代理类的子类，使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用，它的运行速度要远远快于JDK的Proxy动态代理：

# 84.为什么要用动态代理 #

他可以在不修改别代理对象代码的基础上，通过扩展代理类，进行一些功能的附加与增强

# 85.静态代理与动态代理的区别 #

动态代理使我们免于去重写接口中的方法，而着重于去扩展相应的功能或是方法的增强，与静态代理相比简单了不少，减少了项目中的业务量

# 86.动态代理机制 #

Proxy这个类的作用就是用来动态创建一个代理对象的类。每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

# 87.什么是 Java 序列化？ #

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。

可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。

序列化是为了解决在对对象流进行读写操作时所引发的问题。

反序列化的过程，则是和序列化相反的过程。

另外，我们不能将序列化局限在 Java 对象转换成二进制数组，例如说，我们将一个 Java 对象，转换成 JSON 字符串，或者 XML 字符串，这也可以理解为是序列化。

# 88.如何实现 Java 序列化？ #

如下的方式，就是 Java 内置的序列化方案，实际场景下，我们可以自定义序列化的方案，例如说 Google Protobuf 。

将需要被序列化的类，实现 Serializable 接口，该接口没有需要实现的方法，implements Serializable 只是为了标注该对象是可被序列化的。

序列化

然后，使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象

接着，使用 ObjectOutputStream 对象的 \#writeObject(Object obj) 方法，就可以将参数为 obj 的对象写出(即保存其状态)。

反序列化

要恢复的话则用输入流。

Java 序列话中，如果有些字段不想进行序列化怎么办？

对于不想进行序列化的变量，使用 transient 关键字修饰。

当对象被序列化时，阻止实例中那些用此关键字修饰的的变量序列化。

当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

transient 只能修饰变量，不能修饰类和方法。

# 89.Comparable 和 Comparator 的区别? #

Comparable 接口，在 java.lang 包下，用于当前对象和其它对象的比较，所以它有一个 \#compareTo(Object obj) 方法用来排序，该方法只有一个参数。

Comparator 接口，在 java.util 包下，用于传入的两个对象的比较，所以它有一个 \#compare(Object obj1, Object obj2) 方法用来排序，该方法有两个参数

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/caf94d1138c04739ac31dea65cf70dfa.png