Java八股文面试之java基础篇

本是古典何须时尚 2024-04-08 09:23 158阅读 0赞

#### 文章目录 ####

*  一.基本语法
 *   *  1.switch语句中，表达式的数据类型，可以是哪些?
     *  2.==和equals 的对比
     *  面向对象和面向过程的区别
     *  八种基本数据类型的大小，以及他们的封装类
     *  instanceof关键字的作用
     *  3.ArrayList和LinkedList的区别？
     *  4.java 8接口新增了哪些特性？
     *  5.重写与重载的区别
     *  6.实现多重继承的三种方式
     *  7.抽象类和接口的区别
     *  8.为什么要有hashCode?
     *  9.什么是内部类,内部类的分类有哪些？
     *  10.静态方法和实例方法的区别是什么？
     *  11.静态变量和实例变量的区别是什么？
     *  12.构造方法有哪些特性？
     *  13.在Java中定义一个不做事且没有参数的构造方法的作用
     *  14.break,continue,return的区别和作用
     *  15.构造器(constructor)是否可被重写(override)？
     *  16.final、finally以及finalize的区别
     *  17.Java语言有哪些特点(面向对象的四大特性)
     *  18.什么是Java程序的主类？应用程序和小程序的主类有何不同？
     *  19.深克隆和浅克隆
     *  20.String类的截取方法
     *  21.如何跳出双重for循环
     *  22.谈一下异常
     *  JVM 如何判断一个对象可以被回收
     *  Jdk和Jre和JVM的区别
 *  二.Java集合
 *   *  1.Iterator是什么？
     *  ArrayList为什么线程不安全？
     *  ArrayList去重的几种方法
     *  HashMap与HashTable的区别？
     *  HashMap与ConcurrentHashMap的区别？
     *  HashMap有哪些线程安全的方式？
     *  Iterator和ListIterator之间有什么区别？
     *  Enumeration和Iterator接口的区别
 *  多线程
 *   *  线程有哪几种状态。
     *  创建多线程有几种方法？
     *  如何停止一个正在运行的线程
     *  sleep()和wait() 有什么区别？
     *  Thread 类中的start() 和 run() 方法有什么区别？
     *  Thread类中的yield方法有什么作用？
     *  乐观锁和悲观锁的理解以及实现
     *  有三个线程T1,T2,T3如何保证顺序执行
     *  简述一下你对线程池的理解
     *  常用的线程池有哪些？分别有什么特点？
     *  说说ThreadLocal原理？
     *  多线程有什么用？
 *  I/O流
 *   *  流一般需不需要关闭，如果关闭的话用什么方法？一般在哪个代码块里关闭比较好？处理流是怎么关闭的？如果有多个流互相调用传入是怎么关闭的？
     *  Java中有几种类型的流？
 *  反射
 *   *  getFields()和getDeclaredFields()的区别
     *  反射怎么破坏私有结构去设置值
 *  Linux
 *   *  常用命令

## 一.基本语法 ##

### 1.switch语句中，表达式的数据类型，可以是哪些? ###

switch语句中，表达式的数据类型，可以是byte，short，char，int，enum（枚举），JDK7后可以接收字符串

### 2.==和equals 的对比 ###

(1)==既可以判断基本类型，又可以判断引用类型  
①如果判断的是基本类型，则判断的是值是否相等  
②如果判断的是引用类型，则判断的是地址是否相等，即判断是不是同一个对象  
(2)equals是Object类中的方法，只能判断引用类型。默认判断的是地址是否相等，子类一般都会去重写该方法。

### 面向对象和面向过程的区别 ###

（1）面向过程：是分析解决问题的步骤，用函数把这些步骤一步一步地实现，然后在使用的时候一  
一调用则可。性能较高，所以单片机、嵌入式开发等一般采用面向过程开发  
（2）面向对象：是把构成问题的事务分解成各个对象，而建立对象的目的也不是为了完成一个个步骤，  
而是为了描述某个事物在解决整个问题的过程中所发生的行为。面向对象有封装、继承、多态的特  
性，所以易维护、易复用、易扩展。可以设计出低耦合的系统。 但是性能上来说，比面向过程要  
低。

### 八种基本数据类型的大小，以及他们的封装类 ###

![在这里插入图片描述][56626d10349f48ac83f52e0861613a3d.png]

### instanceof关键字的作用 ###

（1）instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法  
为：`boolean result = obj instanceof Class`  
（2）其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接  
或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。  
（3）注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能  
确定类型，则通过编译，具体看运行时定。

int i = 0;
    System.out.println(i instanceof Integer);//编译不通过 必须是引用类型，不能是基本类型
    Integer integer = new Integer(1);
    System.out.println(integer instanceof Integer);//true
    //false ,在 JavaSE规范 中对 instanceof 运算符的规定就是：如果obj为null，那么将返回false。
    System.out.println(null instanceof Object);

### 3.ArrayList和LinkedList的区别？ ###

（1）底层数据结构不同：ArrayList是基于**可变数组**实现的，LinkedList是基于**双向链表+双端队列**实现的。  
ArrayList基于数组使用索引改查效率快，但是增删慢，因为要移动数组中插入、删除位置之后的所有元素。而LinkedList由于只需改变节点中的指针，不必移动节点，故插入、删除灵活；但是，改查慢。  
（2）需要的内存不同：ArrayList中的每个索引的位置存储的是实际的数据，而LinkedList中的每个节点存储的是实际的数据和前后节点的位置，故LinkedList需要更多的内存

### 4.java 8接口新增了哪些特性？ ###

增加了default方法和static方法，这两种方法可以有方法体

// default方法
    public interface LiveAble {
        
    	public default void fly(){
        
    		System.out.println("天上飞");
    } }
    // static方法
    public interface LiveAble {
        
    	public static void run(){
        
    		System.out.println("跑起来~~~");
    }}

### 5.重写与重载的区别 ###

（1）重写：  
①发生在父类与子类之间  
②方法名,参数列表,返回类型(除了子类中方法的返回类型是父类中返回类型的子类)必须相同  
③访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)  
④重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查性异常  
（2）重载：方法名相同，参数列表不同(参数类型不同,或者参数个数不同,甚至是参数顺序不同)  
（3）重写是运行时的多态性，重载是编译时的多态性

### 6.实现多重继承的三种方式 ###

（1）直接实现多个接口  
（2）扩展(extends)一个类然后实现一个或多个接口  
（3）通过内部类去继承其他类

### 7.抽象类和接口的区别 ###

（1）抽象类可以提供成员方法的实现细节，而接口只能存在public abstract 方法  
（2）抽象类中的成员变量可以是各种类型，而接口中的成员变量只能是public static final类型的  
（3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法  
（4）一个类只能继承一个抽象类，而一个类却可以实现多个接口

### 8.为什么要有hashCode? ###

以HashSet为例，使用HashSet添加一个元素时，会根据HashCode值计算出hash值，进而转换成存储表中的索引值。

### 9.什么是内部类,内部类的分类有哪些？ ###

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他  
属性定义方式一致。内部类可以分为成员内部类、局部内部类、匿名内部类和静态内部类

### 10.静态方法和实例方法的区别是什么？ ###

（1）在外部调用静态方法时,可以使用“类名.方法名”，也可以使用“对象名.方法名”;而实例方法只能使用“对象名.方法名”。  
也就是说，调用静态方法可以无需创建对象。  
（2）静态方法在访问本类的成员时，只允许访问静态成员(即静态成员变量和静态方法)，而不允许访问实例成员和实例  
方法；而实例方法无此限制。

### 11.静态变量和实例变量的区别是什么？ ###

（1）静态变量属于类，而不属于任何实例对象。所以在内存中只会有一份，在类的加载过程中，JVM只为静态  
变量分配一次内存空间  
（2）实例变量:每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存的中，  
创建几次对象，就会有几份成员变量。

### 12.构造方法有哪些特性？ ###

（1）名字与方法名相同  
（2）没有返回值，但不能用void声明构造函数  
（3）生成类的对象时自动执行，无需调用

### 13.在Java中定义一个不做事且没有参数的构造方法的作用 ###

Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特有的构造方法，则会调动父类中“没有参数的  
构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用super()来调用父类中  
特定的构造方法，则编译时将会发生错误。

### 14.break,continue,return的区别和作用 ###

（1）break：跳出本次总循环，不在执行当前循环体  
（2）continue：跳出本次循环，继续执行下次循环  
（3）return：程序返回，不再执行下面的代码

### 15.构造器(constructor)是否可被重写(override)？ ###

构造器不能被继承，因此不能被重写，但可以被重载

### 16.final、finally以及finalize的区别 ###

（1）final可以修饰类、变量和方法；修饰类表示该类不能被继承，修饰方法表示该方法不能被重写，修饰变量表示  
该变量是一个常量不能被重新赋值  
（2）finally一般用在try-catch代码块中,在处理异常的时候，通常我们将一定要执行的代码放在finally代码块中,表示  
不管是否出现异常，改代码块都会执行，一般用来存放一些关闭资源的代码。  
（3）finalize是一个方法，属于Object类的一个方法。当对象被回收时，系统自动调用该方法的finalize方法。子类  
可以重写该方法。当某个对象没有任何引用时，jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁  
该对象，在销毁该对象前，会先调用finalize方法。垃圾回收机制的调用，是由系统来决定(即有自己的GC算法)，也  
可以通过System.gc() 主动触发垃圾回收机制

### 17.Java语言有哪些特点(面向对象的四大特性) ###

封装、继承、多态和抽象

### 18.什么是Java程序的主类？应用程序和小程序的主类有何不同？ ###

一个程序中可以有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main()方法的类；而在Java小程序中，这个  
主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不一定要求是public类，但小程序的主类要求必须是public类。主类  
是Java程序执行的入口点。

### 19.深克隆和浅克隆 ###

（1）浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原来属性所指向的对象的内存地址。  
（2）深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

### 20.String类的截取方法 ###

（1）`public String substring(int beginIndex)`  
返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。  
示例： `"unhappy".substring(2) returns "happy"`  
（2）`public String substring(int beginIndex,int endIndex)`返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。  
实例：

"hamburger".substring(4, 8) returns "urge"
     "smiles".substring(1, 5) returns "mile"

### 21.如何跳出双重for循环 ###

在最外层for前加个标记，break 标记名；  
例如：

label:for(){
        
    for(){
        
    break label;
     	}}

### 22.谈一下异常 ###

（1）异常的根类是java.lang.Throwable,其下有两个子类：java.lang.Error和java.lang.Exception，平时所说的异常是指java.lang.Exception  
①Error(错误)：java虚拟机无法解决的严重错误  
②Exception(异常)：因编程错误或偶然的外在因素导致的一般性问题，可以针对性的使用代码进行处理。  
（2）Exception(异常)又可以分为:  
①运行时异常：编译器检查不出来，一般是指编程时的逻辑错误，是程序员应该避免出现的异常  
常见的运行时异常有空指针异常、数学运算异常、数组下标越界异常、类型转换异常等  
②编译时异常：运行时异常(RuntimeException)以外的异常,是编译器要求必须处理的异常,如IOException、SQLException等  
（3）异常处理方式：  
①try-catch-finally  
②throws(将发生的异常抛出,交给调用者(方法)来处理，最顶级的处理者就是JVM)  
（4）自定义异常  
自定义异常类名，该类继承Exception或者RuntimeException  
①如果继承Exception，属于编译异常  
②如果继承RuntimeException，属于运行时异常。一般来说我们都继承RuntimeException  
抛出异常使用：throw new 异常类名(参数);

### JVM 如何判断一个对象可以被回收 ###

在 JVM 里面， 要判断一个对象是否可以被回收， 最重要的是判断这个对象是否还在被使用，  
只有没被使用的对象才能回收。  
（1）引用计数器， 也就是为每一个对象添加一个引用计数器， 用来统计指向当前对象的引  
用次数，如果当前对象存在应用的更新， 那么就对这个引用计数器进行增加， 一旦这个引用  
计数器变成 0， 就意味着它可以被回收了。这种方法需要额外的空间来存储引用计数器， 但是  
它的实现很简单， 而且效率也比较高。不过主流的 JVM 都没有采用这种方式， 因为引用计数器  
在处理一些复杂的循环引用或者相互依赖的情况时，  
可能会出现一些不再使用但是又无法回收的内存， 造成内存泄露的问题。  
（2）可达性分析， 它的主要思想是：  
① 首先确定一系列肯定不能回收的对象作为GC root，比如虚拟机栈里面的引用对象、 本地方法栈  
引用的对象等， 然后以 GC ROOT作为起始节点，从这些节点开始向下搜索， 去寻找它的直接和  
间接引用的对象， 当遍历完之后如果发现有一些对象不可到达，那么就认为这些对象已经没有用了，  
需要被回收。  
②在垃圾回收的时候， JVM 会首先找到所有的 GC root， 这个过程会暂停所有用户线程，也就是  
stop the world， 然后再从 GC Roots 这些根节点向下搜索， 可达的对象保留， 不可达的就会回收掉。  
可达性分析是目前主流 JVM 使用的算法。

### Jdk和Jre和JVM的区别 ###

（1）JDK：Jdk还包括了一些Jre之外的东西 ，就是这些东西帮我们编译Java代码的， 还有就是监控Jvm  
的一些工具 Java Development Kit是提供给Java开发人员使用的，其中包含了Java的开发工具，也  
包括了JRE。所以安装了JDK，就无需再单独安装JRE了。其中的开发工具：编译工具(javac.exe)，  
打包工具(jar.exe)等  
（2）JRE ：Jre大部分都是 C 和 C++ 语言编写的，他是我们在编译java时所需要的基础的类库 Java  
Runtime Environment包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang  
包：包含了运行Java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线  
程、异常处理类等，系统缺省加载这个包  
如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。  
（3）Jvm：在倒数第二层 由他可以在（最后一层的）各种平台上运行 Java Virtual Machine是Java虚拟  
机，Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言可以实现跨平

## 二.Java集合 ##

### 1.Iterator是什么？ ###

Iterator接口提供遍历实现任何Collection接口的集合。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合中的Enumeration，并且迭代器允许调用者在迭代过程中移除元素。

### ArrayList为什么线程不安全？ ###

（1）第一步的ensureCapacityInternal(size+1)方法不安全  
ArrayList默认数组大小为10，假设现在已经添加进去9个元素了，size=9。  
①线程A执行完add方法中的ensureCapacityInternal(size+1)挂起来  
②线程B开始执行，较验数组容量发现不需要扩容。于是把“b”放在了下标为9的位置，且size自增1  
③线程A接着执行，尝试把“a”放在下标为10的位置。但因为数组还没有扩容，最大下标  
才为9，所以会抛出数组越界异常。  
（2）第二步的elementData\[size++\]方法也不安全  
比如刚开始添加元素时size=0，有两个线程，线程A先将元素存放到位置0，但是CPU调度线程A暂停，线程B得到运行的机会。线程B也向此ArrayList中添加元素，因为此时size仍然等于0，所以线程B也将元素存放在位置0，覆盖掉了A。然后线程A和B都继续运行，都增加size的值。这样，线程AB执行完毕后，理想中的情况为size为2，elementData下标为0的位置为A,下标为1的位置为B。而实际情况变成了size为2，elementData下标为0的位置变成了B,下标为1的位置上什么都没有。

### ArrayList去重的几种方法 ###

（1）通过LinkedHashSet来解决  
LinkedHashSet是有序不可重复的，可以把ArrayList传入LinkedHashSet中  
（2）使用Java8的新特性stream的distinct()方法来实现  
（3）使用contains()方法去重  
（4）利用HashSet(无序唯一)的特性

### HashMap与HashTable的区别？ ###

（1）HashMap没有考虑同步，是线程不安全的；HashTable使用了synchronized关键字，是线程安全的  
（2）HashMap允许<K/V>都为null，而HashTable不允许为<K/V>为null。  
（3）Hashtable,HashMap 都使用了 Iterator。而由于历史原因,Hashtable 还使用了Enumeration 的方式  
（4）HashTable中hash数组的默认大小是11，增加方式是old\*2+1，HashMap中hash数组的默认大小是16，之后每次  
扩容变为原来的两倍。  
（5）HashTable继承自Dictionary,HashMap继承自AbstractMap

### HashMap与ConcurrentHashMap的区别？ ###

HashMap是线程不安全的，如果需要需要考虑线程安全的情况下还要考虑性能，可以使用ConcurrentHashMap。  
（1）ConcurrentHashMap是JUC(java.util.concurrent)下的线程安全  
（2）ConcurrentHashMap对整个桶数组进行了分割分段(Segment)，然后在每一个分段上都用lock锁  
进行保护，相对于HashTable的synchronized锁的粒度更精细了一些，并发性能更好，而  
HashMap没有锁机制，不是线程安全的。（JDK1.8之后ConcurrentHashMap启用了一种全新的  
方式实现,利用CAS算法。）  
（3）HashMap的键值对允许有null，但是ConCurrentHashMap都不允许。

### HashMap有哪些线程安全的方式？ ###

（1）方法一：通过Collections.synchronizedMap()返回一个新的Map，这个新的map就是线程安全的。这个要求  
大家习惯基于接口编程，因为返回的并不是HashMap,而是一个Map的实现  
（2）方法二：重新改写HashMap，具体的可以查看java.util.concurrcent.ConcurrentHashMap.这个方法比方法一有了很大的改进

### Iterator和ListIterator之间有什么区别？ ###

（1）我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List  
（2）Iterator只可以向前遍历，而ListIterator可以双向遍历  
（3）ListIterator继承Iterator接口，并添加了一些额外的功能，比如添加、替换一个元素，获取前面或后面元素的索引位置

### Enumeration和Iterator接口的区别 ###

（1）Enumeration的速度是Iterator的两倍，并且使用更少的内存。Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全；因为当一个集合正在被遍历时，它会阻止其他线程去修改集合。  
（2）迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。

## 多线程 ##

### 线程有哪几种状态。 ###

（1）NEW  
线程至今尚未启动  
（2）RUNNABLE  
线程正在 Java 虚拟机中执行  
（3）BLOCKED  
受阻塞并等待获得同步代码块的锁  
（4）WAITING  
无限期地等待另一个线程来执行某一特定操作  
（5）TIMED\_WAITING  
在指定的时间内等待另一个线程来执行某一特定操作  
（6）TERMINATED  
线程已退出  
注意：RUNNABLE 是否真的运行取决于调度器，由操作系统内核来决定，可以细分为Ready就绪和Running运行

### 创建多线程有几种方法？ ###

通过继承Thread类或者实现Runnable接口、Callable接口(JDK>=1.5)都可以实现多线程，不过实现Runnable接口与实现Callable  
接口的方式基本相同，只是Callable接口里定义的方法返回值，可以声明抛出异常而已。因此，将实现Runnable接口  
和实现Callable接口可以归为一种方式。  
（1）实现Runnable、Callable接口的方式创建线程的优缺点  
①优点：线程类只是实现了Runnable接口或者Callable接口，还可以继承其他类。这种方式下，多个线程可以共享一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好的体现了面向对象的思想。  
②缺点：编程稍微复杂一些，如果需要访问当前线程，则必须使用Thread.currentThread()方法  
（2）继承Thread类的方式创建线程的优缺点  
①优点：编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获取当前线程  
②缺点：因为线程类已经继承了Thread类，java语言是单继承的，所以就不能再继承其他父类了。

### 如何停止一个正在运行的线程 ###

（1）当线程退出后,会自动正常退出，也就是当run方法完成后线程终止  
（2）使用stop方法强行终止，但是不推荐；因为stop方法是个废弃方法  
（3）使用interrupt方法中断线程,但并没有真正的结束线程,所以一般用于中断正在休眠的线程

### sleep()和wait() 有什么区别？ ###

（1）对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类  
中的。  
（2）sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程，但是他的监控状态依然保持  
着，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。  
（2）当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用  
notify()方法后本线程才进入对象锁定池准备，获取对象锁进入运行状态。

### Thread 类中的start() 和 run() 方法有什么区别？ ###

start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的  
效果不一样。当你调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()  
方法才会启动新线程。

### Thread类中的yield方法有什么作用？ ###

yield方法可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行。它是一个静态方法  
而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可  
能在进入到暂停状态后马上又被执行。

### 乐观锁和悲观锁的理解以及实现 ###

（1）\*\*乐观锁：\*\*每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断  
一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。  
（2）**乐观锁的实现方式：**  
①使用版本标识来确定读到的数据与提交时的数据是否一致。提交后修改版本标识，不一致时可  
以采取丢弃和再次尝试的策略。  
②java中的Compare and Swap即CAS ，当多个线程尝试使用CAS同时更新同一个变量时，只有其  
中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争  
中失败，并可以再次尝试。 CAS 操作中包含三个操作数 —— 需要读写的内存位置（V）、进行比  
较的预期原值（A）和拟写入的新值(B)。如果内存位置V的值与预期原值A相匹配，那么处理器会自  
动将该位置值更新为新值B。否则处理器不做任何操作  
\*\*（3）悲观锁：\*\*总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据  
的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。  
传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做  
操作之前先上锁。再比如Java里面的同步原语synchronized关键字的实现也是悲观锁。  
**（4）悲观锁的实现方式**:synchronized和lock  
①synchronized是Java关键字，而lock是一个类  
②synchronized获取锁的时候，假设A线程获得锁，B等待，若A阻塞，B会自治等待；而lock在这种情况下  
B会尝试去获取锁  
③synchronized的锁的状态是无法判断的，而lock是可以判断的  
④synchronized和lock都是对象锁，都支持重入锁  
⑤lock可以实现synchronized不具备的特性，如响应中断，支持超时，公平锁和共享锁  
（共享锁:在同一时刻,可以有多个线程用有锁；独占锁:synchronized，在任一时刻，只有一个线程可以拥有此锁）  
（）

### 有三个线程T1,T2,T3如何保证顺序执行 ###

可以使用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的  
顺序你应该先启动最后一个(T3调用T2,T2调用T1),这样T1就会先完成而T3最后完成。实际上先启动三个线程中哪一个  
都行，因为在每个线程的run()方法中都用join方法限定了三个线程的执行顺序。

public class JoinTest2 {
        
    // 1.现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行
    public static void main(String[] args) {
        
    	final Thread t1 = new Thread(new Runnable() {
        
    		@Override
    		public void run() {
        
    			System.out.println("t1");
    }
    });
    	final Thread t2 = new Thread(new Runnable() {
        
    		@Override
    		public void run() {
        
    			try {
        
    		// 引用t1线程，等待t1线程执行完
    				t1.join();
    			} catch (InterruptedException e) {
        
    				e.printStackTrace();
    	}
    				System.out.println("t2");
    }
    });
    	Thread t3 = new Thread(new Runnable() {
        	
    	@Override
    	public void run() {
        
    		try {
        
    		// 引用t2线程，等待t2线程执行完
    		t2.join();
    } catch (InterruptedException e) {
        
    		e.printStackTrace();
    }
    		System.out.println("t3");
    }

### 简述一下你对线程池的理解 ###

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗  
（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行  
（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会  
降低系统的稳定性，使用线程可以进行统一的分配，调优和监控。

### 常用的线程池有哪些？分别有什么特点？ ###

（1）newSingleThreadExecutor：创建一个单线程池，此线程池保证所有任务的执行顺序按照任务的提交顺序执行  
（2）newFixedThreadPool：是一种固定线程数量的线程池  
特点：核心线程和最大线程数量都是一个固定的值。如果任务比较多工作线程处理不过来，就会加入到阻塞队列  
里面等待。  
（3）newCachedThreadPool：是一种可以缓存的线程池，它可以用来处理大量短期的突发流量  
特点:①最大线程数是Interger.MaxValue②线程存活时间是60秒③阻塞队列用的是SynchronousQueue  
（4）newScheduledThreadPool:具有延迟执行功能的线程池，可以用来实现实时调度  
（5）newWorkStealingPool：Java8里面新加入的一个线程池，它内部会创建一个ForkJoinPool,利用工作窃取的算法并行处理请求

### 说说ThreadLocal原理？ ###

hreadLocal可以理解为线程本地变量，他会在每个线程都创建一个副本，那么在线程之间访问内部  
副本变量就行了，做到了线程之间互相隔离，相比于synchronized的做法是用空间来换时间。  
ThreadLocal有一个静态内部类ThreadLocalMap，ThreadLocalMap又包含了一个Entry数组，  
Entry本身是一个弱引用，他的key是指向ThreadLocal的弱引用，Entry具备了保存key value键值对  
的能力。  
弱引用的目的是为了防止内存泄露，如果是强引用那么ThreadLocal对象除非线程结束否则始终无  
法被回收，弱引用则会在下一次GC的时候被回收。  
但是这样还是会存在内存泄露的问题，假如key和ThreadLocal对象被回收之后，entry中就存在key  
为null，但是value有值的entry对象，但是永远没办法被访问到，同样除非线程结束运行。  
但是只要ThreadLocal使用恰当，在使用完之后调用remove方法删除Entry对象，实际上是不会出  
现这个问题的。

### 多线程有什么用？ ###

（1）发挥多核CPU的优势  
随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的，4核、8核甚至  
16核的也都不少见，如果是单线程的程序，那么在双核CPU上就浪费了50%，在4核CPU上就浪费  
了75%。单核CPU上所谓的"多线程"那是假的多线程，同一时间处理器只会处理一段逻辑，只不过  
线程之间切换得比较快，看着像多个线程"同时"运行罢了。多核CPU上的多线程才是真正的多线  
程，它能让你的多段逻辑同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用  
CPU的目的。  
（2）防止阻塞  
从程序运行效率的角度来看，单核CPU不但不会发挥出多线程的优势，反而会因为在单核CPU上运  
行多线程导致线程上下文的切换，而降低程序整体的效率。但是单核CPU我们还是要应用多线程，  
就是为了防止阻塞。试想，如果单核CPU使用单线程，那么只要这个线程阻塞了，比方说远程读取  
某个数据吧，对端迟迟未返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止  
运行了。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，  
也不会影响其它任务的执行。  
（3）便于建模  
这是另外一个没有这么明显的优点了。假设有一个大的任务A，单线程编程，那么就要考虑很多，  
建立整个程序模型比较麻烦。但是如果把这个大的任务A分解成几个小任务，任务B、任务C、任务  
D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。

## I/O流 ##

### 流一般需不需要关闭，如果关闭的话用什么方法？一般在哪个代码块里关闭比较好？处理流是怎么关闭的？如果有多个流互相调用传入是怎么关闭的？ ###

（1）流一旦打开就必须关闭，使用close方法关闭  
（2）一般放入finally语句块中(finally语句一定会执行)  
（3）调用了的处理流就关闭处理流  
（4）多个流互相调用只关闭最外层的流

### Java中有几种类型的流？ ###

（1）按照操作数据单位的不同分为：字节流和字符流  
（2）按照流的流向不用分为：输入流和输出流  
（3）按照流的角色不同分为：节点流，处理流(包装流)

## 反射 ##

### getFields()和getDeclaredFields()的区别 ###

（1）getFields() 只能获得public的field  
（2）getDeclaredFields() 可以获得所有的field

### 反射怎么破坏私有结构去设置值 ###

使用暴破setAccessible(true)，可以访问 private 构造器/方法/属性

## Linux ##

### 常用命令 ###

（1）cd： 切换目录  
（2）pwd：显示当前工作目录的绝对路径  
（3）ls： 查看当前目录下的内容(ls只列出文件名/目录名)  
（4）ll：查看当前目录下的所有详细信息(ll列出详细信息)  
（5）touch：创建文件  
（6）mkdir：创建目录  
（7）cat：用于显示文件内容  
（8）more：以分页的形式查看文件的内容  
（9）less：分页查看文件命令(可以快速定位到最后一页)  
（10）tail：查看文件最后几行  
如：tail -10 // 查看最后10行  
（11）cp：复制文件或目录  
（12）mv：移动文件/改文件名  
（13）rm：删除文件或文件夹  
（14）find：查找指定文件或目录  
（15）vi/vim：编辑  
（16）tar：解压、压缩  
（17）ifconfig：用于查看和更改网络接口的地址和参数  
（18）ping ip地址：用于检测与目标的连通性

[56626d10349f48ac83f52e0861613a3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/dfa0a2cd95f848e6b6089a0296b428a0.png