面试笔记-9.Java常用类库与技巧

电玩女神 2022-11-08 11:24 122阅读 0赞

一  
**1.error和exception的区别**

> 图：error和exception的区别.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70]

**3.Error和Exception包含的类**

> 图：Error和Exception分类.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 1]

**2.RuntimeException和非RuntimeException的异常和Error的异常**

> 图：RuntimeException-非RuntimeException-Error常用异常类.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 2]

**3.java异常处理原则**

> 图：java异常处理原则.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 3]

**4.如何设计高效主流异常处理框架**

> 图：如何设计高效主流异常处理框架.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 4]  
> 图：图示.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 5]

**5.java异常处理的缺点**

> 图：java异常处理的缺点.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 6]

**6.数据结构面试考点**

> 图：数据结构面试考点.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 7]

1.数组和链表

> 图：java数组和链表数据结构区别.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 8]

**1.数组的特点**

> 1)在内存中，数组是一块连续的区域。但是长度必须先申请，申请后是固定的不能改变，可能会浪费内存空间。  
> 2)可以存储基本类型，也可以存储引用类型，但一个数组存储的元素类型必须一直。  
> 3)插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中都要向后移。删除数据时，这个数据后面的数据都要往前移动。  
> 4)读取效率很高，元素通过数组的下标进行访问的，下标从0开始。按照索引查询元素速度快，按照索引遍历数组方便。  
> 5)不利于扩展，数组定义的空间不够时要重新定义数组。

2.优缺点

> 1.优点  
> \-------1)随机访问性强，按照索引查询元素速度快，遍历元素方便

> 2.缺点  
> \-------1)插入和删除效率低，因为要移动其他的元素。  
> \-------2)数组只能存储一种类型的数据  
> \-------3)内存空间要求高，必须有足够的连续内存空间。  
> \-------4）数组大小固定，用不完不能删除，可能浪费内存，不够使也不能动态拓展。

3.使用场景

> 频繁查询，对存储空间要求不大，很少增加和删除的情况

**2.链表的特点**

> 1)通过一个链子把多个结点（元素）连接起来，由数据和地址组成的一个元素，每一个数据都保存了下一个数据的内存地址，通过这个地址找到下一个数据，单个元素在内存中可以存在任何地方，不要求连续。

> 2)不指定大小，扩展方便。链表大小不用定义，数据随意增删。

> 3)增加数据和删除数据很快。只需要改变前后两个元素结点的指针域指向地址即可。

> 4）查找数据时效率低，因为不具有随机访问性，所以访问某个位置的数据都要从第一个数据开始访问，然后根据第一个数据保存的下一个数据的地址找到第二个数据

> 5）分类：  
> \-------1.单向链表：结构：\[数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[数据+null\]  
> \-------单向循环列表：结构：\[数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[数据+指向开头元素位置的指针或地址值\]  
> \-------2.双向列表：结构：\[null+数据+指向下一个元素位置的指针或地址值\]——>\[指向上一个元素位置的指针或地址值+数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[指向上一个元素位置的指针或地址值+数据+null\]  
> \-------双向循环列表：结构：\[指向最后一个元素位置的指针或地址值+数据+指向下一个元素位置的指针或地址值\]——>\[指向上一个元素位置的指针或地址值+数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[指向上一个元素位置的指针或地址值+数据+指向第一个元素位置的指针或地址值\]

2.优缺点

> 1.优点  
> \-------1)插入删除速度快  
> \-------2)大小没有固定，拓展很灵活。  
> \-------3)不需要初始化容量

> 2.缺点  
> \-------1)不能随机查找，必须从第一个开始遍历，查找效率低

> 3.使用场景：数据量较小，需要频繁增加，删除操作的场景

**2.链表**  
1.分类：

> 1.单向链表：结构：\[数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[数据+null\]

> 单向循环列表：结构：\[数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[数据+指向开头元素位置的指针或地址值\]

> 2.双向列表：结构：\[null+数据+指向下一个元素位置的指针或地址值\]——>\[指向上一个元素位置的指针或地址值+数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[指向上一个元素位置的指针或地址值+数据+null\]

> 双向循环列表：结构：\[指向最后一个元素位置的指针或地址值+数据+指向下一个元素位置的指针或地址值\]——>\[指向上一个元素位置的指针或地址值+数据+指向下一个元素位置的指针或地址值\]——>…\[\]…——>\[指向上一个元素位置的指针或地址值+数据+指向第一个元素位置的指针或地址值\]

2.操作：

> 1.链表反转  
> \-------1.递归遍历法：[看此文章][Link 1]

> 2.列队和栈的区别  
> 列队：先进先出（队尾进，队头出）  
> 栈：先进后出(栈顶进，栈顶出)，进栈为压栈，删除为出栈

> 3.二叉树的遍历，递归和非递归方式

> 4.红黑树的旋转

**7.算法考点**

> 图：算法考点.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 9]

**8.算法和数据结构推荐学习:图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 10]

**9.java集合**

> 图：java集合框架图.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 11]  
> [java集合总结][java]

**1.Collection接口**

1.List接口

> 元素有序，可重复，支持随机访问，可以通过元素的序号快速获取元素对象。

> 1.线程不安全：  
> \-------1.ArrayList类：容量动态扩张的Object\[\]实现，初始化为0，第一次add时为10，每次扩容为以前的1.5倍，最大容量Integer.MAX\_VALUE - 8。适合查询，不适合增删改。可重复，可插入null  
> \-------2.LinkedList类：双向链表数据结构。适合增删改，不适合查询。可重复，可插入null

> 2.线程安全的类：  
> \-------CopyOnWriteArrayList：容量动态扩张的Object\[\]实现，被volatile修饰，写时复制集合，又称读写分离集合。写时会复制集合的副本，在副本进行写操作，写完将副本的引用更新到原集合的引用。读写分离，读时不会受到写的影响，但也看不到写的内容。写的代码部分都是用了ReentrantLock锁。可重复，可插入null  
> \-------Vector：容量动态扩张的Object\[\]实现，继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口。其大部分方法都用Synchronize关键字修饰，可重复，可插入null

2.Set接口

> 元素不可重复，添加相同元素时第二次添加操作不会被执行

> 1.线程不安全：  
> \-------1.EnumSet：内部以位向量的形式存储数据，存储枚举类元素的专用集合类，非常紧凑、高效，占用内存很小，而且运行效率很好，批量操作的执行速度也非常快。有序，以枚举值在Enum类内的定义顺序来决定集合元素的顺序。不可重复，不可插入null和非枚举  
> \-------2.TreeSet：内部通过TreeMap的key来存储元素，把元素存储在map的key里，有序，默认使用自然排序，只在添加是排序，修改不排序。插入null会空指针。不可重复，不可插入null；  
> \-------3.HashSet：内部通过HashMap的key来存储元素，所有的value都指向的同一个Object对象，根据hashCode的计算决定存储位置，无序。可插入null，不可重复。  
> \-------4.LinkedHashSet：使用LinkedHashMap的键来储元素，保证元素按照插入顺序存储。HashSet的子类。  
> 5.NavigableSet：

> 2.线程安全：  
> \-------1.ConcurrentSkipListSet：  
> \-------2.CopyOnWriteArraySet：基本同CopyOnWriteArrayList，只是数据不能重复。

3.Queue接口

> [看此文章][Link 2]

**2.Map接口**  
1.线程不安全：

> 1.HashMap：数组+单向链表or平衡树(java8)存储结构。如没有hash冲突就是数组结构，有的话就要是链表or平衡树(单向链表长度>=8转红黑树)。根据HashCode计算出数据位置。 初始容量为16，每次扩容为原来容量的2倍。可插入null(k,v都行),k不能重复，v能重复  
> \-------hash碰撞：多个key值不同，但是计算出的hash相同，会发生hash碰撞。  
> \-------hash碰撞攻击：通过精心构造数据，使得所有数据全部碰撞，此时存储需要消耗大量CPU资源，导致系统无法快速响应请求。  
> \-------负载因子loadFactor:每次添加数据时判断数据个数是否大于现在的容量\*负载因子=threshold，是就扩容  
> 2.TreeMap：基于红黑树（Red-Black tree）的 NavigableMap实现，可自定义排序规则，默认自然排序，k不可为null，否则空指针，不能重复，v可空可重复。  
> 3.LinkedHashMap：基于HashMap存储结构实现，HashMap的子类。不同在于HashMap使用的是单向链表，而它用的双向链表。默认插入顺序排序。可改为访问顺序(访问次数最多的元素排在最后)(10,0.75F, true)改为按访问顺序的参数。k可为null，不可重复。v可重复可为null

2.线程安全

> 1.ConcurrentHashMap：存储结构和HashMap一样，k，v都不能为null。  
> \-------jdk1.7  
> 采用锁分段技术实现线程安全，将数据划分到多个Segment中，操作哪个Segment就锁住哪个Segment，一个Segment被锁不会影响到其他Segment操作  
> \-------jdk1.8  
> 采用了 CAS + synchronized 来保证并发的安全性。  
> 2.HashTable：在修改方法上添加synchronized关键字进行同步，粒度太大，性能不佳。其他同HashMap。  
> 3.ConcurrentSkipListMap：实现了ConcurrentNavigableMap接口，有序且线程安全的类，采用cas算法保证线程安全。k，v都不能null

**9.集合之list和set：图**

> 图：集合之list和set.png  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 12]  
> [看此文章][java]

二  
**1.ArrayList**

> [看此文章Tiglle][Tiglle]

**2.LinkedList**

> [看此文章Tiglle][Tiglle 1]

**3.HashMap**

> [看此文章Tiglle][Tiglle 2]

**4.HashSet**

> [看此文章][Link 3]

**5.HashMap如何减少碰撞**：图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 13]

**2.HashMap，HashTable，ConccurentHashMap的区别**

> 1.HashMap:线程不安全  
> 2.HashTable:在HashMap的基础上实现了粗粒度的线程安全(Synchrozed)  
> 3.ConccurentHashMap在HashMap基础上实现细粒度的线程安全(CAS + synchronized)

三  
**1.同步器**

> CountDownLatch  
> 这个类能够使一个线程等待其他线程完成各自的工作后再执行。  
> CountDownLatch cnt=new CountDownLatch(3);指定执行数量，直到其他线程将执行数量变为0时，等待线程执行任务。其他线程和等待线程使用的是同一个CountDownLatch实例  
> 1.await()方法：一直等待，直到指定线程执行完成  
> 2.countDown()方法：执行完成的线程调用countDown()告诉等待线程自己执行完成，等待数量减1

**2.BlockingQueue**

> 阻塞列队：负责生产的线程不断的制造新对象并插入到阻塞队列中，直到达到这个队列的上限值。队列达到上限值之后生产线程将会被阻塞，直到消费的线程对这个队列进行消费。同理，负责消费的线程不断的从队列中消费对象，直到这个队列为空，当队列为空时，消费线程将会被阻塞，除非队列中有新的对象被插入。

**4.同步，异步，阻塞，非阻塞，同步阻塞，同步非阻塞，异步阻塞，异步非阻塞**

> 1.同步：多个任务线性执行

> 2.异步：多个任务可以并发执行

> 3.阻塞：一个任务执行时遇到等到调用结果，或者IO读写时，一直等待，cpu是空闲的

> 4.非阻塞：一个任务执行时遇到等到调用结果，或者IO读写时，可以继续往下执行，过会在回来获取调用和IO结果

四  
**1.BIO,NIO,AIO**

> 同步阻塞的BIO(Blocking IO)：如果读取数据，代码会阻塞直至有 可供读取的数据。同样，写入调用将会阻塞直至数据能够写入。

> 同步非阻塞的NIO(New IO)：[看此文章][Link 4]

> 异步非阻塞的AIO(AsynchronousIO)：[看此文章][Link 5]

**2.java移位运算符**

> 1.<<:左移运算符  
> 左移位数大于等于32位操作时，左移的值会变成n%32后的值。高位多出去掉，低位少的补0  
> 例：<<n,左移n位，

> 2.>>:右移运算符  
> 右移位数大于等于32位操作时，右移的值会变成n%32后的值。低位多出去掉，高位少的补符号(正数为0，复数为1)

> 3.>>>无符号右移运算符  
> 同右移运算符，只不过高位少的补0

**4.位操作符**

> 1.与( & )：将两个数转换为32位2进制进行比较，如果都是1，结果为1，否则为0  
> 2.或( | )：将两个数转换为32位2进制进行比较，有一个是1，结果为1，否则为0  
> 3.异或( ^ )：将两个数转换为32位2进制进行比较，不同则结果为1，相同为0  
> 5.非( ~ ) ：将1个数转换为32位2进制，1变为0,0变为1

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70]: /images/20221023/20507467aae5435f9bf9763d6ab89e11.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 1]: /images/20221023/69fcb7c5ed58423d9c586733ba220137.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 2]: /images/20221023/7abcd16f010540e497bd4552959dbf78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 3]: /images/20221023/45f4d28cad6f49fd91665315f6324e33.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 4]: /images/20221023/06798349dbe240b693a70383063933a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 5]: /images/20221023/a2127bd6dd024a07828762f1798f7566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 6]: /images/20221023/3e06ee6cae244a2a9ae45947b134cea7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 7]: /images/20221023/ed5f6809949146baaf1f8328cb6cd315.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 8]: /images/20221023/c0a5544812744f3e8ab0f325b500ef80.png
[Link 1]: https://blog.csdn.net/Tiglle/article/details/114324232
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 9]: /images/20221023/b01353970f0e4e08bbae93f9bb994cf9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 10]: /images/20221023/8b4de80630314670a399af89d3ba8563.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 11]: /images/20221023/709f30b1fac741e4a77c380120591471.png
[java]: https://www.cnblogs.com/henuliulei/p/13974877.html
[Link 2]: https://www.cnblogs.com/haimishasha/p/10808906.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 12]: /images/20221023/c3ffd1685ef84d2b81feb237f0823f15.png
[Tiglle]: https://blog.csdn.net/Tiglle/article/details/114401570
[Tiglle 1]: https://blog.csdn.net/Tiglle/article/details/114456481
[Tiglle 2]: https://blog.csdn.net/Tiglle/article/details/114520068
[Link 3]: https://zhuanlan.zhihu.com/p/29021276
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpZ2xsZQ_size_16_color_FFFFFF_t_70 13]: /images/20221023/efc30c600a51436b840bd468d0b6e62b.png
[Link 4]: https://www.zhihu.com/question/342093305
[Link 5]: https://blog.csdn.net/moakun/article/details/81042877