2024 Java常见面试43题

内部类可直接访问外部类的属性

Java中内部类主要分为成员内部类、局部内部类(嵌套在方法和作用域内)、匿名内部类（没构造方法）、静态内部类（static修饰的类，不能使用任何外围类的非static成员变量和方法， 不依赖外围类）

5.进程和线程的区别

==========

进程是cpu资源分配的最小单位，

线程是cpu调度的最小单位。

进程之间不能共享资源，而线程共享所在进程的地址空间和其它资源。

一个进程内可拥有多个线程，进程可开启进程，也可开启线程。

一个线程只能属于一个进程，线程可直接使用同进程的资源,线程依赖于进程而存在。

6.final，finally，finalize的区别

===========================

final:

修饰类、成员变量和成员方法，类不可被继承，成员变量不可变，成员方法不可重写

finally:

与try...catch...共同使用，确保无论是否出现异常都能被调用到

finalize:

类的方法,垃圾回收之前会调用此方法,子类可以重写finalize()方法实现对资源的回收

7.Serializable 和Parcelable 的区别

==============================

Serializable

Java序列化接口 在硬盘上读写 读写过程中有大量临时变量的生成，内部执行大量的i/o操作，效率很低。

Parcelable

Android序列化接口 效率高 使用麻烦 在内存中读写（AS有相关插件 一键生成所需方法） ，对象不能保存到磁盘中

8.静态属性和静态方法是否可以被继承？是否可以被重写？以及原因？

================================

可继承 不可重写 而是被隐藏

如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成。

9.成员内部类、静态内部类、局部内部类和匿名内部类的理解，以及项目中的应用

=====================================

Java中内部类主要分为成员内部类、局部内部类(嵌套在方法和作用域内)、匿名内部类（没构造方法）、静态内部类（static修饰的类，不能使用任何外围类的非static成员变量和方法， 不依赖外围类）

使用内部类最吸引人的原因是：

每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

因为Java不支持多继承，支持实现多个接口。但有时候会存在一些使用接口很难解决的问题，这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。

10.string 转换成 integer的方式及原理

===========================

String to integer

Intrger.parseInt(string);

Integer to String

Integer.toString();

11.哪些情况下的对象会被垃圾回收机制处理掉？

=======================

1. 所有实例都没有活动线程访问。

2. 没有被其他任何实例访问的循环引用实例。

3. Java 中有不同的引用类型。判断实例是否符合垃圾收集的条件都依赖于它的引用类型。

要判断怎样的对象是没用的对象。这里有2种方法：

1. 采用标记计数的方法：

给内存中的对象给打上标记，对象被引用一次，计数就加1，引用被释放了，计数就减一，当这个计数为0的时候，这个对象就可以被回收了。当然，这也就引发了一个问题：循环引用的对象是无法被识别出来并且被回收的。所以就有了第二种方法：

1. 采用根搜索算法：

从一个根出发，搜索所有的可达对象，这样剩下的那些对象就是需要被回收的

12.静态代理和动态代理的区别，什么场景使用？

=======================

静态代理类：

由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理类：

在程序运行时，运用反射机制动态创建而成。

13.Java中实现多态的机制是什么？

===================

方法的重写Overriding和重载Overloading是Java多态性的不同表现

重写

Overriding是父类与子类之间多态性的一种表现

重载

Overloading是一个类中多态性的一种表现.

14.说说你对Java反射的理解

================

Java反射机制是在运行状态中, 对于任意一个类, 都能够知道这个类的所有属性和方法; 对于任意一个对象, 都能够调用它的任意一个方法和属性。从对象出发，通过反射（Class类）可以取得取得类的完整信息（类名 Class类型，所在包、具有的所有方法 Method[]类型)、某个方法的完整信息（包括修饰符、返回值类型、异常、参数类型）、所有属性 (Field[]、某个属性的完整信息、构造器 Constructors），调用类的属性或方法自己的总结：在运行过程中获得类、对象、方法的所有信息。

15.说说你对Java注解的理解

================

元注解

元注解的作用就是负责注解其他注解。java5.0的时候，定义了4个标准的meta-annotation类型，它们用来提供对其他注解的类型作说明。

1.@Target

2.@Retention

3.@Documented

4.@Inherited

16.Java中String的了解

=================

在源码中String是用final 进行修饰，它是不可更改，不可继承的常量。

17.String为什么要设计成不可变的？

=====================

1. 字符串池的需求

字符串池是方法区（Method Area）中的一块特殊的存储区域。当一个字符串已经被创建并且该字符串在 池 中，该字符串的引用会立即返回给变量，而不是重新创建一个字符串再将引用返回给变量。如果字符串不是不可变的，那么改变一个引用（如: string2）的字符串将会导致另一个引用（如: string1）出现脏数据。

1. 允许字符串缓存哈希码

在Java中常常会用到字符串的哈希码，例如：HashMap 。String的不变性保证哈希码始终一，因此，他可以不用担心变化的出现。这种方法意味着不必每次使用时都重新计算一次哈希码——这样，效率会高很多。

1. 安全

String广泛的用于java 类中的参数，如：网络连接（Network connetion），打开文件（opening files ）等等。如果String是可变的，网络连接、文件将会被改变——这将会导致一系列的安全威胁。操作的方法本以为连接上了一台机器，但实际上却不是。由于反射中的参数都是字符串，同样，也会引起一系列的安全问题。

18.Object类的equal和hashCode方法重写，为什么？

==================================

首先equals与hashcode间的关系是这样的：

1. 如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；

2. 如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)。

由于为了提高程序的效率才实现了hashcode方法，先进行hashcode的比较，如果不同，那没就不必在进行equals的比较了，这样就大大减少了equals比较的次数，这对比需要比较的数量很大的效率提高是很明显的

19.List,Set,Map的区别

==================

Set

是最简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。 Set接口主要实现了两个实现类：

HashSet：

HashSet类按照哈希算法来存取集合中的对象，存取速度比较快

TreeSet ：

TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。

List

是其元素以线性方式存储，集合中可以存放重复对象。

ArrayList() :

代表长度可以改变得数组。可以对元素进行随机的访问，向ArrayList()中插入与删除元素的速度慢。

LinkedList():

在实现中采用链表数据结构。插入和删除速度快，访问速度慢。

Map

是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。 Map没有继承于Collection接口 从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。

HashMap：

Map基于散列表的实现。插入和查询键值对的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。

LinkedHashMap：

类似于HashMap，但是迭代遍历它时，取得键值对的顺序是其插入次序，或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快，因为它使用链表维护内部次序。

TreeMap ：

基于红黑树数据结构的实现。查看键或键值对时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在 于，你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。

WeakHashMao ：

弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。

20.ArrayMap和HashMap的对比

======================

1. 存储方式不同

HashMap内部有一个HashMapEntry<K, V>[]对象，每一个键值对都存储在这个对象里，当使用put方法添加键值对时，就会new一个HashMapEntry对象，

1. 添加数据时扩容时的处理不一样，进行了new操作，重新创建对象，开销很大。ArrayMap用的是copy数据，所以效率相对要高。

3.ArrayMap提供了数组收缩的功能，在clear或remove后，会重新收缩数组，是否空间

1. ArrayMap采用二分法查找；

21.HashMap和HashTable的区别

=======================

HashMap

不是线程安全的，效率高一点、方法不是Synchronize的要提供外同步，有containsvalue和containsKey方法。

hashtable

是线程安全，不允许有null的键和值，效率稍低，方法是是Synchronize的。有contains方法方法。Hashtable继承于Dictionary 类

22.HashMap与HashSet的区别

=====================

hashMap:

HashMap实现了Map接口,HashMap储存键值对,使用put()方法将元素放入map中,HashMap中使用键对象来计算hashcode值,HashMap比较快，因为是使用唯一的键来获取对象。

HashSet

实现了Set接口，HashSet仅仅存储对象，使用add()方法将元素放入set中，HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false。HashSet较HashMap来说比较慢。

23.HashSet与HashMap怎么判断集合元素重复？

=============================

HashSet

不能添加重复的元素，当调用add（Object）方法时候，

首先会调用Object的hashCode方法判hashCode是否已经存在，如不存在则直接插入元素；如果已存在则调用Object对象的equals方法判断是否返回true，如果为true则说明元素已经存在，如为false则插入元素。

24.ArrayList和LinkedList的区别，以及应用场景

=================================

ArrayList

是基于数组实现的，ArrayList线程不安全。

LinkedList

是基于双链表实现的：

使用场景：

1. 如果应用程序对各个索引位置的元素进行大量的存取或删除操作，ArrayList对象要远优于LinkedList对象；

2. 如果应用程序主要是对列表进行循环，并且循环时候进行插入或者删除操作，LinkedList对象要远优于ArrayList对象；

25.数组和链表的区别

===========

数组：

是将元素在内存中连续存储的；它的优点：因为数据是连续存储的，内存地址连续，所以在查找数据的时候效率比较高；它的缺点：在存储之前，我们需要申请一块连续的内存空间，并且在编译的时候就必须确定好它的空间的大小。在运行的时候空间的大小是无法随着你的需要进行增加和减少而改变的，当数据两比较大的时候，有可能会出现越界的情况，数据比较小的时候，又有可能会浪费掉内存空间。在改变数据个数时，增加、插入、删除数据效率比较低。

链表：

是动态申请内存空间，不需要像数组需要提前申请好内存的大小，链表只需在用的时候申请就可以，根据需要来动态申请或者删除内存空间，对于数据增加和删除以及插入比数组灵活。还有就是链表中数据在内存中可以在任意的位置，通过应用来关联数据（就是通过存在元素的指针来联系）

26.开启线程的三种方式？

=============

Java有三种创建线程的方式，分别是

继承Thread类、实现Runable接口和使用线程池。

27.线程和进程的区别？

============

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。

28.run()和start()方法区别

====================

这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。

30.如何控制某个方法允许并发访问线程的个数？

=======================

semaphore.acquire()请求一个信号量，这时候的信号量个数-1（一旦没有可使用的信号量，也即信号量个数变为负数时，再次请求的时候就会阻塞，直到其他线程释放了信号量）

semaphore.release()释放一个信号量，此时信号量个数+1

31.在Java中wait和seelp方法的不同；

=========================

Java程序中wait和sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时间，但不会释放锁。

32.谈谈wait/notify关键字的理解

======================

等待对象的同步锁,需要获得该对象的同步锁才可以调用这个方法,否则编译可以通过，但运行时会收到一个异常：IllegalMonitorStateException。

调用任意对象的 wait()方法导致该线程阻塞，该线程不可继续执行，并且该对象上的锁被释放。

唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

调用任意对象的notify()方法则导致因调用该对象的wait()方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

33.什么导致线程阻塞？线程如何关闭？

===================

阻塞式方法是指程序会一直等待该方法完成期间不做其他事情，ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前，当前线程会被挂起，直到得到结果之后才会返回。此外，还有异步和非阻塞式方法在任务完成前就返回。

一种是调用它里面的stop()方法

另一种就是你自己设置一个停止线程的标记 （推荐这种）

34.如何保证线程安全？

============

• 1.synchronized；

• 2.Object方法中的wait,notify；

• 3.ThreadLocal机制 来实现的。

35.如何实现线程同步？

============

1. synchronized关键字修改的方法。

2. synchronized关键字修饰的语句块

3. 使用特殊域变量（volatile）实现线程同步

36.线程间操作List

============

List list = Collections.synchronizedList(new ArrayList());

37.谈谈对Synchronized关键字，类锁，方法锁，重入锁的理解

===================================

java的对象锁和类锁：

java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的

38.synchronized 和volatile 关键字的区别

================================

1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。

1. volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的

2. volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性

4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。

5.volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

39.ReentrantLock 、synchronized和volatile比较

=========================================

Java在过去很长一段时间只能通过synchronized关键字来实现互斥，它有一些缺点。比如你不能扩展锁之外的方法或者块边界，尝试获取锁时不能中途取消等。Java 5 通过Lock接口提供了更复杂的控制来解决这些问题。 ReentrantLock类实现了 Lock，它拥有与synchronized相同的并发性和内存语义且它还具有可扩展性。

40.死锁的四个必要条件？