这一点要看实际情况的

篇幅限制下面就只能给大家展示小册部分内容了。

JDK1.8之前Put方法：

JDK1.8之后Put方法：

HashMap基于哈希表的Map接口实现，是以key-value存储形式存在，即主要用来存放键值对。动态链接和方法出口等信息。HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。

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

21、

1. java.lang.ClassCastException

数据类型转换异常。ThreadPoolExecutor对象有哪些参数 怎么设定核心线程数和最大线程数 拒绝策略有哪些    难度系数：⭐

参数与作用：共7个参数

1. corePoolSize：核心线程数，

在ThreadPoolExecutor中有一个与它相关的配置：allowCoreThreadTimeOut（默认为false），当allowCoreThreadTimeOut为false时，核心线程会一直存活，哪怕是一直空闲着。

在运行时构造任意一个类的对象。方法区常量池引用的对象、常见线程安全的并发容器有哪些    难度系数：⭐

1. CopyOnWriteArrayList、该内存区域是唯一一个java虚拟机规范没有规定任何OOM情况的区域。MySQL、Redis、
2. workQueue：任务队列

常用有三种队列，即SynchronousQueue,LinkedBlockingDeque（无界队列）,ArrayBlockingQueue（有界队列）。

第三:提高线程的可管理性。MySQL、

区别：

1. Integer是int的包装类，int则是java的一种基本数据类型
2. Integer变量必须实例化后才能使用，而int变量不需要
3. Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4. Integer的默认值是null，int的默认值是0

5、

当然虽然增了红黑树作为底层数据结构，结构变得复杂了，但是阈值大于8并且数组长度大于64时，链表转换为红黑树时，效率也变的更高效。ConcurrentHashMap

1. Cookie 是 web 服务器发送给浏览器的一块信息，浏览器会在本地一个文件中给每个 web 服务器存储 cookie。value都可以为null。

   这样做的目的是因为数组比较小，尽量避开红黑树结构，这种情况下变为红黑树结构，反而会降低效率，因为红黑树需要进行左旋，右旋，变色这些操作来保持平衡 。Spring、异常处理和线程恢复等功能都需要依赖这个计数器完成。

5、那线程池的最大线程数可以配置为 cpu 核心数+1 如果是 IO 密集型，主要是进行 IO 操作，执行 IO 操作的时间较长，这是 cpu 出于空闲状态，导致 cpu 的利用率不高，这种情况下可以增加线程池的大小。操作数栈、GET 和POST 的区别    难度系数：⭐

1. GET 请求的数据会附在URL 之后（就是把数据放置在 HTTP 协议头中），以?分割URL 和传输数据，参数之间以&相连，如：login.action?name=zhagnsan&password=123456。
2. finalize：Object类中定义的方法，Java中允许使用finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。什么是 java 序列化，如何实现 java 序列化    难度系数：⭐
   1. 序列化是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。例如，thread.start()。

   22、

   1. 程序计数器：

   内存空间小，字节码解释器工作时通过改变这个计数值可以选取下一条需要执行的字节码指令，分支、

3. 方法区里有一个运行时常量池，用于存放静态编译产生的字面量和符号引用。

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

   实现原理：javac编译器的语法糖，底层是通过Integer.valueOf()和Integer.intValue()方法实现。Redis、通过线程工厂可以对线程的一些属性进行定制。

4. 序 列 化 的 实 现 ： 将 需 要 被 序 列 化 的 类 实 现 Serializable 接 口 ， 该 接 口 没 有 需 要 实 现 的 方 法 ， implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用 ObjectOutputStream 对象的 writeObject(Object obj)方法就可以将参数为 obj 的对象写出(即保存其状态)，要恢复的话则用输入流。
5. 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。并发编程、具体可以参考 treeifyBin方法。线程的状态转换有什么（生命周期）   难度系数：⭐

   

   1. 新建状态(New) ：线程对象被创建后，就进入了新建状态。如果这个线程异常结束，会有另一个取代它，保证顺序执行。

      Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。当用户在应用程序的 Web 页之间跳转时，存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去

   2. Cookie 和session 的不同点

   无论客户端做怎样的设置，session 都能够正常工作。Springboot、而是选择进行数组扩容。UnSafe 类的 objectFieldOffset() 方法是个本地方法，这个方法是用来拿“原值”的内存地址，返回值是 valueOffset；另外，value 是一个 volatile 变量，因此 JVM 总是可以保证任意时刻的任何线程总能拿到该变量的最新值。String能被继承吗 为什么用final修饰    难度系数：⭐

   1. 不能被继承，因为String类有final修饰符，而final修饰的类是不能被继承的。值得一提的是，当初始化时用的工作队列为LinkedBlockingDeque时，这个值将无效。
      1. java.lang.IllegalArgumentException

      方法传递参数错误。

   2. 对于随机访问get和set，ArrayList效率优于LinkedList，因为LinkedList要移动指针。

      补充：将链表转换成红黑树前会判断，即使阈值大于8，但是数组长度小于64，此时并不会将链表变为红黑树。当方法调用时，调用指令将会 检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有monitor（虚拟机规范中用的是管程一词），然后再执行方法，最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。通过重复利用己创建的线程降低线程创建和销毁造成的消耗。JVM内存分哪几个区，每个区的作用是什么    难度系数：⭐⭐

      

      

      java虚拟机主要分为以下几个区

      1. 方法区
         1. 有时候也成为永久代，在该区内很少发生垃圾回收，但是并不代表不发生GC，在这里进行的GC主要是对方法区里的常量池和对类型的卸载
         2. 方法区主要用来存储已被虚拟机加载的类的信息、
            1. 堆

            java堆是所有线程所共享的一块内存，在虚拟机启动时创建，几乎所有的对象实例都在这里创建，因此该区域经常发生垃圾回收操作。线程的创建方式    难度系数：⭐

            1. 继承Thread类创建线程
            2. 实现Runnable接口创建线程
            3. 使用Callable和Future创建线程   有返回值
            4. 使用线程池创建线程

            1. #### 代码演示

            2. import java.util.concurrent.*;

            3. public class threadTest{

            4.     public static void main(String[] args) throws ExecutionException, InterruptedException {

            5.         //继承thread

            6.         ThreadClass thread = new ThreadClass();

            7.         thread.start();

            8.         Thread.sleep(100);

            9.         System.out.println("#####################");

            11.         //实现runnable

            12.         RunnableClass runnable = new RunnableClass();

            13.         new Thread(runnable).start();

            14.         Thread.sleep(100);

            15.         System.out.println("#####################");

            17.         //实现callable

            18.         FutureTask futureTask = new FutureTask(new CallableClass());

            19.         futureTask.run();

            20.         System.out.println("callable返回值：" + futureTask.get());

            21.         Thread.sleep(100);

            22.         System.out.println("#####################");

            24.         //线程池

            25.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 2, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));

            26.         threadPoolExecutor.execute(thread);

            27.         threadPoolExecutor.shutdown();

            28.         Thread.sleep(100);

            29.         System.out.println("#####################");

            31.         //使用并发包Executors

            32.         ExecutorService executorService = Executors.newFixedThreadPool(5);

            33.         executorService.execute(thread);

            34.         executorService.shutdown();

            35.    }

            36. }

            38. class ThreadClass extends Thread{

            39.     @Override

            40.     public void run() {

            41.         System.out.println("我是继承thread形式：" + Thread.currentThread().getName());

            42.    }

            43. }

            45. class RunnableClass implements Runnable{

            46.     @Override

            47.     public void run(){

            48.         System.out.println("我是实现runnable接口：" + Thread.currentThread().getName());

            49.    }

            50. }

            52. class CallableClass  implements Callable<String> {

            53.     @Override

            54.     public String call(){

            55.         System.out.println("我是实现callable接口：");

            56.         return "我是返回值，可以通过get方法获取";

            57.    }

            58. }

            Java

            17、

            1. 装箱：将基本类型转换成包装类对象
            2. 拆箱：将包装类对象转换成基本类型的值

            java为什么要引入自动装箱和拆箱的功能？主要是用于java集合中，List<Inteter> list=new ArrayList<Integer>();

            list集合如果要放整数的话，只能放对象，不能放基本类型，因此需要将整数自动装箱成对象。Spring、Linux、Linux、

            如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。

      2. 虚拟机栈
         1. 虚拟机栈也就是我们平常所称的栈内存,它为java方法服务，每个方法在执行的时候都会创建一个栈帧，用于存储局部变量表、当客户端禁用 cookie 时将无法使用 cookie

            在存储的数据量方面：session 能够存储任意的java 对象，cookie 只能存储 String 类型的对象

            第二章-Java高级篇

            1、当任务到达时，任务可以不需要的等到线程创建就能立即执行。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。

         2. 在java中可以作为GC Roots的对象有以下几种：虚拟机栈中引用的对象、刷新次数多的新生区
            1. 标记-清除  老年代一般是由标记清除或者是标记清除与标记整理的混合实现

            a) 效率比较低，会差生碎片。FireFox 等，理论上没有长度限制，其限制取决于操作系统的支持。

            1. newSingleThreadExecutor

            创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。SpringCloud、而实际上，URL 不存在参数上限的问题，HTTP 协议规范没有对 URL 长度进行限制。接口：只能是public

         3. 抽象类：可以有成员变量；接口：只能声明常量

         2、常量、final、

      3. 在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全而StringBuffer则每次都需要判断锁，效率相对更低

      篇幅限制下面就只能给大家展示小册部分内容了。阻塞的情况分三种：

      1. 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。MQ、深拷贝与浅拷贝的理解    难度系数：⭐

         深拷贝和浅拷贝就是指对象的拷贝，一个对象中存在两种类型的属性，一种是基本数据类型，一种是实例对象的引用。例如延迟3秒执行。containsKey和containsValue三个方法，其中contains和containsValue方法功能相同。HashMap底层源码    难度系数：⭐⭐⭐

         HashMap的底层结构在jdk1.7中由数组+链表实现，在jdk1.8中由数组+链表+红黑树实现，以数组+链表的结构为例。

      2. 该区域是被线程共享的。HashMap 的实现不是同步的，这意味着它不是线程安全的。
         1. unit：keepAliveTime的单位。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。当sleep()状态超时、MyBatis、JVM、
         2. Lock大量使用CAS+自旋。MQ、join(）等待线程终止或者超时、
         3. void notifyAll()--->唤醒在此对象监视器上等待的所有线程。所以综上所述为了提高性能和减少搜索时间，底层在阈值大于8并且数组长度大于64时，链表才转换为红黑树。Kafka 面试专题

            (笔记渠道/点击)

      18、此外，HashMap中的映射不是有序的。Spring、单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

   3. synchronize对线程的同步仅提供独占模式，而Lock即可以提供独占模式，也可以提供共享模式

   synchronized	Lock
   关键字	类
   自动加锁和释放锁	需要手动调用unlock方法释放锁
   jvm层面的锁	API层面的锁
   非公平锁	可以选择公平或者非公平锁
   锁是一个对象,并且锁的信息保存在了对象中	代码中通过int类型的state标识
   有一个锁升级的过程	无

    篇幅限制下面就只能给大家展示小册部分内容了。其实这样说是错误的，不准确的：“GET 方式提交的数据最多只能是 1024 字节"，因为 GET 是通过 URL 提交数据，那么 GET 可提交的数据量就跟URL 的长度有直接关系了。Redis、

   第一章-Java基础篇

   1、微服务、上面“安全”的含义仅仅是不作数据修改，而这里安全的含义是真正的 Security 的含义，比如：通过 GET 提交数据，用户名和密码将明文出现在 URL 上，因为(1)登录页面有可能被浏览器缓存，(2)其他人查看浏览器的历史纪录，那么别人就可以拿到你的账号和密码了，除此之外，使用 GET 提交数据还可能会造成 Cross-site request forgery 攻击。

6. 阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。

   第二:提高响应速度。整理了一份核心面试笔记包括了：Java面试、sleep和wait区别    难度系数：⭐

   1. sleep方法

   属于Thread类中的方法

   释放cpu给其它线程 不释放锁资源

   sleep(1000) 等待超过1s被唤醒

   1. wait方法

   属于Object类中的方法

   释放cpu给其它线程，同时释放锁资源

   wait(1000) 等待超过1s被唤醒

   wait() 一直等待需要通过notify或者notifyAll进行唤醒

   wait 方法必须配合 synchronized 一起使用，不然在运行时就会抛出IllegalMonitorStateException异常

   1. #### 锁释放时机代码演示

   2. public static void main(String[] args) {

   3.     Object o = new Object();

   4.     Thread thread = new Thread(() -> {

   5.         synchronized (o) {

   6.             System.out.println("新线程获取锁时间：" + LocalDateTime.now() + " 新线程名称：" + Thread.currentThread().getName());

   7.             try {

   9.                 //wait 释放cpu同时释放锁

   10.                 o.wait(2000);

   12.                 //sleep 释放cpu不释放锁

   13.                 //Thread.sleep(2000);

   14.                 System.out.println("新线程获取释放锁锁时间：" + LocalDateTime.now() + " 新线程名称：" + Thread.currentThread().getName());

   15.            } catch (InterruptedException e) {

   16.                 throw new RuntimeException(e);

   17.            }

   18.         }

   19.     });

   21.     thread.start();

   23.     try {

   24.         Thread.sleep(100);

   25.    } catch (InterruptedException e) {

   26.         throw new RuntimeException(e);

   27.    }

   29.     System.out.println("主线程获取锁时间：" + LocalDateTime.now() + " 主线程名称：" + Thread.currentThread().getName());

   31.     synchronized (o){

   32.         System.out.println("主线程获取释放锁锁时间：" + LocalDateTime.now() + " 主线程名称：" + Thread.currentThread().getName());

   33.    }

   34. }

   Java

   4、

   1. 是否提供contains方法

   HashMap只有containsValue和containsKey方法；HashTable有contains、线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进 行统一的分配，调优和监控

   8、对于任意一个对象，可以调用它的任意一个方法。protected和default这些修饰符、Springboot、

7. 运行状态(Running)：线程获取CPU权限进行执行。Atomic原子类了解多少 原理是什么    难度系数：⭐

   Java 的原子类都存放在并发包 java.util.concurrent.atomic下，如下图：

   

   基本类型

   • 使用原子的方式更新基本类型
   • AtomicInteger：整型原子类
   • AtomicLong：长整型原子类
   • AtomicBoolean：布尔型原子类

   数组类型

   • 使用原子的方式更新数组里的某个元素
   • AtomicIntegerArray：整形数组原子类
   • AtomicLongArray：长整形数组原子类
   • AtomicReferenceArray：引用类型数组原子类

   引用类型

   • AtomicReference：引用类型原子类
   • AtomicStampedReference：原子更新引用类型里的字段原子类
   • AtomicMarkableReference ：原子更新带有标记位的引用类型
   • AtomicIntegerFieldUpdater：原子更新整形字段的更新器
   • AtomicLongFieldUpdater：原子更新长整形字段的更新器
   • AtomicStampedReference：原子更新带有版本号的引用类型。MyBatis、这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。默认是抛出一个运行时异常。Object中有哪些方法    难度系数：⭐
     1. protected Object clone()--->创建并返回此对象的一个副本。
              void wait(long timeout, int nanos)--->导致当前的线程等待，直到其他线程调用此对象的 notify()

     10、变量和方法。因此根据CAS特性，lock建议使用在低锁冲突的情况下。

 篇幅限制下面就只能给大家展示小册部分内容了。MQ、线程池底层工作原理    难度系数：⭐

1. 第一步：线程池刚创建的时候，里面没有任何线程，等到有任务过来的时候才会创建线程。
   1. keepAliveTime：存活时间，

   当非核心空闲超过这个时间将被回收，同时空闲核心线程是否回收受allowCoreThreadTimeOut影响。MyBatis、

   代码块的同步是利用monitorenter和monitorexit这两个字节码指令。修饰类时，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。或者I/O处理完毕时，线程重新转入就绪状态。以后浏览器再给特定的 web 服务器发送请求时，同时会发送所有为该服务器存储的 cookie

2. Session 是存储在 web 服务器端的一块信息。
   1. Java 反射机制提供功能

   在运行时判断任意一个对象所属的类。session 对象存储特定用户会话所需的属性及配置信息。