能量加油站Java上

蔚落 2024-03-30 16:07 58阅读 0赞

#### 1、final 在 Java 中有什么作用？ ####

*  1、final 修饰的类叫最终类，该类不能被继承。
 *  2、final 修饰的方法不能被重写
 *  3、final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改

#### 2、Math.round() 指向上取整 ####

*  补充 Double.doubleToRawLongBits() 作用是将double转换为Long类型

#### 3、long 和 float 区别 ####

*  Double类中doubleToRawLongBits，double类型占64位，而long类型也是占64位，两个类型在计算机中存储的机器码都是64位二进制，从0和1的角度来看，是没有任何区别的。区别在于，对应同一64位二进制机器码，两者的解析方式不同
 *  long：按整数类型来解析，也是我们常见的类似“个十百千…”位来存储的，例如13  
    ![1212.png][]  
    所以13的二进制位0…1101（…代表省略了64-5=59个零）
 *  double：按浮点类型来解析，按IEEE754标准，详细见IEEE  
    754 浮点类型表示  
    64位：符号位，共1位  
    53-63位：指数位，共11位  
    1-52位：尾数位，共52位
 *  在jdk中double类（float与int对应）中提供了double与long转换，doubleToRawLongBits就是将double转换为long，这个方法是原始方法（底层不是java实现，是c++实现的）

public static native long doubleToRawLongBits(double value);

*  doubleToRawLongBits转换时，value可能是NaN，这时候，doubleToRawLongBits还是会直接转换为对应的long，doubleToRawLong的可以允许非double数值转换，而doubleToLongBits经过了一次处理，将NaN的数值全部替换为，这个就是两者的区别

public static long doubleToLongBits(double value) {
        
            long result = doubleToRawLongBits(value);
            // Check for NaN based on values of bit fields, maximum
            // exponent and nonzero significand.
            if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
                  DoubleConsts.EXP_BIT_MASK) &&
                 (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
                result = 0x7ff8000000000000L;
            return result;
        }

#### 4、 Java 中操作字符串都有哪些类？它们之间有什么区别？ ####

*  操作字符串的类有：String、StringBuffer、StringBuilder。
 *  String 和 StringBuffer、StringBuilder 的区别在于 String 声明的是不可变的对象，每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象，而 StringBuffer、StringBuilder 可以在原有对象的基础上进行操作，所以在经常改变字符串内容的情况下最好不要使用 String。
 *  StringBuffer 和 StringBuilder 最大的区别在于，StringBuffer 是线程安全的，而 StringBuilder 是非线程安全的，但 StringBuilder 的性能却高于 StringBuffer，所以在单线程环境下推荐使用 StringBuilder，多线程环境下推荐使用 StringBuffer。

#### 5、抽象类必须要有抽象方法吗？ ####

abstract classCat{
        
        publicstaticvoidsayHi(){
        
            System. out. println("hi~");
        }
    }

#### 6、接口和抽象类有什么区别？ ####

*  实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。
 *  构造函数：抽象类可以有构造函数；接口不能有。
 *  实现数量：类可以实现很多个接口；但是只能继承一个抽象类。
 *  访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法可以是任意访问修饰符。

#### 7、Java 中 IO 流分为几种？ ####

*  按功能来分：输入流（input）、输出流（output）。
 *  按类型来分：字节流和字符流。
 *  字节流和字符流的区别是：字节流按 8 位传输以字节为单位输入输出数据，字符流按 16 位传输以字符为单位输入输出数据。

#### 8、BIO、NIO、AIO 有什么区别？ ####

*  BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
 *  NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
 *  AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制

#### 9、Files的常用方法都有哪些？ ####

*  Files. exists()：检测文件路径是否存在。
 *  Files. createFile()：创建文件。
 *  Files. createDirectory()：创建文件夹。
 *  Files. delete()：删除一个文件或目录。
 *  Files. copy()：复制文件。
 *  Files. move()：移动文件。
 *  Files. size()：查看文件个数。
 *  Files. read()：读取文件。
 *  Files. write()：写入文件。

#### 10、Java 容器都有哪些？ ####

*  Java 容器分为 Collection 和 Map 两大类，其下又有很多子类，如下所示：  
    ![collections.png][]
 *  Collection接口：单列数据，定义了存取一组对象的方法的集合

> 1、List：元素有序(指的是存储时，与存放顺序保持一致)、可重复的集合  
> 2、Set：元素无序、不可重复的集合

### ![Maps.png][] ###

*  ArrayList和LinkedList、Vector比较

> 1、二者都线程不安全，相对线程安全的Vector，执行效率高。此外，ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。
> 
> > 1、Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized)，属于强同步类，访问要慢,同时开销也比ArrayList要大，Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍

*  11、HashMap 和 Hashtable 有什么区别？

> 1、存储：HashMap 运行 key 和 value 为 null，而 Hashtable 不允许。  
> 2、线程安全：Hashtable 是线程安全的，而 HashMap 是非线程安全的。

*  12、如何决定使用 HashMap 还是 TreeMap？

> 1、对于在 Map 中插入、删除、定位一个元素这类操作，HashMap 是最好的选择，因为相对而言 HashMap 的插入会更快，但如果你要对一个 key 集合进行有序的遍历，那 TreeMap 是更好的选择。

*  13、说一下 HashMap 的实现原理

> 1、HashMap 基于 Hash 算法实现的，我们通过 put(key,value)存储，get(key)来获取。当传入 key 时，HashMap 会根据 key. hashCode() 计算出 hash 值，根据 hash 值将 value 保存在 bucket 里。当计算出的 hash 值相同时，我们称之为 hash 冲突，HashMap 的做法是用链表和红黑树存储相同 hash 值的 value。当 hash 冲突的个数比较少时，使用链表否则使用红黑树。

*  14、说一下 HashSet 的实现原理？

> 1、HashSet 是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，因此 HashSet 的实现比较简单，相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成，HashSet 不允许重复的值。

*  15、ArrayList 和 LinkedList 的区别是什么？

> 1、数据结构实现：ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。

> 2、随机访问效率：ArrayList 比 LinkedList 在随机访问的时候效率要高，因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。

> 3、增加和删除效率：在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，因为 ArrayList 增删操作要影响数组内的其他数据的下标。

*  16、如何实现数组和 List 之间的转换？

> 1、数组转 List：使用 Arrays. asList(array) 进行转换。  
> 2、List 转数组：使用 List 自带的 toArray() 方法。

// list to array
    List<String> list = new ArrayList<String>();
    list. add("醉代码");
    list. add("的博客");
    list. toArray();
    // array to list
    String[] array = new String[]{
        "王磊","的博客"};
    Arrays. asList(array);

*  17、ArrayList 和 Vector 的区别是什么？

> 1、线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。

> 2、性能：ArrayList 在性能方面要优于 Vector。

> 3、扩容：ArrayList 和 Vector 都会根据实际的需要动态的调整容量，只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。

*  18、Array 和 ArrayList 有何区别？

> 1、Array 可以存储基本数据类型和对象，ArrayList 只能存储对象。

> 2、Array 是指定固定大小的，而 ArrayList 大小是自动扩展的。

> 3、Array 内置方法没有 ArrayList 多，比如 addAll、removeAll、iteration 等方法只有 ArrayList 有

*  19、在 Queue 中 poll()和 remove()有什么区别？

> 1、相同点：都是返回第一个元素，并在队列中删除返回的对象。  
> 2、不同点：如果没有元素 poll()会返回 null，而 remove()会直接抛出 NoSuchElementException 异常。

Queue<String> queue = new LinkedList<String>();
    queue. offer("string"); // add
    System. out. println(queue. poll());
    System. out. println(queue. remove());
    System. out. println(queue. size());

*  20、哪些集合类是线程安全的？

> 1、Vector、Hashtable、Stack 都是线程安全的  
> 2、HashMap 对应的线程安全类就是 ConcurrentHashMap

*  21、 迭代器 Iterator 是什么?

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

*  22、Iterator 怎么使用？有什么特点？

List<String> list = new ArrayList<>();
    Iterator<String> it = list. iterator();
    while(it. hasNext()){
        
      String obj = it. next();
      System. out. println(obj);
    }

> Iterator 的特点是更加安全，因为它可以确保，在当前遍历的集合元素被更改的时候，就会抛出 ConcurrentModificationException 异常。

*  23、Iterator 和 ListIterator 有什么区别？

> 1、Iterator 可以遍历 Set 和 List 集合，而 ListIterator 只能遍历 List。

> 2、Iterator 只能单向遍历，而 ListIterator 可以双向遍历（向前/后遍历）。

> 3、ListIterator 从 Iterator 接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。

*  24、怎么确保一个集合不能被修改？

> 1、可以使用 Collections. unmodifiableCollection(Collection c) 方法来创建一个只读集合，这样改变集合的任何操作都会抛出 Java. lang. UnsupportedOperationException 异常。  
> 示例代码如下：

List<String> list = new ArrayList<>();
    list. add("x");
    Collection<String> clist = Collections. unmodifiableCollection(list);
    clist. add("y"); // 运行时此行报错
    System. out. println(list. size());

#### 多线程 ####

*  25、并行和并发有什么区别？

> 1、并行：多个处理器或多核处理器同时处理多个任务。  
> 2、并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。

*  26、线程和进程的区别？

> 一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有多个线程来增加程序的执行速度。

*  27、守护线程是什么？

> 守护线程是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。在 Java 中垃圾回收线程就是特殊的守护线程。

*  28、创建线程有哪几种方式？

> 创建线程有三种方式：  
> 继承 Thread 重写 run 方法；  
> 实现 Runnable 接口；  
> 实现 Callable 接口。

*  29、说一下 runnable 和 callable 有什么区别？

> runnable 没有返回值，callable 可以拿到有返回值，callable 可以看作是 runnable 的补充。

*  30、sleep() 和 wait() 有什么区别？

> 1、类的不同：sleep() 来自 Thread，wait() 来自 Object  
> 2、释放锁：sleep() 不释放锁；wait() 释放锁。  
> 3、用法不同：sleep() 时间到会自动恢复；wait() 可以使用 notify()/notifyAll()直接唤醒。

*  31、notify()和 notifyAll()有什么区别？

> 1、notifyAll()会唤醒所有的线程，notify()之后唤醒一个线程。notifyAll() 调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而 notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制。

*  32、线程的 run() 和 start() 有什么区别？

> 1、start() 方法用于启动线程，run() 方法用于执行线程的运行时代码。run() 可以重复调用，而 start() 只能调用一次。

*  33、创建线程池有哪几种方式？

> 1、newSingleThreadExecutor()：它的特点在于工作线程数目被限制为 1，操作一个无界的工作队列，所以它保证了所有任务的都是被顺序执行，最多会有一个任务处于活动状态，并且不允许使用者改动线程池实例，因此可以避免其改变线程数目；  
> 2、newCachedThreadPool()：它是一种用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 作为工作队列；  
> 3、newFixedThreadPool(int nThreads)：重用指定数目（nThreads）的线程，其背后使用的是无界的工作队列，任何时候最多有 nThreads 个工作线程是活动的。这意味着，如果任务数量超过了活动队列数目，将在工作队列中等待空闲线程出现；如果有工作线程退出，将会有新的工作线程被创建，以补足指定的数目 nThreads；  
> 4、newSingleThreadScheduledExecutor()：创建单线程池，返回 ScheduledExecutorService，可以进行定时或周期性的工作调度；  
> 5、newScheduledThreadPool(int corePoolSize)：和newSingleThreadScheduledExecutor()类似，创建的是个 ScheduledExecutorService，可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程；  
> 6、newWorkStealingPool(int parallelism)：这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序；  
> 7、***ThreadPoolExecutor()***：是最原始的线程池创建，上面1-3创建方式都是对ThreadPoolExecutor的封装。

*  34、线程池都有哪些状态？

> 1、RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。  
> 2、SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。  
> 3、STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。  
> 4、TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。  
> 5、TERMINATED：terminated()方法结束后，线程池的状态就会变成这个。

### ![jsp.jpg][] ###

> 1、RUNNING  
> a、状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。  
> b、状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！

> 2、SHUTDOWN  
> a、状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。  
> b、状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。

> 3、STOP  
> a、状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。  
> b、状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

> 4、TIDYING  
> a 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。  
> b 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。  
> 当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

> 5、TERMINATED  
> a 状态说明：线程池彻底终止，就变成TERMINATED状态。  
> b 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

*  35、线程池中 submit() 和 execute() 方法有什么区别？

> 1、execute()：只能执行 Runnable 类型的任务。

> 2、submit()：可以执行 Runnable 和 Callable 类型的任务。  
> 备注：Callable 类型的任务可以获取执行的返回值，而 Runnable 执行无返回值。

*  36、在 Java 程序中怎么保证多线程的运行安全？

> 1、使用安全类，比如 Java. util. concurrent 下的类  
> 2、使用自动锁 synchronized  
> 3、使用手动锁 Lock

Lock lock = new ReentrantLock();
    lock. lock();
    try {
        
        System. out. println("获得锁");
    } catch (Exception e) {
        
        // TODO: handle exception
    } finally {
        
        System. out. println("释放锁");
        lock. unlock();
    }

*  37、什么是死锁？

> 当线程 A 持有独占锁a，并尝试去获取独占锁 b 的同时，线程 B 持有独占锁 b，并尝试获取独占锁 a 的情况下，就会发生 AB 两个线程由于互相持有对方需要的锁，而发生的阻塞现象，我们称为死锁。

*  38、怎么防止死锁？

> 1、尽量使用 tryLock(long timeout, TimeUnit unit)的方法(ReentrantLock、ReentrantReadWriteLock)，设置超时时间，超时可以退出防止死锁。

> 2、尽量使用 Java. util. concurrent 并发类代替自己手写锁。  
> 3、尽量降低锁的使用粒度，尽量不要几个功能用同一把锁。

*  39、 ThreadLocal 是什么？有哪些使用场景？

> 1、ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

> 2、ThreadLocal 的经典使用场景是数据库连接和 session 管理等。  
> threadlocal详情

*  40、synchronized 和 volatile 的区别是什么？

> 1、volatile 是变量修饰符；synchronized 是修饰类、方法、代码段。  
> 2、volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的修改可见性和原子性。  
> 3、volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。  
> 4、volatile不需要加锁，比synchronized更轻量级，不会阻塞线程；  
> 5、从内存可见性角度，volatile读相当于加锁，volatile写相当于解锁；

### ![v2ilate.png][] ###

### ![resolve.png][] ###

*  41、synchronized 和 Lock 有什么区别？>

> 1、synchronized 可以给类、方法、代码块加锁；而 lock 只能给代码块加锁。

> 2、synchronized 不需要手动获取锁和释放锁，使用简单，发生异常会自动释放锁，不会造成死锁；而 lock 需要自己加锁和释放锁，如果使用不当没有 unLock()去释放锁就会造成死锁。

> 3、通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

*  42 、说一下 atomic 的原理？

> 1、通过CAS (Compare And Wwap)乐观锁机制-自旋锁（它的实现很简单，就是用一个预期的值和内存值进行比较，如果两个值相等，就用预期的值替换内存值，并返回 true。否则，返回 false。）保证原子性，【通过降低锁粒度（多段锁）增加并发性能。这一点是java8做出的改进】从而避免 synchronized 的高开销，执行效率大为提升。

class MyThread implements Runnable {
        
     
        static AtomicInteger ai=new AtomicInteger(0);
     
        public void run() {
        
            for (int m = 0; m < 1000000; m++) {
        
                ai.getAndIncrement();
            }
        }
    };
     
    public class TestAtomicInteger {
        
        public static void main(String[] args) throws InterruptedException {
        
            MyThread mt = new MyThread();
     
            Thread t1 = new Thread(mt);
            Thread t2 = new Thread(mt);
            t1.start();
            t2.start();
            Thread.sleep(500);
            System.out.println(MyThread.ai.get());
        }
    }
    备注：
    使用AtomicInteger声明了一个全局变量，并且在多线程中进行自增，代码中并没有进行显示的加锁。以上代码的输出结果，永远都是2000000。如果将AtomicInteger换成Integer，打印结果基本都是小于2000000。

> 2、在Java 8中引入了4个新的计数器类型，LongAdder、LongAccumulator、DoubleAdder、DoubleAccumulator。他们都是继承于Striped64。当竞争不激烈的时候，所有线程都是通过CAS对同一个变量（Base）进行修改，当竞争激烈的时候，会将根据当前线程哈希到对于Cell上进行修改（多段锁）

#### 反射 ####

*  43、什么是反射？

> 1、在程序运行过程中，对任意一个类都能获取其所有属性和方法，并且对任意一个对象都能调用其任意一个属性和方法。这种动态获取类和对象的信息，以及动态调用对象的方法的功能被称为Java语言的反射机制

*  44、什么是 Java 序列化？什么情况下需要序列化？

> 1、为了保存各种对象在内存中的状态，并且可以把保存的对象状态再读出来。

*  45、动态代理是什么？有哪些应用？

> 1、动态代理是运行时动态生成代理类。  
> 2、spring aop、hibernate 数据查询、测试框架的后端 mock、rpc，Java注解对象获取等

*  46、 怎么实现动态代理？

> 1、JDK 原生动态代理和 cglib 动态代理。JDK 原生动态代理是基于接口实现的，而 cglib 是基于继承当前类的子类实现的。

public class Test {
        
    
    	/**
    	 * Main入口
    	 * @param args
    	 * @throws ClassNotFoundException 
    	 */
    	@SuppressWarnings("rawtypes")
    	public static void main(String[] string) throws ClassNotFoundException {
        
    		Word word = new Word();
    		Class word1 = word.getClass();				// 通过对象的getClass()方法获取Class
    		Class word2 = Word.class;					// 通过类.class获取Class
    		Class word3 = Class.forName("com.Word");	// 通过路径获取Class
    		System.out.println(word1 == word2);
    		System.out.println(word2 == word3);
    	}
    
    }

**结果都是 true**

#### 对象拷贝 ####

*  47、为什么要使用克隆？

> 1、克隆的对象可能包含一些已经修改过的属性，而 new 出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠克隆方法了。

*  48、如何实现对象克隆？
    
    > 1、实现 Cloneable 接口并重写 Object 类中的 clone() 方法。
    
    > 2、实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。
 *  48、深拷贝和浅拷贝区别是什么？

> 1、浅克隆：当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。

> 2、深克隆：除了对象本身被复制外，对象所包含的所有成员变量也将复制。

#### Java Web ####

*  49、JSP 和 servlet 有什么区别？

> 1、JSP 是 servlet 技术的扩展，本质上就是 servlet 的简易方式。servlet 和 JSP 最主要的不同点在于，servlet 的应用逻辑是在 Java 文件中，并且完全从表示层中的 html 里分离开来，而 JSP 的情况是 Java 和 html 可以组合成一个扩展名为 JSP 的文件。JSP 侧重于视图，servlet 主要用于控制逻辑。

*  50、JSP 有哪些内置对象？作用分别是什么？

> JSP 有 9 大内置对象：  
> 1、request：封装客户端的请求，其中包含来自 get 或 post 请求的参数；  
> 2、response：封装服务器对客户端的响应；  
> 3、pageContext：通过该对象可以获取其他对象；  
> 4、session：封装用户会话的对象；  
> 5、application：封装服务器运行环境的对象；  
> 6、out：输出服务器响应的输出流对象；  
> 7、config：Web 应用的配置对象；  
> 8、page：JSP 页面本身（相当于 Java 程序中的 this）；  
> 9、exception：封装页面抛出异常的对象。

*  51、session 和 cookie 有什么区别？

> 1、存储位置不同：session 存储在服务器端；cookie 存储在浏览器端。  
> 2、安全性不同：cookie 安全性一般，在浏览器存储，可以被伪造和修改。  
> 3、容量和个数限制：cookie 有容量限制，每个站点下的 cookie 也有个数限制。  
> 4、存储的多样性：session 可以存储在 Redis 中、数据库中、应用程序中；而 cookie 只能存储在浏览器中。

*  52、说一下 session 的工作原理？

> session 的工作原理是客户端登录完成之后，服务器会创建对应的 session，session 创建完之后，会把 session 的 id 发送给客户端，客户端再存储到浏览器中。这样客户端每次访问服务器时，都会带着 sessionid，服务器拿到 sessionid 之后，在内存找到与之对应的 session 这样就可以正常工作了。

*  53、如果客户端禁止 cookie 能实现 session 还能用吗？

> 可以用，session 只是依赖 cookie 存储 sessionid，如果 cookie 被禁用了，可以使用 url 中添加 sessionid 的方式保证 session 能正常使用。

*  54、spring mvc 和 struts 的区别是什么？

> 1、拦截级别：struts2 是类级别的拦截；spring mvc 是方法级别的拦截。  
> 2、数据独立性：spring mvc 的方法之间基本上独立的，独享 request 和 response 数据，请求数据通过参数获取，处理结果通过 ModelMap 交回给框架，方法之间不共享变量；而 struts2 虽然方法之间也是独立的，但其所有 action 变量是共享的，这不会影响程序运行，却给我们编码和读程序时带来了一定的麻烦。  
> 3、拦截机制：struts2 有以自己的 interceptor 机制，spring mvc 用的是独立的 aop 方式，这样导致struts2 的配置文件量比 spring mvc 大。  
> 4、对 ajax 的支持：spring mvc 集成了ajax，所有 ajax 使用很方便，只需要一个注解 @ResponseBody 就可以实现了；而 struts2 一般需要安装插件或者自己写代码才行。

*  55、如何避免 SQL 注入？

> 1、使用预处理 PreparedStatement。  
> 2、使用正则表达式过滤掉字符中的特殊字符。

#### 异常 ####

*  56、 throw 和 throws 的区别？

> throw：是真实抛出一个异常。  
> throws：是声明可能会抛出一个异常。

*  57、final、finally、finalize 有什么区别？

> 1、final：是修饰符，如果修饰类，此类不能被继承；如果修饰方法和变量，则表示此方法和此变量不能在被改变，只能使用。

> 2、finally：是 try\{\} catch\{\} finally\{\} 最后一部分，表示不论发生任何情况都会执行，finally 部分可以省略，但如果 finally 部分存在，则一定会执行 finally 里面的代码。

> 3、finalize：是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法。

*  58、 try-catch-finally 中哪个部分可以省略？

> try-catch-finally 其中 catch 和 finally 都可以被省略，但是不能同时省略，也就是说有 try 的时候，必须后面跟一个 catch 或者 finally。

*  59、try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

> finally 一定会执行，即使是 catch 中 return 了，catch 中的 return 会等 finally 中的代码执行完之后，才会执行。

*  60、常见的异常类有哪些？

> 1、NullPointerException 空指针异常  
> 2、ClassNotFoundException 指定类不存在  
> 3、NumberFormatException 字符串转换为数字异常  
> 4、IndexOutOfBoundsException 数组下标越界异常  
> 5、ClassCastException 数据类型转换异常  
> 6、FileNotFoundException 文件未找到异常  
> 7、NoSuchMethodException 方法不存在异常  
> 8、IOException IO 异常  
> 9、SocketException Socket 异常

#### 网络 ####

*  61、http 响应码 301 和 302 代表的是什么？有什么区别？

> 1、301：永久重定向。  
> 2、302：暂时重定向。  
> 它们的区别是，301 对搜索引擎优化（SEO）更加有利；302 有被提示为网络拦截的风险。

*  62、forward 和 redirect 的区别？

> 1、forward 是转发 和 redirect 是重定向：  
> 2、地址栏 url 显示：foward url 不会发生改变，redirect url 会发生改变；  
> 3、数据共享：forward 可以共享 request 里的数据，redirect 不能共享；  
> 4、效率：forward 比 redirect 效率高。

*  63、 TCP 三次握手介绍  
    ![TCP.png][]
 *  64、get 和 post 请求有哪些区别？

> 1、get 请求会被浏览器主动缓存，而 post 不会

> 2、get 传递参数有大小限制，而 post 没有

> 3、post 参数传输更安全，get 的参数会明文限制在 url 上，post 不会

*  65、实现跨域有以下几种方案：

> 1、服务器端运行跨域 设置 CORS 等于 \*；  
> 2、在单个接口使用注解 @CrossOrigin 运行跨域；  
> 3、使用 jsonp 跨域；

*  66、JSONP 实现原理？
    
    > jsonp：JSON with Padding，它是利用script标签的 src 连接可以访问不同源的特性，加载远程返回的“JS 函数”来执行的。

#### 设计模式 ####

*  67、说一下你熟悉的设计模式？

> 1、单例模式：保证被创建一次，节省系统开销。  
> 2、工厂模式（简单工厂、抽象工厂）：解耦代码。  
> 3、观察者模式：定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有的依赖者都会收到通知并自动更新。  
> 4、外观模式：提供一个统一的接口，用来访问子系统中的一群接口，外观定义了一个高层的接口，让子系统更容易使用。  
> 5、模版方法模式：定义了一个算法的骨架，而将一些步骤延迟到子类中，模版方法使得子类可以在不改变算法结构的情况下，重新定义算法的步骤。  
> 6、状态模式：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

*  68、简单工厂和抽象工厂有什么区别？

> 简单工厂：用来生产同一等级结构中的任意产品，对于增加新的产品，无能为力。  
> 抽象工厂：用来生产不同产品族的全部产品，对于增加新的产品，无能为力；支持增加产品族。

#### Spring/Spring MVC ####

*  69、为什么要使用 spring？

> 1、spring 提供 ioc 技术，容器会帮你管理依赖的对象，从而不需要自己创建和管理依赖对象了，更轻松的实现了程序的解耦。  
> 2、spring 提供了事务支持，使得事务操作变的更加方便。  
> spring 提供了面向切片编程，这样可以更方便的处理某一类的问题。  
> 3、更方便的框架集成，spring 可以很方便的集成其他框架，比如 MyBatis、hibernate 等。

*  70、 解释一下什么是 aop？

> aop 是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

*  71、解释一下什么是 ioc？

> 对于 spring 框架来说，就是由 spring 来负责控制对象的生命周期和对象间的关系。

*  72、spring 有哪些主要模块？

> spring core：框架的最基础部分，提供 ioc 和依赖注入特性。  
> spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法。  
> spring dao：Data Access Object 提供了JDBC的抽象层。  
> spring aop：提供了面向切面的编程实现，让你可以自定义拦截器、切点等。  
> spring Web：提供了针对 Web 开发的集成特性，例如文件上传，利用 servlet listeners 进行 ioc 容器初始化和针对 Web 的 ApplicationContext。  
> spring Web mvc：spring 中的 mvc 封装包提供了 Web 应用的 Model-View-Controller（MVC）的实现。

*  73、spring 常用的注入方式有哪些？

> setter 属性注入  
> 构造方法注入  
> 注解方式注入

*  74、spring 中的 bean 是线程安全的吗？

> 1、spring 中的 bean 默认是单例模式，spring 框架并没有对单例 bean 进行多线程的封装处理。  
> 2、最简单的就是改变 bean 的作用域，把“singleton”变更为“prototype”，这样请求 bean 相当于 new Bean()了，所以就可以保证线程安全了。

*  75、spring 支持几种 bean 的作用域？

> 1、singleton：spring ioc 容器中只存在一个 bean 实例，bean 以单例模式存在，是系统默认值；  
> 2、prototype：每次从容器调用 bean 时都会创建一个新的示例，既每次 getBean()相当于执行 new Bean()操作；  
> Web 环境下的作用域：  
> 3、request：每次 http 请求都会创建一个 bean；  
> 4、session：同一个 http session 共享一个 bean 实例；  
> 5、global-session：用于 portlet 容器，因为每个 portlet 有单独的 session，globalsession 提供一个全局性的 http session。

*  76、 spring 自动装配 bean 有哪些方式？

> no：默认值，表示没有自动装配，应使用显式 bean 引用进行装配。  
> byName：它根据 bean 的名称注入对象依赖项。  
> byType：它根据类型注入对象依赖项。  
> 构造函数：通过构造函数来注入依赖项，需要设置大量的参数。  
> autodetect：容器首先通过构造函数使用 autowire 装配，如果不能，则通过 byType 自动装配。

*  77、spring 事务实现方式有哪些？

> 声明式事务：声明式事务也有两种实现方式，基于 xml 配置文件的方式和注解方式（在类上添加 @Transaction 注解）  
> 编码方式：提供编码的形式管理和维护事务。

*  78、说一下 spring 的事务隔离？

> spring 有五大隔离级别，默认值为 ISOLATION\_DEFAULT（使用数据库的设置），其他四个隔离级别和数据库的隔离级别一致：
> 
> > ISOLATION\_DEFAULT：用底层数据库的设置隔离级别，数据库设置的是什么我就用什么；

> > ISOLATIONREADUNCOMMITTED：未提交读，最低隔离级别、事务未提交前，就可被其他事务读取（会出现幻读、脏读、不可重复读）；

> > ISOLATIONREADCOMMITTED：提交读，一个事务提交后才能被其他事务读取到（会造成幻读、不可重复读），SQL server 的默认级别；

> > ISOLATIONREPEATABLEREAD：可重复读，保证多次读取同一个数据时，其值都和事务开始时候的内容是一致，禁止读取到别的事务未提交的数据（会造成幻读），MySQL 的默认级别；

> > ISOLATION\_SERIALIZABLE：序列化，代价最高最可靠的隔离级别，该隔离级别能防止脏读、不可重复读、幻读。

*  79、Spring mvc的运行流程

> spring mvc 先将请求发送给 DispatcherServlet  
> DispatcherServlet 查询一个或多个 HandlerMapping，找到处理请求的 Controller  
> DispatcherServlet 再把请求提交到对应的 Controller  
> Controller 进行业务逻辑处理后，会返回一个ModelAndView  
> Dispathcher 查询一个或多个 ViewResolver 视图解析器，找到 ModelAndView 对象指定的视图对象  
> 视图对象负责渲染返回给客户端

*  80、@RequestMapping 的作用是什么？

> 将 http 请求映射到相应的类/方法上

*  81、@Autowired 的作用是什么？

> @Autowired 它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作，通过@Autowired 的使用来消除 set/get 方法

#### Spring Boot/Spring Cloud ####

*  82、什么是 spring boot？

> spring boot 是为 spring 服务的，是用来简化新 spring 应用的初始搭建以及开发过程的

*  83、为什么要用 spring boot？

> 1、配置简单  
> 2、独立运行  
> 3、自动装配  
> 4、无代码生成和 xml 配置  
> 5、提供应用监控  
> 6、提升开发效率

*  84、spring boot 核心配置文件是什么？

> 1、bootstrap (. yml 或者 . properties)：boostrap 由父 ApplicationContext 加载的，比 applicaton 优先加载，且 boostrap 里面的属性不能被覆盖；  
> 2、application (. yml 或者 . properties)：用于 spring boot 项目的自动化配置。 yml 格式不支持 @PropertySource 注解导入，xml和property文件可以解析

@Configuration
    @ComponentScan(basePackages = "propertysourcedemo")
    @PropertySource(value = "classpath:daoconfig/datasource-config.properties")
    public class SpringConfig {
        
    
        //通过SPEL表达式注入属性
        @Value("${druid.driverClassName}")
        private String driverClassName;
    
        @Value("${druid.url}")
        private String url;
    
        @Value("${druid.username}")
        private String username;
    
        @Value("${druid.password}")
        private String password;
    
        //创建资源文件解析器，spring4.3之前必须要的，不要就无法解析。
        @Bean
        public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer(){
        
            return new PropertySourcesPlaceholderConfigurer();
        }
    
        //注册Druid数据源连接池
        @Bean
        public DruidDataSource druidDataSource(){
        
            System.out.println("driverClassName====> " + driverClassName);
            System.out.println("url====> " + url);
            System.out.println("username====> " + username);
            System.out.println("username====> " + username);
            DruidDataSource druidDataSource = new DruidDataSource();
            druidDataSource.setDriverClassName(driverClassName);
            druidDataSource.setUrl(url);
            druidDataSource.setUsername(username);
            druidDataSource.setPassword(password);
            return druidDataSource;
        }
    }

*  85、spring boot 有哪些方式可以实现热部署？

> 1、使用 devtools 启动热部署，添加 devtools 库，在配置文件中把 spring. devtools. restart. enabled 设置为 true；  
> 2、使用 Intellij Idea 编辑器，勾上自动编译或手动重新编译。

*  86、jpa 和 hibernate 有什么区别？

> Java Persistence API，是 Java 持久化接口规范，hibernate 属于 jpa 的具体实现。

*  87、什么是 spring cloud？

> spring cloud 是一系列框架的有序集合。它利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 spring boot 的开发风格做到一键启动和部署。

*  88、 spring cloud 断路器的作用是什么？

> 在分布式架构中，断路器模式的作用也是类似的，当某个服务单元发生故障（类似用电器发生短路）之后，通过断路器的故障监控（类似熔断保险丝），向调用方返回一个错误响应，而不是长时间的等待。这样就不会使得线程因调用故障服务被长时间占用不释放，避免了故障在分布式系统中的蔓延。

*  89、spring cloud 的核心组件有哪些？

> Eureka：服务注册于发现。  
> Feign：基于动态代理机制，根据注解和选择的机器，拼接请求 url 地址，发起请求。  
> Ribbon：实现负载均衡，从一个服务的多台机器中选择一台。  
> Hystrix：提供线程池，不同的服务走不同的线程池，实现了不同服务调用的隔离，避免了服务雪崩的问题。  
> Zuul：网关管理，由 Zuul 网关转发请求给对应的服务

*  90、为什么要用Hibernate？

> 1、hibernate 是对 jdbc 的封装，大大简化了数据访问层的繁琐的重复性代码。

2、hibernate 是一个优秀的 ORM 实现，很多程度上简化了 DAO 层的编码功能。

3、可以很方便的进行数据库的移植工作。

4、提供了缓存机制，是程序执行更改的高效。

*  91、什么是 ORM 框架？

> 1、ORM（Object Relation Mapping）对象关系映射，是把数据库中的关系数据映射成为程序中的对象。

> 2、使用 ORM 的优点：提高了开发效率降低了开发成本、开发更简单更对象化、可移植更强。

*  92、hibernate 有几种查询方式？

> hql、原生 SQL、条件查询 Criteria。

#### MyBatis ####

*  93、MyBatis 中 \#\{\}和 $\{\}的区别是什么？

> \#\{\}是预编译处理，$\{\}是字符替换。在使用 \#\{\}时，MyBatis 会将 SQL 中的 \#\{\}替换成“?”，配合 PreparedStatement 的 set 方法赋值，这样可以有效的防止 SQL 注入，保证程序的运行安全。

*  94、MyBatis 有几种分页方式？

> 逻辑分页和物理分页。  
> 1、逻辑分页：」 使用 MyBatis 自带的 RowBounds 进行分页，它是一次性查询很多数据，然后在数据中再进行检索。  
> 2、物理分页：」 自己手写 SQL 分页或使用分页插件 PageHelper，去数据库查询指定条数的分页数据的形式。

*  95、MyBatis 是否支持延迟加载？延迟加载的原理是什么？

> 1、MyBatis 支持延迟加载，设置 lazyLoadingEnabled=true 即可

> 2、延迟加载的原理的是调用的时候触发加载，而不是在初始化的时候就加载信息。比如调用 a. getB(). getName()，这个时候发现 a. getB() 的值为 null，此时会单独触发事先保存好的关联 B 对象的 SQL，先查询出来 B，然后再调用 a. setB(b)，而这时候再调用 a. getB(). getName() 就有值了，这就是延迟加载的基本原理。

<mapper namespace="cn.ideal.mapper.AccountMapper">
        
        <resultMap id="userAccountMap" type="Account">
            <id property="id" column="id"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
            
            <association property="user" column="uid" javaType="User" select="cn.ideal.mapper.UserMapper.findById"></association>
        </resultMap>
    
        
        <select id="findAll" resultMap="userAccountMap">
            SELECT * FROM account
        </select>
    </mapper>

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="cn.ideal.mapper.UserMapper">
    
        
        <resultMap id="userAccountMap" type="User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="telephone" column="telephone"></result>
            <result property="birthday" column="birthday"></result>
            <result property="gender" column="gender"></result>
            <result property="address" column="address"></result>
            <collection property="accounts" ofType="account">
                <id property="id" column="aid"></id>
                <result property="uid" column="uid"></result>
                <result property="money" column="money"></result>
            </collection>
        </resultMap>
    
        
        <select id="findAll" resultMap="userAccountMap">
           SELECT u.*,a.id as aid,a.uid,a.money FROM user u LEFT OUTER JOIN account a on u.id = a.uid;
        </select>
    
        
        <select id="findById" parameterType="INT" resultType="User">
            select * from user where id = #{
        uid}
        </select>
    
    </mapper>

*  96、说一下 MyBatis 的一级缓存和二级缓存？  
    一级缓存：基于 PerpetualCache 的 HashMap 本地缓存，它的声明周期是和 SQLSession 一致的，有多个 SQLSession 或者分布式的环境中数据库操作，可能会出现脏数据。当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认一级缓存是开启的。  
    二级缓存：也是基于 PerpetualCache 的 HashMap 本地缓存，不同在于其存储作用域为 Mapper 级别的，如果多个SQLSession之间需要共享缓存，则需要使用到二级缓存，并且二级缓存可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现 Serializable 序列化接口(可用来保存对象的状态)。
 *  97、MyBatis 有哪些执行器（Executor）？

> 1、 SimpleExecutor：每执行一次 update 或 select 就开启一个 Statement 对象，用完立刻关闭 Statement 对象；  
> 2、ReuseExecutor：执行 update 或 select，以 SQL 作为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后不关闭 Statement 对象，而是放置于 Map 内供下一次使用。简言之，就是重复使用 Statement 对象；  
> 3、BatchExecutor：执行 update（没有 select，jdbc 批处理不支持 select），将所有 SQL 都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个 Statement 对象，每个 Statement 对象都是 addBatch()完毕后，等待逐一执行 executeBatch()批处理，与 jdbc 批处理相同。

*  98、MyBatis 分页插件的实现原理是什么？

> 使用 MyBatis 提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的 SQL，然后重写 SQL，根据 dialect 方言，添加对应的物理分页语句和物理分页参数。

*  99、在 hibernate 中 getCurrentSession 和 openSession 的区别是什么？

> 1、getCurrentSession 会绑定当前线程，而 openSession 则不会。  
> 2、getCurrentSession 事务是 Spring 控制的，并且不需要手动关闭，而 openSession 需要我们自己手动开启和提交事务。

[1212.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ad1e9ce582e24dcaa8677b3980259af0.png
[collections.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ff8b5fc5ff8d4b16a94783d263b31b43.png
[Maps.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a8b296a4a8f54e6aa38bea724b881ca3.png
[jsp.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7b5100ed27a04d1091b6fbe4e9c90ee6.jpeg
[v2ilate.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/83040d20762642138d677bf3638c8655.png
[resolve.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/05b9f7258ed547a292144bfcd2f34e23.png
[TCP.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/98283fe452e2436db6a8aee7785c4789.png