项目面试题汇总

# 目录介绍

1.Java面试题汇总
2.C语言面试题汇总
3.C++编程面试题
4.JavaScript面试题
5.设计模式面试题
6.数据结构和算法
7.网络编程面试题
8.Android面试题
9.iOS面试题汇总

# 1.Java面试题汇总

# 1.1 基础问题汇总

String类：说下String与StringBuffer区别，底部如何实现？String类可以被继承吗，为什么？String为什么要设计成不可变的？
基本数据：int、char、long各占多少字节数？比如double强转int类型会造成精度损失，为什么？int,long的取值范围以及BigDecimal，数值越界了如何处理？
拆箱和装箱：介绍一下拆箱和装箱的问题。为什么要这样操作？Integer 对象缓存机制是什么？int 和 Integer 哪个会占用更多的内存？
char字符：char 型变量中能不能存贮一个中文汉字，为什么？char是两个字节，是怎么存Utf-8的字符的？
Byte字节：将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围，将会出现什么现象？
泛型：什么是泛型，应用场景，如何获取泛型的真实参数类型？如何理解泛型通配符？如何理解泛型擦除这个概念？Java中List<？>和List
整型和字面值：整型数据和字面值有何区别？为何要有字面值？说下装箱和拆箱操作，int和integer分别存储在哪里，valueOf用到什么设计模式，怎么理解缓存池的概念
二进制：浮点型在二进制中如何表示，为何会出现精度丢失，从存储角度分析一下。如何对比浮点型数据是否是相同的？

# 1.2 面向对象问题

面向对象：面向对象有哪些特征？继承，封装，多态，可以随意抽一个问细节？接口和抽象类有什么区别？
封装：什么是封装？访问权限修饰符的作用是什么？举一个钱包的封装案例，说一下封装的作用？
继承：继承（Inheritance）与聚合（Aggregation）的区别在哪里？为什么类只能单继承，接口可以多继承？
多态：Java实现多态有哪些必要条件？具体怎么实现？多态的实现原理？多态的作用？
重载与重写：重载（overloading）与重写（override）的区别？重载的方法能否根据返回类型进行区分？继承最大好处？构造器 Constructor 是否可被 Override？
构造函数：什么是构造函数？什么是构造函数重载？什么是复制构造函数？为何要有构造函数？
案例题：如果类 a 继承类 b，实现接口c，而类 b 和接口 c 中定义了同名变量，请问会出现什么问题？
拷贝：如何实现对象克隆？深拷贝和浅拷贝区别？深拷贝和浅拷贝如何实现激活机制？
抽象类和接口：接口和抽象类有什么区别？为什么要这样设计？什么场景选择接口，什么场景选择抽象类？
静态：静态属性和静态方法是否可以被继承？是否可以被重写？以及原因？静态内部类的设计意图？静态块有什么好处？静态块和构造方法哪一个先执行？
内部类：内部类分为几种？内部类可以引用它的包含类（外部类）的成员吗？ Java 中为什么要引入内部类，还有匿名内部类？匿名内部类是否可以继承其它类，是否可以实现接口？
值传递和引用传递：当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？
final：为什么内部类调用的外部变量必须是final修饰的？final的作用是什么，被final修饰的类，可以改变类里面的属性吗？ final, finally, finalize 的区别？

# 1.3 集合框架问题

集合体系：Java 集合类框架的基本接口有哪些？Collection 和 Collections 有什么区别？List、Set、Map 之间的区别？为什么 Map 不继承 Collection？
ArrayList：ArrayList 底层数据结构是什么？初始容量和扩容机制？为什么扩容是 1.5 倍？ArrayList 与 Vector 有什么区别？
LinkedList：LinkedList 底层结构？双向链表和 ArrayList 在增删查改性能上各有什么差异？LinkedList 可以当作队列和栈使用吗？
HashMap：HashMap 底层实现原理？JDK7 和 JDK8 的 HashMap 区别？为什么链表长度超过 8 转红黑树？为什么阈值是 8 和 6？
HashMap 扩容：HashMap 的 put 流程？扩容的触发条件和具体过程？为什么容量一定是 2 的幂？为什么加载因子是 0.75？
HashMap 并发：HashMap 在多线程下有哪些问题？JDK7 为什么会出现死循环？JDK8 还会出现吗？为什么？
ConcurrentHashMap：如何保证线程安全？JDK7 分段锁和 JDK8 CAS+synchronized 的区别？size() 是怎么计算的？
HashSet：HashSet 底层如何实现？它如何保证元素不重复？TreeSet 与 HashSet 的区别是什么？
LinkedHashMap：LinkedHashMap 与 HashMap 区别是什么？如何用 LinkedHashMap 实现一个 LRU 缓存？
TreeMap：TreeMap 底层是什么数据结构？红黑树和 AVL 树的区别？为什么用红黑树？
集合对比：ArrayList 和 LinkedList 的区别？HashMap 和 HashTable 的区别？HashMap 和 TreeMap 的区别？
快速失败：Iterator 的 fail-fast 和 fail-safe 是什么意思？哪些集合是 fail-fast 的？哪些是 fail-safe 的？

# 1.4 IO流知识问题

Byte字节：什么是比特(Bit)，什么是字节(Byte)，什么是字符(Char)，它们长度是多少，各有什么区别？
File：File类型中定义了什么方法来创建一级目录？File类型中定义了什么方法来判断一个文件是否存在？如何判断目录的存在？
IO流：对文本文件操作用什么I/O流？对各种基本数据类型和String类型的读写，采用什么流？为了提高读写性能，可以采用什么流？
缓冲Buffer：直接缓冲区与非直接缓冲器有什么区别？怎么读写 ByteBuffer？ByteBuffer 中的字节序是什么
案例：当用System.in.read(buffer)从键盘输入一行n个字符后，存储在缓冲区buffer中的字节数是多少？
流关闭：流一般需要不需要关闭，如果关闭的话在用什么方法，一般要在那个代码块里面关闭比较好，处理流是怎么关闭的，如果有多个流互相调用传入是怎么关闭的？
IO分类：什么是同步IO？什么是异步IO？什么是阻塞IO？什么是非阻塞IO？

# 1.5 异常处理问题

异常体系：为什么要设置异常？Error和Exception有何区别？说一下它们各自的特点，可以举例场景来说明？
异常关键字：Java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别如何使用？
异常分类：什么是受检查的异常，什么是运行时异常？运行时异常与一般异常有何异同？简述一个你最常见到的runtime exception(运行时异常)？
finally：如果执行finally代码块之前方法返回了结果，或者JVM退出了，finally块中的代码还会执行吗？在什么情况下，finally语句不会执行？
try代码块：try里有return，finally还执行么？那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return前还是后？
catch：一旦某个catch捕获到匹配的异常类，其它的catch还会执行吗？catch异常匹配是如何执行？
异常：Exception和Error有什么区别？运行时异常与一般异常有什么区别？不要生吞异常？
异常捕获：try {}里有一个 return 语句，那么紧跟在这个 try 后的 finally {}里的code会不会被执行，什么时候被执行，在 return 前还是后?
异常性能：try..catch..到底影响性能吗？从jvm层面分析下。在try-catch中for循环和在for循环中try-catch有何区别，性能损耗如何？

# 1.6 线程知识问题

线程生命周期：线程中start和run方法有什么区别？wait和sleep方法的不同？sleep() 、join（）、yield（）有什么区别？请绘制线程周期图……
死锁案例：用Java手写一个会导致死锁的程序，遇到这种问题解决方案是什么？那些场景用到了死锁机制？
线程dump：你将如何使用thread dump？你将如何分析Thread dump？
线程stop：Java 中如何停止一个线程？stop() 和 suspend() 方法为何不推荐使用？如何让正在运行的线程暂停一段时间？
线程start：调用start()方法时会执行run()方法，为什么不能直接调用run()方法？你是如何调用 wait（方法的）？使用 if 块还是循环？为什么
生产者消费者：说说生产者-消费者场景，如何保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区空时消耗数据？
ThreadLocal：ThreadLocal作用是什么，平常怎么用它，线程为何需要这个东西，里面的副本是怎么拷贝的？
线程异常：线程中异常为何不能抛出到外部线程捕获？如何处理线程异常？
线程等待：wait()和sleep()的区别？各自有哪些使用场景？怎么唤醒一个阻塞的线程？Thread.sleep(0)的作用是啥？

# 1.7 并发知识问题

多线程：多线程为何会有bug？为什么会产生这种问题，又是如何解决的？
volatile：volatile这个关键字是怎么理解的？在并发环境中如何确保程序的可见性、顺序性和一致性？
Synchronized：谈谈对Synchronized关键字，类锁，方法锁，重入锁的理解？有哪些使用场景？说一下锁如何升级和降级。
锁比较：Lock锁比synchronized块的优势是什么？各自用途是什么？有哪些不同点？
锁概念：公平锁/非公平锁如何理解？乐观锁/悲观锁如何理解？偏向锁/轻量级锁/重量级锁是如何理解？互斥锁/读写锁如何理解？
多线程规则：如何理解同步，异步，阻塞，非阻塞的概念。如何实现异步线程串列执行？
死锁：活锁和死锁有什么区别？什么是死锁(Deadlock)？导致线程死锁的原因？如何确保 N 个线程可以访问 N 个资源同时又不导致死锁？
CAS乐观锁：什么是乐观锁？如何实现乐观锁？如何避免ABA问题？CAS乐观锁是如何实现的？CAS的问题有哪些？
读写锁：设计一个多线程，可以同时读，读的时候不能写，写的时候不能读(读写锁)。两个进程同时要求写或者读，能不能实现？
线程优先级：Java中用到的线程调度算法是什么？你对线程优先级的理解是什么？什么是线程调度器 (Thread Scheduler) 和时间分片 (Time Slicing)？
线程安全：谈谈你对多线程同步机制的理解？如何保证多线程读写文件的安全，有哪些方式可以做到？
并发请求：如何控制某个方法允许并发访问线程的个数？多个线程如何同时请求，返回的结果如何等待所有线程数据完成后合成一个数据？
案例题：你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
案例题：假如有一个第三方接口，有很多个线程去调用获取数据，现在规定每秒钟最多有 10 个线程同时调用它，如何做到？
案例题：现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
案例题：一个int变量，用volatile修饰，多线程去操作++，线程安全吗？那如何才能保证i++线程安全？不用锁如何保证int自增安全？

# 1.8 类的加载问题

类加载：Person p = new Person()请写一下类的加载过程？在加载过程分别对Person类中的常量，变量，构造方法，成员方法做了什么处理？
内存分配：如何理解栈，堆，本地方法区……？堆内存设置的参数是什么？JVM中哪个参数是用来控制线程的栈堆栈小？
双亲委派：什么是双亲委派模型？为什么使用双亲委托模型？说一下ClassLoader中loadClass方法实现了双亲委派模型的思路？
类加载器：JAVA类加载器包括几种，作用是什么？它们之间的父子关系是怎么样的？如何自定义一个类加载器(那些场景会这样)？
类加载器：ClassLoader原理是什么？类加载器工作机制是什么？loadClass(String name, boolean resolve)第二个参数意义是什么？
类初始化：什么时候发生类初始化？遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，会做些什么？
类初始化：构造器的设计？成员初始化顺序？类名.变量和new对象初始化有何区别，分别是什么情况？
对象：说下对象的内存布局？对象头里面属性有哪些？如何访问对象？对象销毁是如何判断的？
异常：StackOverFlow异常有没有遇到过？一般你猜测会在什么情况下被触发？如何指定一个线程的堆栈大小？一般你们写多少？
工作内存：工作内存和主内存的关系？它们的作用分别是什么？说一下每个线程工作内存的设计原理？简述重排序，内存屏障，happen-before。
内存：说一下创建对象后，对象的内存布局，平常用到的锁，在内存对象布局哪里，怎么去判断对象中某个方法是否有锁
GC机制：垃圾回收机制的原理是什么？如果对象的引用被置为null，垃圾收集器是否会立即释放对象占用的内存？
GC机制：请从四大引用这块说一下GC的回收策略？引用计数法的思路是什么？引用计数法两个对象互相引用如何解决？
垃圾回收：什么情况下触发垃圾回收？如何选择合适的垃圾收集算法？JVM中最大堆大小有没有限制？吞吐量优先选择什么垃圾回收器？响应时间优先呢？
JVM内存分哪几个区，每个区的作用是什么？一个对象从创建到销毁都是怎么在这些部分里存活和转移的？
JVM自身会维护缓存吗？是不是在堆中进行对象分配，操作系统的堆还是JVM自己管理堆？什么情况下会发生栈内存溢出？
四种引用：为何需要四种引用？说一下四中引用的区别和使用场景，什么情况下会导致应用内存空间不足？弱引用和软引用有什么区别？引用队列如何理解？
强引用：如何回收强引用？强引用有何特点？将对象引用赋值为null有何意义？将引用设置成null后jvm什么时候回收对象呢？
软引用：软引用的使用场景？如何判断内存空间是否足够？可能被回收，Jvm是如何处理软引用队列的回收逻辑？注意点有什么？
弱引用：弱引用有何特点？垃圾回收器如何处理弱引用回收策略？软引用和弱引用如何选择？
序列化：transient关键字作用是什么？使用场景是什么？它的实现原理是什么？

# 1.9 反射使用问题

反射概念：什么是反射机制？java反射机制提供了什么功能？在运行时如何调用任一对象的方法？反射优缺点有哪些？
反射使用：如何通过反射创建对象？如何反射获取内部类和调用内部类方法以及反射得到匿名内部类？如何通过反射获取和设置对象私有字段的值？
反射使用：new和反射创建对象有何区别？场景分析题：你需要控制学生、老师或家长唱歌行为，可是这些类又是由其他人设计，你只对开始与暂停操作进行控制。那么该如何做呢？
反射：如何防止反射序列化攻击单例？反射中有个暴力访问权限方法，这个方法怎么实现的？如何避免反射攻击？
反射跟泛型：如何通过反射获得泛型的实际类型参数？forName()源码设计思想是什么？getMethod源码设计思想是什么？
反射分析：什么是反射机制？反射机制的优缺点？通过设置setAccessible(true)暴力访问权限有什么危害？
反射性能：反射为何损耗性能，从jvm层面说一下你的看法？如何提高反射的效率？

# 1.10 枚举注解问题

注解作用：注解起到什么作用？注解有哪些？写过注解吗？比如分析下butterKnife在bind()时的原理……注解如何实现一个findViewById
注解分类：编译器注解和运行期注解使用场景有哪些？说一下编译期注解实践的场景？运行时注解：retrofit；编译时注解：EventBus
注解实践：注解如何获取，反射为何耗性能？了解动态注解吗，说一下Retrofit网络加载框架是如何进行动态注解的？

# 1.11 线程池问题

线程池设计：为什么要有线程池？线程池的核心设计思想是什么样的？线程池设计包含那些属性？线程池如何设计任务提交？
线程池：线程池的关闭方式有几种，各自的区别是什么？线程池中submit() 和 execute()方法有什么区别？
线程池：线程池内的线程如果全部忙，提交一个新的任务，会发生什什么？队列全部塞满了之后，还是忙，再提交会发生什么？
核心线程：线程池核心线程数一般定义多少，为什么？核心线程可以销毁吗，为什么？
线程池场景：说说几种常见的线程池及使用场景？线程池都有哪几种工作队列？怎么理解无界队列和有界队列？
线程池复用：线程池复用原理是什么？是执行完成后销毁，再新建几个放那；还是始终是那几个线程？
线程池设计：如何理解线程池是一种生产者&消费者模式？

# 1.12 其他知识问题

加解密：加解密有哪些方式？对称加密有哪些，使用场景是什么？非对称加密有哪些，使用场景是什么？如何理解单向加密？
MD5：用途是什么？应用场景有哪些？如何增强md5的安全性？md5的算法大概是什么样的？如何设计一款算法？
Base64：base64是加密算法吗？那些场景使用base64？它的本质是什么？它编码的好处是什么？为何说base64处理的数据有利于多设备传输？ASCII不可见字符有哪些？

# 2.C语言面试题汇总

# 2.1 基础语法问题

关键字：C语言有多少个关键字？static、const、volatile、extern、register、auto 各自作用是什么？typedef 和 #define 有什么区别？
数据类型：char、short、int、long、long long 在 32 位和 64 位平台下各占几个字节？sizeof 是函数还是关键字？sizeof(struct) 如何计算？为什么会有字节对齐？
存储类型：全局变量、局部变量、静态变量、寄存器变量分别存储在哪里？它们的生命周期和作用域分别是什么？
字符串：C 字符串和字符数组有什么区别？strlen 和 sizeof 对字符串的处理有什么不同？strcpy 和 strncpy、strcat 和 strncat 的区别？
运算符：&、|、^、~、>>、<< 位运算各自用途？a ^= b; b ^= a; a ^= b; 为什么可以交换两数？++i 和 i++ 的区别，在表达式中的副作用？
格式化：printf 的可变参数是如何实现的？%d、%u、%x、%p、%f、%e、%s 各自含义？如何防止 printf 带来的安全问题？

# 2.2 指针与内存问题

指针概念：什么是指针？指针和地址有什么区别？空指针、野指针、悬垂指针分别是什么？如何避免野指针？
指针运算：指针加减整数的含义是什么？指针之间的减法有什么意义？p++ 和 (*p)++ 的区别？数组名和指针的区别？
指针和数组：int a[10] 和 int *p 有什么区别？&a、a、a[0]、&a[0] 四者之间的关系？多维数组和指针数组有什么区别？
函数指针：函数指针如何定义和使用？回调函数是什么？如何用函数指针实现一个简单的策略模式？typedef 简化函数指针的写法？
二级指针：什么是二级指针？为什么需要二级指针？char **argv 和 char *argv[] 是一回事吗？
const 和指针：const int *p、int *const p、const int *const p 三者有什么区别？const 能阻止通过指针修改数据吗？
动态内存：malloc、calloc、realloc、free 的区别？malloc 返回值为什么要强转？为什么 free 之后还要 p = NULL？
内存泄漏：什么情况下会发生内存泄漏？如何检测内存泄漏？valgrind 的原理是什么？
内存布局：C 程序运行时内存分为哪几个区（代码区、数据区、BSS、堆、栈）？栈增长方向？堆增长方向？

# 2.3 结构体和联合体

结构体：结构体和联合体有什么区别？结构体内存对齐的规则是什么？如何让结构体紧凑排列？#pragma pack 的作用？
位域：什么是位域？位域有什么限制？位域在内存中是如何存储的？不同平台下的位域是否可移植？
柔性数组：什么是柔性数组？它的使用场景是什么？如何分配和释放？
共用体：union 可以做什么？如何用 union 判断大小端？union 的 sizeof 如何计算？
枚举：enum 底层存储类型是什么？可以控制 enum 的大小吗？enum 和 #define 有什么区别？
typedef：typedef struct 和 struct 定义有什么区别？typedef 函数指针的写法？

# 2.4 预处理与编译问题

预处理：预处理器做了哪些工作？#include <> 和 #include "" 有什么区别？#pragma 有哪些用法？
宏定义：#define 宏和 inline 函数有什么区别？宏的副作用有哪些？如何写一个安全的 MAX 宏？## 和 # 在宏中的作用？
条件编译：#ifdef、#ifndef、#if、#endif 的用法？头文件防重复包含的两种方式？
编译过程：C 程序从源码到可执行文件经过哪些阶段（预处理、编译、汇编、链接）？每一步做了什么？
链接：静态链接和动态链接的区别？.a、.so、.dll 分别是什么？符号表、重定位是什么概念？
段：text、data、bss、rodata 段分别放什么？未初始化的全局变量在哪？const 全局变量在哪？

# 2.5 字符串与大小端

字符串操作：手写 strcpy、strcmp、strlen、strcat、memcpy、memmove。memcpy 和 memmove 有什么区别？
循环拷贝：memcpy 为什么不能处理内存重叠？memmove 如何处理？如何从高位向低位或低位向高位拷贝？
指针数组：char *a[] 和 char **a 有什么区别？二维数组传参时为什么要指定第二维？
字符串常量：char *s = "hello" 和 char s[] = "hello" 有什么本质区别？前者能修改吗，后者能修改吗？
大端小端：什么是大端小端？如何判断机器的大小端？网络字节序是大端还是小端？htonl、ntohl 的作用？

# 2.6 其他进阶问题

可变参数：va_list、va_start、va_arg、va_end 是什么？原理是什么？为什么 va_arg 必须知道参数类型？
setjmp：setjmp 和 longjmp 是什么？它们解决什么问题？和异常处理的区别？
递归：递归的本质是什么？尾递归为什么可以被优化？什么情况下会栈溢出？
程序运行：main 函数结束之前和之后还能做什么？atexit 是什么？exit、_exit、abort、return 的区别？
常见陷阱：const int a = 10; int *p = (int*)&a; *p = 20; 可以吗？为什么？sizeof 对数组参数的处理？
文件操作：fopen、fread、fwrite、fseek、ftell、fclose 分别做什么？fflush 什么时候必须调用？
信号：signal 和 sigaction 的区别？哪些信号不能被捕获？signal handler 里可以调用 printf 吗？

# 3.C++编程面试题

# 3.1 语言基础问题

C 和 C++ 的区别：C 和 C++ 最大的区别是什么？C++ 新增了哪些特性？C++ 完全兼容 C 吗？
引用和指针：引用和指针有什么区别？为什么要引入引用？引用底层是如何实现的？可以有空引用吗？可以返回局部变量的引用吗？
new 和 malloc：new 和 malloc 有什么区别？new[] 和 new 的区别？operator new 和 new operator 又是什么？placement new 是什么？
函数重载：C++ 函数为什么支持重载而 C 不支持？name mangling 是什么？extern "C" 用于解决什么问题？
默认参数：默认参数在哪里书写？默认参数和函数重载是否冲突？默认参数是编译期还是运行期确定？
内联函数：inline 的作用？内联一定会被编译器内联吗？虚函数可以内联吗？为什么？
命名空间：namespace 的作用？using namespace std 有什么问题？匿名命名空间有什么用？

# 3.2 面向对象问题

封装继承多态：C++ 如何实现三大特性？public/protected/private 继承分别有什么区别？多继承会带来什么问题？
虚函数：虚函数是如何实现多态的？虚函数表在哪？每个对象都有虚函数表指针吗？构造函数可以是虚函数吗？析构函数为什么要是虚函数？
纯虚函数：纯虚函数和抽象类是什么概念？含有纯虚函数的类还能实例化吗？接口类怎么设计？
虚继承：菱形继承会带来什么问题？虚继承如何解决？虚基类表指针是什么？
构造析构：类对象构造和析构顺序？派生类构造时父类构造函数如何调用？析构函数调用虚函数会怎样？
拷贝控制：三大法则、五大法则是什么（拷贝构造、拷贝赋值、析构、移动构造、移动赋值）？什么时候需要自己实现？=default 和 =delete 的作用？
运算符重载：哪些运算符可以重载？哪些不能？operator= 实现时要注意什么？自赋值检查必要吗？
友元：friend 有什么用？friend 破坏了封装吗？友元可以继承吗？
类的大小：一个空类的 sizeof 是多少？有一个虚函数的类 sizeof 是多少？多继承、虚继承又是多少？
多态实现：静态多态（模板、重载）和动态多态（虚函数）有什么区别？CRTP 是什么？

# 3.3 模板与泛型

模板基础：函数模板和类模板是什么？模板是编译期实例化还是运行期？模板特化和偏特化是什么？
模板类型推导：auto、decltype、模板参数推导各有什么规则？万能引用 T&& 和右值引用 T&& 有什么区别？引用折叠是什么？
模板实例化：为什么模板声明和实现通常放在头文件？显式实例化和隐式实例化有什么区别？
模板元编程：SFINAE 是什么？enable_if 如何工作？type_traits 常用类型判断有哪些？constexpr 函数是什么？
可变参数模板：typename... Args 是什么？参数包如何展开？折叠表达式是什么？

# 3.4 STL 相关问题

容器分类：STL 容器分为哪几类（序列、关联、无序、容器适配器）？vector、list、deque、map、unordered_map 各自底层是什么？
vector：vector 的扩容策略？为什么是 1.5 倍或 2 倍？reserve 和 resize 有什么区别？迭代器失效的场景？
list：list 底层是什么？为什么 list 不支持随机访问？list 的迭代器失效规则？
map 和 unordered_map：底层红黑树和哈希表的区别？什么场景选 map，什么场景选 unordered_map？map 的 key 必须支持什么运算？
迭代器：迭代器有哪几种分类（输入、输出、前向、双向、随机）？每种分类支持哪些操作？
算法：sort 底层用的是什么算法？为什么是 introsort？stable_sort 和 sort 的区别？
仿函数：仿函数是什么？和函数指针、lambda 相比有什么优势？std::function 和 std::bind 的原理？
智能指针：unique_ptr、shared_ptr、weak_ptr 各自用在什么场景？shared_ptr 线程安全吗？引用计数线程安全吗？循环引用如何解决？
shared_ptr 原理：shared_ptr 的控制块和数据块分别存什么？make_shared 比直接 new 有什么优势？

# 3.5 内存与资源管理

内存模型：C++ 程序的内存布局？栈和堆的区别？栈上分配和堆上分配性能差距在哪？
RAII：RAII 是什么？它解决了什么问题？智能指针、锁、文件句柄是如何用 RAII 管理的？
移动语义：右值引用是什么？std::move 做了什么？为什么说 std::move 不移动？完美转发 std::forward 是什么？
拷贝省略：RVO 和 NRVO 是什么？C++17 的强制拷贝省略是什么？
内存泄漏：哪些场景容易导致内存泄漏？如何排查？shared_ptr 循环引用是怎么发生的？
对象池：为什么需要对象池？如何设计一个线程安全的对象池？

# 3.6 C++11/14/17/20 新特性

lambda：lambda 是什么？捕获列表的含义？lambda 是如何实现的（闭包类）？mutable 修饰什么？
auto/decltype：auto 的推导规则？和 decltype 有什么区别？decltype(auto) 是什么？
nullptr：nullptr 和 NULL 的区别？为什么要引入 nullptr？
右值引用：什么是右值引用？移动构造和拷贝构造何时被调用？noexcept 对移动有什么影响？
并发：std::thread、std::async、std::future、std::promise 如何配合使用？std::atomic 的内存序有哪些？
其他：range-based for、override/final、constexpr、结构化绑定、if constexpr、concepts 各自解决了什么问题？

# 3.7 其他高级问题

异常：C++ 异常机制原理是什么？try/catch 是如何工作的？noexcept 的作用？析构函数为什么不能抛异常？
异常安全：基本保证、强保证、不抛异常保证分别是什么？swap 技术如何实现强异常安全？
编译优化：编译器做了哪些优化？inline、RVO、常量折叠、循环展开？
链接：extern "C"、weak symbol、一次定义原则 ODR 是什么？符号冲突怎么解决？
虚函数优化：devirtualization 是什么？final 关键字的性能作用？
线程安全：局部 static 变量的初始化在 C++11 后是线程安全的吗？为什么？
内存对齐：alignas、alignof 是什么？false sharing 是什么？如何避免？

# 4.JavaScript面试题

# 4.1 基础类型问题

数据类型：JS 有哪些基本数据类型？typeof null 为什么返回 "object"？typeof 和 instanceof 的区别？
类型转换：== 和 === 的区别？隐式类型转换的规则是什么？[] == ![] 的结果是什么？为什么？
判空：如何准确判断一个变量是数组？如何判断变量是 undefined、null、NaN？Object.prototype.toString.call 的作用？
基本包装类：Number、String、Boolean 这些基本包装类型何时被创建？为什么 "abc".length 可以访问？
深浅拷贝：浅拷贝和深拷贝的区别？常见深拷贝的实现方式（JSON、递归、structuredClone）各有什么坑？循环引用如何处理？
不可变：const 定义的对象可以修改属性吗？如何实现真正的不可变对象？Object.freeze 是浅冻结还是深冻结？

# 4.2 作用域与闭包

作用域：JS 的作用域链是如何形成的？var、let、const 的作用域有什么区别？为什么要引入块级作用域？
变量提升：什么是变量提升？函数声明和函数表达式的提升有什么区别？暂时性死区是什么？
闭包：什么是闭包？闭包的应用场景有哪些？闭包会导致内存泄漏吗？如何避免？
this 指向：this 在不同调用场景下指向什么？箭头函数的 this 是什么？call、apply、bind 的区别？如何手写 bind？
执行上下文：什么是执行上下文？执行栈是什么？变量对象、活动对象、作用域链怎么理解？
IIFE：立即执行函数有什么作用？在模块化时代还有用吗？

# 4.3 原型与继承

原型链：什么是原型？什么是原型链？__proto__ 和 prototype 的区别？Object.prototype.__proto__ 是什么？
继承实现：JS 有哪些继承方式（原型链、构造函数、组合、寄生、寄生组合、ES6 class）？各自优缺点？
new 操作符：new 做了哪些事情？如何手写一个 new？new.target 是什么？
instanceof：instanceof 是如何工作的？如何手写一个 instanceof？
class：ES6 class 和 ES5 函数构造器有什么区别？class 里的 static 方法如何理解？super 关键字的用法？
Object.create：Object.create 和 new 的区别？如何用 Object.create 实现继承？

# 4.4 异步编程问题

事件循环：JS 的事件循环是怎样的？宏任务和微任务有哪些？浏览器和 Node.js 的事件循环有什么不同？
Promise：Promise 有哪三种状态？Promise 的 then、catch、finally 各自用途？如何手写一个 Promise？Promise.all、Promise.race、Promise.allSettled、Promise.any 的区别？
async/await：async/await 的本质是什么？和 Promise 相比有什么优势？如何处理 async 中的异常？
回调地狱：什么是回调地狱？Promise 和 async/await 如何解决？
定时器：setTimeout 和 setInterval 有什么问题？requestAnimationFrame 是什么？requestIdleCallback 的用途？
并发控制：如何用 Promise 实现并发限制？如何实现请求重试、超时取消（AbortController）？

# 4.5 DOM 与 BOM

事件机制：DOM 事件流（捕获、目标、冒泡）？addEventListener 的第三个参数含义？事件委托是什么？有什么优势？
事件对象：event.target 和 event.currentTarget 的区别？stopPropagation、stopImmediatePropagation、preventDefault 的区别？
DOM 操作：原生 DOM 操作为什么慢？document fragment 为什么可以优化？重绘和回流的区别？如何减少重绘回流？
BOM：window、location、history、navigator、screen 常用属性？history.pushState 和 replaceState 用在什么场景？
存储：cookie、localStorage、sessionStorage、IndexedDB 的区别？各自容量限制和适用场景？

# 4.6 ES6+ 新特性

let/const：和 var 的区别？为什么推荐使用 let/const？
解构赋值：数组解构、对象解构的用法？默认值如何设置？
扩展运算符：... 在函数参数、数组、对象中分别有什么含义？剩余参数和扩展运算符有什么区别？
Map 和 Set：Map 和对象有什么区别？Set 有什么用？WeakMap、WeakSet 为什么要弱引用？
Symbol：Symbol 是什么？它解决了什么问题？Symbol.iterator 有什么用？
迭代器和生成器：可迭代协议是什么？generator 函数的 yield 如何工作？如何用 generator 实现 async/await？
模块化：CommonJS、AMD、UMD、ES Module 的区别？动态 import() 的用途？

# 4.7 性能与安全

防抖节流：防抖和节流的区别？分别适用什么场景？如何手写？
内存泄漏：JS 中有哪些常见的内存泄漏？闭包、未清理的定时器、DOM 引用、全局变量如何排查？
XSS：什么是 XSS？反射型、存储型、DOM 型 XSS 的区别？如何防御 XSS？
CSRF：什么是 CSRF？如何防御 CSRF？SameSite Cookie 的作用？
同源策略：什么是同源策略？跨域有哪些解决方案（CORS、JSONP、proxy、postMessage）？
首屏优化：首屏加载慢有哪些优化手段？代码分割、懒加载、预加载、SSR 各自在什么场景用？

# 4.8 框架与工程化

虚拟 DOM：什么是虚拟 DOM？它真的比原生 DOM 快吗？diff 算法的核心思想是什么？key 的作用？
响应式原理：Vue2 的 Object.defineProperty 和 Vue3 的 Proxy 有什么区别？React 的状态更新机制是同步还是异步？
框架对比：React 和 Vue 的设计理念有什么差异？单向数据流 vs 双向绑定？
Webpack：Webpack 的构建流程？loader 和 plugin 的区别？Tree Shaking 的原理和前提？code splitting 如何实现？
包管理：npm、yarn、pnpm 有什么区别？pnpm 为什么快？package-lock.json 的作用？
TypeScript：TS 和 JS 的关系？any、unknown、never 各是什么？泛型、联合类型、交叉类型的用法？

# 5.设计模式面试题

# 5.1 基础概念问题

设计模式：什么是设计模式？GoF 23 种模式分为哪三大类（创建型、结构型、行为型）？
设计原则：SOLID 五大原则分别是什么？举例说明每一条？为什么要遵循这些原则？
耦合内聚：耦合和内聚是什么？高内聚低耦合如何实现？
过度设计：什么是过度设计？模式不是越多越好，你如何判断要不要用模式？
UML：常见的 UML 关系（依赖、关联、聚合、组合、泛化、实现）怎么理解？组合和聚合的核心区别？

# 5.2 创建型模式

单例模式：单例的 6 种实现方式（饿汉、懒汉、DCL、静态内部类、枚举、CAS）各有什么优劣？为什么 DCL 要用 volatile？双重检查锁的作用？
单例场景：单例模式应用在什么场景？如何防止反射破坏单例？如何防止序列化破坏单例？
工厂模式：简单工厂、工厂方法、抽象工厂的区别？各自使用场景？为什么简单工厂不算 GoF 模式？
建造者模式：Builder 模式解决了什么问题？和工厂模式的区别？StringBuilder 是建造者模式吗？
原型模式：Prototype 模式的核心思想？和 new 相比优势在哪？clone 的深浅拷贝问题如何处理？

# 5.3 结构型模式

适配器模式：Adapter 模式解决什么问题？类适配器和对象适配器的区别？InputStreamReader 是不是适配器？
装饰器模式：Decorator 和继承有什么区别？为什么 Java IO 用大量的装饰器？
代理模式：静态代理和动态代理的区别？JDK 动态代理和 CGLib 动态代理有什么区别？为什么 JDK 动态代理必须基于接口？
外观模式：Facade 模式的本质？和中介者模式的区别？
桥接模式：Bridge 模式解决什么问题？桥接和适配器有什么区别？举一个 JDBC 的例子？
组合模式：Composite 模式的使用场景？如何处理叶子和容器的一致性？
享元模式：Flyweight 模式解决什么问题？Integer 缓存池是不是享元？String 常量池是不是享元？

# 5.4 行为型模式

策略模式：Strategy 模式的核心思想？和工厂模式如何配合？如何避免大量 if-else？
观察者模式：Observer 模式的实现方式？推模型和拉模型的区别？Java 自带的 Observable 有什么问题？
责任链模式：Chain of Responsibility 的典型场景？OkHttp 的拦截器、Netty 的 Pipeline 是如何实现的？
模板方法模式：Template Method 的核心？和策略模式有什么区别？AbstractList、HttpServlet 是不是模板方法？
命令模式：Command 模式解决什么问题？如何实现撤销重做？
状态模式：State 模式和策略模式有什么区别？如何避免大量状态判断？
迭代器模式：Iterator 模式的本质？为什么 Java 集合类都实现 Iterator？fail-fast 如何实现？
访问者模式：Visitor 模式解决什么问题？双分派是什么？为什么它不常用？
备忘录模式：Memento 模式的应用场景？如何实现快照和恢复？
中介者模式：Mediator 模式和观察者的区别？它如何降低耦合？

# 5.5 实战与源码问题

源码分析：JDK 源码中有哪些模式的使用（Runtime=单例、Calendar=建造者、List.iterator=迭代器、Runnable=命令）？
框架模式：Spring 中有哪些模式（IoC=工厂、AOP=代理、TransactionTemplate=模板方法、ApplicationEvent=观察者）？
Android 模式：Android 中常见模式有哪些（Handler=责任链思想、ViewGroup=组合、BitmapFactory=工厂、LayoutInflater=建造）？
对比：策略、状态、命令都可以消除 if-else，它们区别是什么？模板方法、策略、函数回调又怎么区分？
场景题：如何设计一个通用的缓存组件（责任链 + 策略 + 装饰器）？如何设计一个日志框架（责任链 + 策略 + 门面）？
重构：说说你在项目中重构时用到过哪些模式？重构前后代码的可维护性对比？

# 6.数据结构和算法

# 6.1 数组与链表

数组：数组和链表的区别？顺序存储和链式存储各自的优缺点？数组是如何随机访问 O(1) 的？
动态数组：ArrayList、Vector、std::vector 的扩容机制？为什么是 1.5 倍或 2 倍？扩容时的均摊复杂度是多少？
单链表：单链表如何实现增删查改？如何判断链表有环？环的入口怎么找（快慢指针）？
链表反转：单链表反转的迭代和递归写法？K 个一组反转链表怎么做？
链表合并：合并两个有序链表、合并 K 个有序链表（分治、优先队列）各自复杂度？
双向链表：双向链表相比单链表的优势？LRU 用双向链表 + HashMap 如何实现？
跳表：什么是跳表？跳表的查询复杂度？为什么 Redis 有序集合用跳表而不用红黑树？

# 6.2 栈与队列

栈应用：栈的典型应用有哪些（函数调用、括号匹配、表达式求值、单调栈）？
队列应用：队列的典型应用（BFS、生产者消费者、异步消息）？
栈实现队列：如何用两个栈实现队列？如何用两个队列实现栈？
单调栈：单调栈解决什么问题？经典题：柱状图最大矩形、每日温度、下一个更大元素。
单调队列：单调队列解决什么问题？滑动窗口最大值如何用单调队列优化？
循环队列：环形队列如何实现？队空和队满如何区分？
双端队列：deque 的底层实现？std::deque 和 java.util.ArrayDeque 有什么区别？

# 6.3 树与图

二叉树：二叉树的前中后序遍历（递归、迭代、Morris 遍历）？层序遍历如何实现？
二叉搜索树：BST 的增删查改？BST 中序遍历为什么有序？BST 退化问题？
平衡树：AVL 树和红黑树的区别？红黑树为什么被广泛应用（HashMap、TreeMap、epoll、进程调度）？红黑树的五条性质？
B 树与 B+ 树：B 树和 B+ 树的区别？为什么数据库索引用 B+ 树而不用红黑树？B+ 树的叶子节点为什么要用链表？
Trie 树：前缀树的用途（自动补全、敏感词过滤）？空间如何优化（三叉 Trie、DoubleArray Trie）？
堆：大顶堆、小顶堆如何实现？堆的增删改查复杂度？堆排序为什么不稳定？Top K 问题怎么解？
图：图的存储（邻接矩阵、邻接表）？BFS 和 DFS 的区别？哪些场景用 BFS，哪些用 DFS？
最短路径：Dijkstra、Floyd、Bellman-Ford、SPFA 各自适用什么场景？Dijkstra 为什么不能处理负权边？
最小生成树：Prim 和 Kruskal 的区别？并查集在 Kruskal 中如何使用？
拓扑排序：有向无环图的拓扑排序如何实现？课程表类问题怎么建模？

# 6.4 哈希与查找

哈希：哈希函数的好坏标准？常见哈希冲突解决方法（开放寻址、链地址、再哈希、公共溢出区）？
哈希扩容：什么时候需要扩容？扩容的阈值和代价？渐进式 rehash 如何设计（Redis 是怎么做的）？
一致性哈希：一致性哈希解决了什么问题？虚拟节点是为了解决什么？雪崩问题如何避免？
布隆过滤器：Bloom Filter 的原理和用途？误判率如何计算？为什么不能删除？计数布隆过滤器如何实现？
二分查找：标准二分、查找左边界、查找右边界如何写？二分的边界条件为什么容易错？

# 6.5 排序与分治

比较排序：冒泡、选择、插入、希尔、归并、快排、堆排的时间和空间复杂度？哪些是稳定排序？
快速排序：快排的基本思想？最坏情况是什么？如何避免最坏（三数取中、随机化）？
归并排序：归并排序是如何分治的？空间复杂度为什么是 O(n)？归并排序求逆序对怎么做？
非比较排序：计数、桶、基数排序的原理？各自的适用场景？为什么可以突破 O(nlogn)？
大数据排序：10 亿数据如何排序？外部排序怎么实现？Top K 问题用什么方法？
分治：分治的核心思想？主定理是什么？有哪些典型的分治算法（归并、快排、最近点对、大数乘法）？

# 6.6 动态规划与贪心

动态规划：DP 的三要素（状态、转移方程、边界）？DP 和递归的区别？记忆化搜索和 DP 的关系？
经典 DP：背包问题（01、完全、多重）、LIS、LCS、编辑距离、打家劫舍、股票买卖系列？
空间优化：DP 的滚动数组优化？状态压缩 DP 是什么（子集 DP、棋盘 DP）？
贪心：贪心算法的核心思想？贪心和 DP 的区别？如何证明贪心的正确性？
经典贪心：活动选择、任务调度、Huffman 编码、区间调度、找零钱？
DP vs 贪心：两者的取舍依据？什么情况下贪心也能得到最优解？

# 6.7 回溯与搜索

回溯：回溯的核心思想？模板是怎样的？剪枝的常见手段？
经典回溯：全排列、组合、子集、N 皇后、数独？如何去重？
BFS 最短路：为什么 BFS 能求最短路径？双向 BFS 怎么实现？
A*：A* 算法是什么？启发函数的选取原则？和 Dijkstra 的区别？
并查集：并查集的实现（路径压缩、按秩合并）？时间复杂度为什么近似 O(1)？

# 7.网络编程面试题

# 7.1 网络基础问题

分层模型：OSI 七层和 TCP/IP 四层各是哪些？每层核心协议？为什么工程上用 TCP/IP 四层？
基本概念：IP、端口、Socket、域名、URL、URI、URN 的区别？MAC 地址和 IP 地址的区别？
子网掩码：子网掩码有什么作用？CIDR 表示法是什么？如何计算同一网段？
DNS：DNS 解析过程？递归查询和迭代查询的区别？DNS 记录类型（A、AAAA、CNAME、MX、TXT）有哪些？
ARP：ARP 协议的作用？ARP 欺骗是什么？arp -a 能看到什么？
ICMP：ICMP 有什么用？ping 和 traceroute 的原理？

# 7.2 TCP 相关问题

TCP 特点：TCP 和 UDP 的区别？TCP 如何保证可靠性（序号、确认、重传、流量控制、拥塞控制）？
三次握手：为什么要三次握手？两次为什么不行？SYN 攻击是什么？
四次挥手：为什么要四次挥手？为什么 TIME_WAIT 要等 2MSL？CLOSE_WAIT 太多说明什么问题？
半关闭：TCP 半关闭是什么？shutdown 和 close 有什么区别？
流量控制：TCP 滑动窗口如何实现流量控制？窗口大小对吞吐量有什么影响？
拥塞控制：慢启动、拥塞避免、快重传、快恢复分别是什么？Reno、Cubic、BBR 算法有什么区别？
Nagle 算法：Nagle 算法解决了什么问题？为什么 TCP_NODELAY 要关闭它？延迟确认是什么？
Keep-alive：TCP Keep-alive 和 HTTP Keep-alive 有什么区别？长连接如何保活？心跳包怎么设计？
粘包拆包：为什么 TCP 会粘包？UDP 会吗？如何解决粘包（固定长度、分隔符、长度字段）？

# 7.3 HTTP 相关问题

HTTP 方法：GET、POST、PUT、DELETE、HEAD、OPTIONS、PATCH 各自含义？GET 和 POST 的本质区别？幂等性是什么？
状态码：常见状态码分类（1xx~5xx）？301 和 302、304 和 200、401 和 403 的区别？
请求头：Content-Type、Content-Length、Transfer-Encoding、Cache-Control、ETag、Referer、User-Agent 各自作用？
HTTP 版本：HTTP/1.0、1.1、2、3 的主要区别？HTTP/2 的多路复用怎么实现？HTTP/3 用 QUIC 为什么快？
缓存机制：强缓存（Expires、Cache-Control）和协商缓存（Last-Modified、ETag）的区别？缓存决策过程？
Cookie 和 Session：Cookie 和 Session 的区别？JWT 又是什么？SameSite、HttpOnly、Secure 各自作用？
断点续传：Range 请求头、206 Partial Content、Accept-Ranges 如何工作？
分块传输：Transfer-Encoding: chunked 的作用？何时用分块传输？

# 7.4 HTTPS 与安全

HTTPS 原理：HTTPS 比 HTTP 多做了什么？TLS 握手流程（非对称协商、对称加密、CA 验证）？
证书：数字证书是什么？CA 如何工作？自签名证书的风险？
加密：对称加密（AES、DES）和非对称加密（RSA、ECC）的区别？为什么 HTTPS 要对称+非对称结合？
TLS 版本：TLS 1.2 和 TLS 1.3 有什么区别？TLS 1.3 为什么更快更安全？
中间人攻击：MITM 是什么？Charles 为什么能抓 HTTPS？如何防抓包（证书 pinning）？
常见攻击：CSRF、XSS、SQL 注入、重放攻击、DDoS 各自的原理和防御？

# 7.5 Socket 编程问题

Socket 基础：Socket 是什么？文件描述符和 Socket 的关系？bind、listen、accept、connect、send、recv 各自做了什么？
IO 模型：五种 IO 模型（阻塞、非阻塞、IO 复用、信号驱动、异步）分别是怎样的？Reactor 和 Proactor 的区别？
IO 复用：select、poll、epoll 的区别？epoll 为什么高效？LT 和 ET 的区别？
epoll：epoll_create、epoll_ctl、epoll_wait 分别做什么？epoll 底层数据结构是什么？惊群效应如何避免？
高性能 IO：为什么 Redis 单线程能做到高性能？Nginx 的 worker 多进程 + epoll 模型？
零拷贝：sendfile、mmap、splice 都是零拷贝吗？它们分别节省了哪几次拷贝和上下文切换？

# 7.6 移动端与高并发

WebSocket：WebSocket 和 HTTP 的区别？握手过程？心跳机制如何设计？
长连接短连接：长连接和短连接各自场景？长连接如何维持？什么时候该断开？
负载均衡：LVS、Nginx、HAProxy 各自属于哪一层？四层和七层负载均衡区别？一致性哈希在 LB 中的应用？
CDN：CDN 的工作原理？回源机制是什么？CDN 如何解决热点问题？
限流：限流算法有哪些（计数器、滑动窗口、漏桶、令牌桶）？各自适用场景？
弱网：移动端弱网优化有哪些手段？DNS 预解析、连接预热、请求合并、HTTP/2、QUIC 各自能解决什么问题？

# 8.Android面试题

# 8.1 四大组件问题汇总

App进程：说一下App进程启动流程？Zygote进程的启动流程是什么样的？关于Zygote进程主要做了那些事情？
App进程：SystemServer进程启动流程是什么样的？怎么创建单个进程(application)？如何启动ActivityThread？
启动入口：ActivityThread启动入口做了什么？如何创建上下文？为什么要创建上下文。说一下主线程创建时机？
启动流程：说一下application的启动流程，何时创建，什么时候调用onCreate和attachBaseContext方法？
启动顺序：Application中attachBaseContext方法，onCreate方法和ContentProvider中的onCreate方法执行的顺序是什么？
Activity启动流程：其中考察最多的类似问题是：从桌面点击一个图标之后，到界面显示，这个过程发生了什么？
Activity启动模式：也就是常见的四种启动模式，面试官更喜欢问何时使用他们，也就是使用场景。从非activity中开启activity为什么要添加flag，不添加会出现什么问题？
Activity生命周期：onStart()和onResume()/onPause()和onStop()的区别？并且这几个方法在那种场景下用到，具体有什么作用？
Activity异常生命周期：简单说一下这些方法是做什么用的？onSaveInstanceState()方法？何时会调用？onSaveInstanceState()与onPause()的区别？如何避免配置改变时Activity重建？
Activity#onNewIntent：onNewIntent()调用时机？onNewIntent()具体有什么作用？Activity遵循什么设计模式？知道ActivityThread这个类是干什么用的吗？
Service：Activity如与Service通信？Service的生命周期与启动方法由什么区别？Service先start再bind如何关闭service，为什么bindService可以跟Activity生命周期联动？
Service：一个Activity先start一个Service后，再bind时会回调什么方法？此时如何做才能回调Service的destroy()方法？
Service前台服务：前台服务是什么？和普通服务的不同？如何去开启一个前台服务？如何去做保活？
Service绑定服务：bindService是一个异步的过程吗？绑定service大概需要经历那些过程？是否能在Service进行耗时操作？
Receiver：广播有哪些注册方式？有什么区别？广播发送和接收原理是什么？广播传输的数据是否有限制，是多少，为什么要限制？
BroadcastReceiver：广播原理是什么？如何进行数据传递？广播跨进程实现的方案是什么？
Receiver案例分析：BroadcastReceiver与LocalBroadcastReceiver有什么区别？LocalBroadcastReceiver 是应用内广播，那么它是怎么实现的？
Receiver案例分析：如何通过广播拦截和abort一条短信；广播是否可以请求网络；广播引起anr的时间限制？广播中怎么进行网络请求?
ContentProvider：为什么会设计ContentProvider，ContentProvider 是如何实现数据共享的?请说一下进程共享和线程安全问题……
ContentProvider：说一下初始化流程，简单说一下ContentProvider的权限管理(读写分离，权限控制-精确到表级，URL控制)
Fragment原理：Fragment设计原理是什么？replace和add的区别？用Fragment有遇过什么坑吗，怎么解决？
Fragment案例：Fragment是如何做懒加载的？有那几个重要的方法？如何实现？setUserVisibleHint()方法什么时候调用？
Fragment分析：如果在onStop的时候做了网络请求，onResume的时候怎么恢复？
Fragment案例：在fragment中为什么有时getActivity()会为null？Fragment试图为什么有的时候会重叠，怎么产生的，又如何解决？

# 8.2 View工作原理问题

View刷新：requestLayout、invalidate与postInvalidate作用与区别，在requestLayout这个方法里面做了什么？
View刷新：requestLayout，onLayout，onDraw，DrawChild区别与联系？drawChild()是做什么用的？View是如何绘制到屏幕上的？
Canvas：Canvas.save()跟Canvas.restore()的调用时机？Canvas的底层机制，绘制框架，硬件加速是什么原理，canvas lock的缓冲区是怎么回事
View绘制流程，当一个TextView的实例调用setText()方法后执行了什么？请说一下原理……
测量：如何理解View中的测量？子控件的测量依赖父布局约束吗？如何理解测量过程中的"递"和"归"的设计思想？
测量：如何理解测量中布局MeasureSpec的设计？mode三种布局模式分别如何理解？mode和size的组成如何理解？
测量：单个控件测量流程是怎么样的？测量策略是如何影响测量结果的？如何标记测量完成？谈一下设计思想？
测量：完整的View树测量流程的设计思路是什么样的？遍历测量孩子的大小如何处理margin和padding逻辑？
布局：getWidth()方法和getMeasureWidth()区别呢？布局的设计思路是什么？
布局：单个View的布局流程是怎么样的？如何理解布局中相对位置和绝对位置？什么情况下需要对控件重新布局？
布局：以LinearLayout为例，完整布局流程是怎么样的。如果其中的一个孩子View修改了top高度，其布局流程会发生什么变化？
绘制：在View中draw绘制思路是如何设计的？ViewGroup中dispatchDraw分发绘制设计思路是怎样的？
绘制：说一下绘制中surface起到什么作用？draw里面绘制了那些东西，简要介绍一下？

# 8.3 Android事件体系问题

事件分发流程：考察得最多，基本把整个分发流程讲清楚就好了；其次还会考察如何解决具体的冲突场景。
事件体系设计思想：事件体系设计思想是什么？事件分发的本质？事件在哪些对象间进行传递？事件流程？
事件拦截：点击事件被拦截，但是想传到下面的View，如何操作？事件传递流程是什么？主要有哪些方法，请说一下这些方法的作用……
事件分发：事件分发中的onTouch 和onTouchEvent 有什么区别，又该如何使用？事件传递流程和OnTouchListener的关系，那个先执行？
返回键事件：说一下返回键事件分发流程？如何从Native层传输到应用层，说一下事件传递的流程。

# 8.4 Android消息机制

Handler工作流程：比如怎么唤醒主线程的，while为啥不会阻塞主线程。同步屏障。涉及到绘制优化、屏幕刷新机制等。
阻塞唤醒原理：这里一般是会问为何loop()方法是死循环却不会占用cpu时间片 or 为何next()方法阻塞却不会卡死。更深一点会问到Linux的IO多路复用epoll原理。
异步消息：说下handler的流程，异步消息是什么？Android中哪些场景会发送异步消息？我们在代码中可以手动发异步消息吗？
ThreadLocal：Handler为何用ThreadLocal？它是如何存储数据的？为何多线程需要使用到它？什么场景会用到ThreadLocal？
消息机制：postDelay中是如何处理延迟消息的？如何阻塞挂起？

# 8.5 Android多线程问题

多线程：Android中为什么要使用多线程，说下多线程？多个线程如何同步请求，返回的结果如何等待所有线程数据完成后合成一个数据？
场景面试题：如果我开了 18 个子线程，同时发送，并发的情况下如何保证消息及时性？
AsyncTask：AsyncTask机制说一下……如何取消AsyncTask？并且它存在哪些不足？AsyncTask生命周期随着activity销毁而销毁吗？AsyncTask如何造成内存泄漏？
IntentService：你觉得使用 IntentService 和自己写一个异步加载有什么区别吗？IntentService原理是什么？
场景面试题：线程池的核心参数。如果core为5，提交了三个任务，分别被三个线程执行了，其中一个任务提前执行完毕了，此时再提交一个任务，这个任务是如何执行的？

# 8.6 Android动画机制

常见的动画有哪些？具体有哪些使用场景？动画的两种实现：setX跟setTranslationX区别？
Animation动画框架实现原理？动画可以改变相应的事件和位置吗？为什么？差值器和估值器是做什么用的？
补间动画和属性动画，对于作用于View，两者有什么区别？属性动画是如何改变View的属性的？

# 8.7 Android多媒体问题

图片加载：怎么加载一张超大图？如何计算内存大小？加载大图如何避免OOM，平常是怎么压缩图片的？如何加载超高清大图，局部加载图片了解嘛？
圆角：如何给控件的背景设置圆角。做图片圆角的原理是什么，平常有哪些优化操作？
Drawable：对比使用图片和drawable的好处，以及drawable的原理。不同文件展示会一样嘛？同样图片不同文件展示会一样嘛？
svg图片：svg 为什么体积会比较小？为什么是可伸缩的？是否可以无损缩放？svg 是否可以放一张照片，为什么？
Luban：压缩具体实现原理，可以自己写吗？Luban 压缩如何保证压缩的同时，图片质量还清晰？
多媒体：为什么限制在应用间共享文件？作为进程间的共享相册文件，是如何进行跨进程读取的？

# 8.8 Android网络相关

请求：数据层有统一的管理么，数据缓存是怎么做的，http请求等有提供统一管理么？
缓存：网络请求缓存处理，okHttp如何处理网络缓存的？缓存拦截器中做了什么逻辑？
数据有序：服务器只提供数据接收接口，在多线程或多进程条件下，如何保证数据的有序到达？
网络请求：https请求如何保证安全性？Charles能抓https请求么？能抓的话那安全性在哪？app如何防止代理抓包？

# 8.9 Android数据相关问题

SharePreference性能优化，可以做进程同步吗？SharedPreferences的应用场景，核心原理是什么？SharedPreferences是线程安全的吗？
SharedPreferences：两种提交方式，缺点，如何解决？主要是commit和apply的区别？
Android如何在不压缩的情况下加载高清大图？Android里的内存缓存和磁盘缓存是怎么实现的。
android里面的两种序列化方式，如何实现的。Android为什么引入Parcelable？怎么实现的？有没有尝试简化Parcelable的使用？
什么是序列化，序列化的对象设置一个serialVersionUID有什么作用？Serializable和Parcelable在性能上那个更加高效，具体结合案例说说……
序列化：serializable和parcelable的原理，以及各自的优缺点、应用场景。

# 8.10 WebView相关问题

WebView优化了解吗，如何提高WebView的加载速度？Java和JS的相互调用怎么实现，有做过什么优化吗？
WebView内存泄露出现的原因，该如何解决？怎么样提高webView加载速度？
WebView的内核是什么，4.4后直接使用了Chrome，那么Chrome又有哪些好处呢？
js调用native方法，它底层的原理是什么？为什么js能调用到Java的方法？webkit提供了这个功能，那它是怎么实现的？js调用native的方法时，是同步的还是异步的?java方法return一个值，js那边能立即拿到么？通过js调用一个java方法，这个java方法都是@onJavaInterface注解过的，这个方法是运行在哪个线程？

# 8.11 JetPack相关问题

LiveData：连续set两个相同的数据，会收到几次；连续post两个相同的数据，会收到几次；liveData能在子线程接收么？
LiveData：核心设计思想是什么？如何实现双向绑定。View 到 Model，Model 到 View 如何实现绑定？
LiveData：连续三次postValue数据，
ViewModel：如何实现Activity旋转之后，依旧能恢复数据的，如何保证model不变？ViewModel 如何绑定不同的页面？ViewModel 是单向绑定还是双向绑定？
ViewModel：是怎么和 View 之间怎么绑定的？充当业务逻辑层，如果两个模块逻辑一样，只是 UI 不一样，如何保证复用？如何实现ViewModel单利对象？

# 8.12 Android编译问题

gradle生命周期，怎么自定义插件？统计编译耗时插件，运行在哪个阶段？
描述从编译到apk的过程，以及gradle有哪些task参与其中？
implementation 和 api的区别是什么？

# 9.iOS面试题汇总

# 9.1 Objective-C 基础问题

分类：Category 是什么？它为什么不能添加实例变量？通过关联对象如何变相添加属性？Category 的加载时机？
扩展：Extension 和 Category 的区别？Extension 是何时被编译进类的？
协议：Protocol 的作用？@required 和 @optional 的区别？协议和抽象类在 OC 中如何对比？
属性：@property 的本质是什么？nonatomic 和 atomic 的区别？strong、weak、copy、assign、retain 各自用在什么场景？
copy 与 strong：NSString/NSArray/NSDictionary 为什么要用 copy 修饰？自定义类如何支持 copy？NSCopying 协议怎么实现？
深浅拷贝：copy 和 mutableCopy 的区别？不可变类型的 copy 和可变类型的 copy 结果有什么差异？
IBAction 与 IBOutlet：两者背后做了什么？IBOutlet 用 strong 还是 weak？
id 与 instancetype：两者有什么区别？为什么初始化方法推荐用 instancetype？
KVO：KVO 的底层实现？isa-swizzling 是什么？KVO 对多个属性监听的性能如何？如何实现一个线程安全的 KVO？
KVC：KVC 的底层实现？setValue:forKey: 和 setValue:forKeyPath: 的区别？KVC 如何访问私有变量？
NSNotification：通知的实现原理？通知是同步还是异步？NSNotificationCenter 的通知队列有什么用？通知何时需要移除？

# 9.2 Runtime 与消息转发

Runtime：Runtime 是什么？为什么说 OC 是运行时语言？Runtime 提供了哪些能力？
类结构：objc_class 结构包含哪些成员？isa 指针指向什么？元类是什么？元类的元类又是什么？
消息发送：[obj foo] 被编译成什么？objc_msgSend 的流程是怎样的？缓存（cache_t）的作用？
消息转发：消息转发的三大步骤（resolveInstanceMethod、forwardingTargetForSelector、forwardInvocation）？unrecognized selector 的触发时机？
Method Swizzling：方法交换的原理？使用场景（埋点、无痕 Hook、修复崩溃）？有哪些注意事项？为什么要放在 +load 里？
load 与 initialize：两者的调用时机和调用次数？为什么说 load 是类加载就调用而 initialize 是懒加载？Category 的 load 和本类的 load 谁先执行？
isa 指针：64 位下 isa 指针的位域设计是怎样的？为什么 isa 不再是纯指针？non-pointer isa 是什么？
关联对象：关联对象存储在哪？它和对象的生命周期如何同步？弱关联和强关联的区别？
weak 原理：weak 指针是如何实现的？对象释放时 weak 指针是如何被置 nil 的？SideTable 的结构是什么？

# 9.3 内存管理问题

MRC 和 ARC：MRC 和 ARC 的区别？ARC 底层做了什么？编译器在 ARC 下插入了哪些 retain/release？
引用计数：引用计数存储在哪（64 位 isa 中 + SideTable）？retainCount 真的准吗？dealloc 的触发时机？
循环引用：block、delegate、NSTimer 为什么容易造成循环引用？如何用 weakSelf/strongSelf 打破？NSTimer 如何彻底解决循环引用？
autorelease：autorelease 的实现原理？AutoreleasePool 的结构（哨兵 + 栈）？嵌套池是怎么设计的？
主线程 RunLoop 与 AutoreleasePool：主线程 AutoreleasePool 和 RunLoop 的关系是什么？为什么不用手动创建？
僵尸对象：EnableZombieObjects 的原理？为什么它只能在 debug 下使用？
野指针：什么是野指针？ARC 下还会出现野指针吗？如何定位野指针崩溃？
Block 内存管理：Block 有哪几种类型（global、stack、malloc）？为什么 __block 能让变量可修改？ARC 下 Block 为什么默认是 Malloc 类型？

# 9.4 Block 与多线程

Block 本质：Block 的底层是什么结构体？capture 变量是如何存入 Block 的？Block 的 invoke 函数是什么？
__block：__block 修饰变量底层做了什么？它是如何实现变量的读写共享的？
多线程：iOS 有哪几种多线程技术（pthread、NSThread、GCD、NSOperation）？各自适用什么场景？
GCD：串行队列、并发队列、主队列、全局队列的区别？dispatch_sync 死锁的典型场景？
GCD 进阶：dispatch_group 如何等待多个异步任务？dispatch_barrier 的作用？dispatch_semaphore 如何控制并发？
NSOperation：NSOperation 和 GCD 相比优势在哪（依赖、取消、暂停、KVO）？自定义 Operation 需要重写哪些方法？
锁：NSLock、@synchronized、pthread_mutex、os_unfair_lock、dispatch_semaphore 的性能对比？什么时候用读写锁？
线程安全：atomic 真的线程安全吗？为什么？如何实现一个线程安全的数组（可变 + 读写锁）？
RunLoop：RunLoop 是什么？它和线程的关系？mode 有哪些？为什么滚动时定时器会停？commonModes 如何解决？
RunLoop 应用：AutoReleasePool、事件响应、手势识别、UI 刷新、卡顿监控都是如何借助 RunLoop 实现的？

# 9.5 UI 与视图层

UIView 与 CALayer：两者的区别？为什么 UIView 负责事件响应而 CALayer 负责绘制？layer 的 contents 是什么？
渲染流程：iOS 渲染的四步（Commit Transaction → Render Server → OpenGL/Metal → Display）？离屏渲染是什么？
离屏渲染：哪些操作会触发离屏渲染（圆角 + 阴影、mask、rasterize、group opacity）？如何避免和优化？
事件响应：Hit-Test 和 pointInside 的关系？如何扩大按钮点击区域？事件是先找到响应者还是先传递？
响应者链：Responder Chain 是什么？事件未处理会传给谁？如何自定义响应链？
布局：Frame、Bounds、Center 的区别？AutoLayout 的本质是什么？AutoLayout 是如何解算约束的（Cassowary 算法）？
UITableView 优化：Cell 复用原理？高度计算如何优化？图片异步加载怎么做？RunLoop + 空闲渲染如何用于流畅度？
UIImage 加载：imageNamed 和 imageWithContentsOfFile 的区别？内存缓存是如何工作的？大图加载 OOM 怎么解决？
UIWebView 与 WKWebView：为什么淘汰 UIWebView？WKWebView 的进程间通信模型？JS 和 OC 如何互相调用？
Core Animation：显式动画和隐式动画的区别？CADisplayLink 与 CATimer 的区别？animation 的 fromValue、toValue、byValue 是什么关系？

# 9.6 Swift 相关问题

Swift vs OC：Swift 和 OC 最大的区别？Swift 为什么能做到更高性能？Swift 是如何和 OC 混编的？
值类型与引用类型：struct、enum、class 的区别？为什么 Swift 大量使用值类型？copy-on-write 是什么？
可选类型：Optional 的本质是什么（枚举）？强解包 !、可选绑定 if let、guard let、可选链 ?. 各自用法？
泛型：Swift 泛型和 OC 的区别？关联类型 associatedtype 是什么？泛型约束怎么写？
协议：Swift 协议和 OC 协议的区别？Protocol Extension 是什么？Protocol-Oriented Programming 的核心思想？
闭包：Swift 闭包和 OC Block 的区别？逃逸闭包和非逃逸闭包的区别？@autoclosure 的作用？
属性：存储属性和计算属性的区别？lazy、willSet、didSet 各自作用？property wrapper 是什么？
错误处理：throws、try、try?、try! 的区别？Result 类型和 throws 的对比？
内存模型：Swift 的 class 是否也走 ARC？ARC 在 Swift 中有什么变化？weak 和 unowned 的区别？
并发：Swift 5.5 的 async/await 原理？Actor 如何解决数据竞争？Structured Concurrency 是什么？

# 9.7 性能优化与工具

启动优化：App 启动分哪两个阶段（pre-main、main）？如何优化冷启动时间？动态库加载、+load、静态初始化、Runtime 注册各自占多少耗时？
卡顿监控：卡顿是如何定义的（16.67 ms）？如何通过 RunLoop 监控卡顿？CADisplayLink 方案的原理？
内存优化：如何排查内存泄漏（MLeaksFinder、Instruments Leaks）？如何降低峰值内存？图片和 Cell 的缓存策略？
耗电优化：哪些操作耗电？后台任务如何使用？定位、网络、屏幕刷新如何优化？
包大小：App Thinning 是什么？Bitcode 的作用？如何瘦身（LinkMap 分析、无用代码扫描、资源压缩）？
Crash 监控：Signal 和 Mach Exception 的区别？哪些崩溃捕获不到？符号化的原理？
Instruments：Time Profiler、Allocations、Leaks、Core Animation、Network 各自用在什么场景？

# 9.8 网络与存储

网络层：NSURLSession 和 NSURLConnection 的区别？后台下载怎么实现？断点续传如何做？
证书校验：HTTPS 证书校验流程？如何做证书 pinning？AFNetworking 的 security policy 怎么配置？
缓存：NSURLCache 默认是如何缓存的？如何自定义磁盘缓存？SDWebImage 的缓存策略？
持久化：沙盒有哪些目录（Documents、Library、tmp）？各自存什么？iCloud 备份规则？
存储方案：UserDefaults、Plist、Keychain、FMDB、Core Data、Realm 各自适用场景？
Keychain：Keychain 为什么卸载 App 后数据还在？如何用它做设备唯一标识？
Core Data：Core Data 是数据库吗？它和 SQLite 是什么关系？NSManagedObjectContext 的并发模式有哪些？
序列化：NSCoding 和 Codable 的区别？NSSecureCoding 解决了什么安全问题？

# 9.9 架构与设计问题

MVC/MVP/MVVM：iOS 经典的 Massive ViewController 问题如何解决？MVVM 如何落地？RxSwift/Combine 在其中的角色？
VIPER：VIPER 架构的五层职责？在大型项目中的优劣势？
路由：iOS 路由方案有哪些（URL Router、Target-Action、Protocol-Class）？各自优缺点？
组件化：iOS 组件化如何落地？CocoaPods 私有库如何管理？二进制化如何做？
跨端：React Native、Flutter、KMM 在 iOS 端的原理分别是什么？通信桥是如何设计的？
热修复：JSPatch、RollOut 的原理？为什么被苹果审核禁止？Hybrid 方案如何绕过？
埋点：无痕埋点如何实现？Hook UIViewController 的生命周期和 UIControl 的 sendAction 是如何做的？

# 9.10 系统机制与签名

签名机制：iOS App 的签名链是怎样的（Apple 根证书 → 开发者证书 → App）？重签名的原理？
Provisioning Profile：描述文件的作用？开发、Ad-Hoc、企业、AppStore 四种证书的区别？
沙盒机制：App 沙盒有什么限制？App Group 如何实现跨 App 共享数据？
动态库：iOS 允许加载动态库吗？.framework 和 .a 的区别？Embed & Sign 选项是做什么的？
冷启动与 dyld：dyld 在启动时做了什么？rebase、bind、lazy bind 分别是什么？+load 和 C++ 静态构造器的执行时机？
多进程：iOS 有多进程吗？Extension、WKWebView 的进程模型是怎样的？

上次更新: 2026/06/28, 17:55:19

← 技术招聘的方法论经典面试题汇总→