--- theme: mk-cute --- # 前言面试专题前面的百度篇，腾讯篇，阿里篇，京东篇，bilibili篇，网易篇，字节篇，小红书，小米，携程十大板块已经更新完了，还剩下最后个专题~持续更新中。 **1.[12W字；2022最新Android11位大厂面试专题（一）百度篇](https://juejin.cn/post/7146205842608488485)** **2.[12W字；2022最新Android11位大厂面试专题（二）阿里篇](https://juejin.cn/post/7146209856113475591)** **3.[12W字；2022最新Android11位大厂面试专题（三）腾讯篇](https://juejin.cn/post/7146543303985463332)** **4.[面霸养成记；50万字Android面试文档（四五）字节，京东篇](https://juejin.cn/post/7146576872103477279)** **5.[面霸养成记；50万字Android面试文档（六七）网易，Bilibili篇](https://juejin.cn/post/7146935125320663070)** **6.[面霸养成记；50万字Android面试文档（八九）小红书，小米篇](https://juejin.cn/post/7147623196399763464)** **7.[含泪刷128道面试题，50万字2022最新Android11位大厂面试专题（七）](https://juejin.cn/post/7147970341246074887)** 一共50W字的文档，面试专题12W字只是一小部分，字数限制，分几篇更。 >关注公众号：**Android苦做舟** > >提前解锁 **《整套50W字Android体系PDF》**，让学习更贴近未来实战。 > **总共囊括**： > **1.腾讯Android开发笔记（33W字）** > > **2.2022最新Android十一位大厂面试专题（12W字）** > > **3.音视频经典面试题（6W字）** > >**4.Jetpack全家桶** > >**5.Android 性能监控框架Matrix** > >**6.JVM** > >**7.车载应用开发** **共十一模块，今天来更新第11专题爱奇艺篇，面试专题完结啦🤣** ## 十一丶爱奇艺 ### 1.Android布局层级过深为什么会对性能有影响？为什么Compose没有布局嵌套问题？做过布局性能优化的同学都知道，为了优化界面加载速度，要尽可能的减少布局的层级。这主要是因为布局层级的增加，可能会导致测量时间呈指数级增长。而Compose却没有这个问题，它从根本上解决了布局层级对布局性能的影响: Compose界面只允许一次测量。这意味着随着布局层级的加深，测量时间也只是线性增长的. 下面我们就一起来看看Compose到底是怎么只测量一次就把活给干了的,本文主要包括以下内容： - 布局层级过深为什么影响性能? - Compose为什么没有布局嵌套问题? #### ①布局层级过深为什么影响性能? 我们总说布局层级过深会影响性能，那么到底是怎么影响的呢？主要是因为在某些情况下ViewGroup会对子View进行多次测量举个例子 ``` ``` - LinearLayout宽度为`wrap_content`,因此它将选择子View的最大宽度为其最后的宽度 - 但是有个子View的宽度为`match_parent`，意思它将以LinearLayout的宽度为宽度，这就陷入死循环了 - 因此这时候， LinearLayout 就会先以0为强制宽度测量一下子View，并正常地测量剩下的其他子View，然后再用其他子View里最宽的那个的宽度，二次测量这个`match_parent`的子 View，最终得出它的尺寸，并把这个宽度作为自己最终的宽度。 - 这是对单个子View的二次测量，如果有多个子View写了`match_parent` ，那就需要对它们每一个都进行二次测量。 - 除此之外，如果在LinearLayout中使用了weight会导致测量3次甚至更多,重复测量在Android中是很常见的上面介绍了为什么会出现重复测量，那么会有什么影响呢？不过是多测量了几次，会对性能有什么大的影响吗？之所以需要避免布局层级过深是因为它对性能的影响是指数级的 - 如果我们的布局有两层，其中父View会对每个子View做二次测量，那它的每个子View一共需要被测量 2 次 - 如果增加到三层，并且每个父View依然都做二次测量，这时候最下面的子View被测量的次数就直接翻倍了，变成 4 次 - 同理，增加到 4 层的话会再次翻倍，子 View 需要被测量 8 次 ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4d7d0531d05f4fad8a85227725a689c6~tplv-k3u1fbpfcp-watermark.image?) 也就是说，对于会做二次测量的系统，层级加深对测量时间的影响是指数级的,这就是Android官方文档建议我们减少布局层级的原因 #### ②Compose为什么没有布局嵌套问题? 我们知道，Compose只允许测量一次，不允许重复测量。如果每个父组件对每个子组件只测量一次，那就直接意味着界面中的每个组件只会被测量一次 ![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/110276b0f90d43659756155931c49fcb~tplv-k3u1fbpfcp-watermark.image?) 这样即使布局层级加深，测量时间却没有增加，把组件加载的时间复杂度从O(2ⁿ) 降到了 O(n)。那么问题就来了，上面我们已经知道，多次测量有时是必要的，但是为什么Compose不需要呢？ Compose中引入了固有特性测量(Intrinsic Measurement) 固有特性测量即Compose允许父组件在对子组件进行测量之前，先测量一下子组件的「固有尺寸」我们上面说的，ViewGroup的二次测量，也是先进行这种「粗略测量」再进行最终的「正式测量」，使用固有特性测量可以产生同样的效果而使用固有特性测量之所以有性能优势，主要是因为其不会随着层级的加深而加倍，固有特性测量也只进行一次 Compose会先对整个组件树进行一次Intrinsic测量，然后再对整体进行正式的测量。这样开辟两个平行的测量过程，就可以避免因为层级增加而对同一个子组件反复测量所导致的测量时间的不断加倍了。 ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f2bc8346d23d4a8ca130cf4c49172053~tplv-k3u1fbpfcp-watermark.image?) 总结成一句话就是，在Compose里疯狂嵌套地写界面，和把所有组件全都写进同一层里面，性能是一样的！所以Compose没有布局嵌套问题 ### 2.kotlin协程 kotlin(完整版)→33W字开发笔记中有详细版 ### 3.HashMap原理(第三章第10题） ### 4.算法：手写快排 #### 快速排序算法思路从小到大排序时 **快速排序算法原理**：快速排序利用了分治的思想，采用递归来实现如果要排序一个数组，先取一个参照数（这里取数组最后一个数作为参照）把数组从分成以参数为”中间“结点的前后2部分，数组中参照数之前的都小于参照数，参照数之后的都大于参照数, 然后，对参照数的前后两部分分别排序这样整个数组就有序了。递推公式： - quickSort(p,r) = partition(p,r)+quickSortCore(p,q-1)+quickSortCore(q+1,r); - q = partition(p,r); - 终止条件：p>=r 不用继续分解 - p: 每段的起始下标 - r: 每段的末尾下标 - q: 每段的"中间"下标最好情况下： ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f8d5b96c45124ec183d9ad34664ece35~tplv-k3u1fbpfcp-watermark.image?) 最坏情况下 ![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6f0739806d844db5ae117ad6bbeb9aee~tplv-k3u1fbpfcp-watermark.image?) **时间复杂度：O(N*logN) ~ O(n 2 n^2n 2 )** 1.快速排序算法的耗时是在拆分这里(partition)，通过上图可以看出是个完全二叉树，当n规模足够大时就可以近似看成是满二叉树，由partition函数来看合并的时间复杂度是O(n) - 最好情况下 O(nlogn)：即拆分时左右2部分均分，时间复杂度由上图可知每层处理的数据规模都是n 假设每层耗时常量t 树高为h,那么总耗时=n*t*h, T(n) = n*t*log ⁡ 2 n \log_2 nlog 2 n (参考:完全二叉树的树高H和结点数N的关系) - 最坏情况下 O(n 2)：即当数组数据已经有序时例如{1,2,3,4,5},此时无法均分,取5为参照数,每次就只会执行quickSortCore(p,q-1)方法,partition处理的数据规模就是每次:T(n) = (n+n-1+ …1)*t = t*n*(n-1)/2 (t指单个数据处理耗时,是个常量值,n指数据规模) 空间复杂度：O(logn)~O(n nn)，快速排序虽然没有申请额外的空间,但是有递归函数调用栈的内存消耗。 - 最好情况下 O(logn)：即拆分时左右2部分均分时树深度最深也就是树的高度可表示log ⁡ 2 n \log_2 nlog 2 n。 - 最坏情况下 O(n nn)：即当数组数据已经有序时例如{1,2,3,4,5},此时无法均分,取5为参照数,每次就只会执行quickSortCore(p,q-1)方法一直往下递归快速排序是不稳定的排序算法。例如{6,8,7,6,3,5,9,4},取末尾4为参照数,拆分时,当下标j=4指向数3时此时下标i=-1,r=7 ,arr[j] < arr[r] 进入交换导致第一个6在第二个6的后面顺序发生改变。总结:快速排序算法时间复杂度：O(N*logN) ~ O(n 2 n^2n 2), 空间复杂度：O(logn) ~ O(n nn),该算法可以进行进一步优化：出发点就是尽量使其每次左右均分数据规模 #### ①核心代码 ``` private static int[] quickSort(int[] arr) { if (null != arr && arr.length > 0) { quickSortCore(arr, 0, arr.length - 1); } return arr; } private static void quickSortCore(int[] arr, int p, int r) { if (p >= r) { return; } int q = partition(arr, p, r); quickSortCore(arr, p, q - 1); quickSortCore(arr, q + 1, r); } /** * [p,i] 小于 arr[r]的区域 * [i+1,j-1] 大于 arr[r]的区域 * [j,r-1] 未处理的区域 * r 下标默认是分区点参照的元素 * p,j,i,r 均指下标,arr[r]指参照数 * * @param arr * @param p * @param r * @return */ private static int partition(int[] arr, int p, int r) { // 初始时设置i= -1,表示小于参照数的区域是空,i标识小于参照数的区域末尾位置 int i = p - 1; // 扫描未处理区域和挨个和参照数进行比较 for (int j = p; j < r; j++) { // 比参照数小的放到[p,i]区域,[p,i]区域就开始扩大了 if (arr[j] < arr[r]) { swap(arr, i + 1, j); i++; } } // 再把参照数放到比它小的区域的后一个下标位置,这样参照数左侧就是全部小于参照数的数，右侧就是大于参照数的数，可以继续往下拆分左右2侧递归了 swap(arr, i + 1, r); return i + 1; } private static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } ``` #### ②测试用例 ``` package arithmetic.ecut.com.排序.a_快速排序; /** * 快速排序 * * @author 起凤 * @description: TODO * @date 2022/4/11 */ public class QuickSort { public static void main(String[] args) { int[] arr = {1, 5, 6, 2, 3, 4}; print(quickSort(arr)); int[] arr1 = {2, 3, 1, 4, -1, 8, -1}; print(quickSort(arr1)); int[] arr2 = {-1, 7, 1, 4, 5, 8, 7}; print(quickSort(arr2)); } private static int[] quickSort(int[] arr) { if (null != arr && arr.length > 0) { quickSortCore(arr, 0, arr.length - 1); } return arr; } private static void quickSortCore(int[] arr, int p, int r) { if (p >= r) { return; } int q = partition(arr, p, r); quickSortCore(arr, p, q - 1); quickSortCore(arr, q + 1, r); } /** * [p,i] 小于 arr[r]的区域 * [i+1,j-1] 大于 arr[r]的区域 * [j,r-1] 未处理的区域 * r 下标默认是分区点参照的元素 * p,j,i,r 均指下标,arr[r]指参照数 * * @param arr * @param p * @param r * @return */ private static int partition(int[] arr, int p, int r) { // 初始时设置i= -1,表示小于参照数的区域是空,i标识小于参照数的区域末尾位置 int i = p - 1; // 扫描未处理区域和挨个和参照数进行比较 for (int j = p; j < r; j++) { // 比参照数小的放到[p,i]区域,[p,i]区域就开始扩大了 if (arr[j] < arr[r]) { swap(arr, i + 1, j); i++; } } // 再把参照数放到比它小的区域的后一个下标位置,这样参照数左侧就是全部小于参照数的数，右侧就是大于参照数的数，可以继续往下拆分左右2侧递归了 swap(arr, i + 1, r); return i + 1; } private static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } private static void print(int[] sort) { StringBuilder builder = new StringBuilder(); for (int i = 0; i < sort.length; i++) { builder.append(sort[i]).append(","); } System.out.println(builder); } } ``` ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e6d80d5118ed47a3a0e5fcc2b248267b~tplv-k3u1fbpfcp-watermark.image?) ### 5.Activity启动模式 #### **①标准模式——standard** 这个启动模式是最常见的，Activity 默认就是此启动模式。每启动一次 Activity，就会创建一个新 Activity 实例并置于栈顶。谁启动了这个 Activity，那么这个 Activity 就运行在启动它的那个 Activity 所在的栈中。其实后面这句话挺重要，之前学习的时候并不是太理解这句话，但也是在不久前遇到了一个问题让我重新理解了：Android 中有多窗口模式，这个问题是在多窗口模式下发现的，我们应用中有个地方会调用设置中的页面来选择声音，在正常模式下是没有问题的，但是多窗口模式下就会重新启动一个任务栈，但我们系统中限制多窗口模式下只能有一个应用在前台，结果我们自己的应用被干掉了。。。大家一定引以为戒，知识点的每一句话都有可能有用！下面咱们来测试下标准模式，先一步一步来，先从第一个页面跳转到第二个页面，看下 log： ``` E/MainActivity: onCreate: E/MainActivity: onStart: E/MainActivity: onResume: E/MainActivity: onPause: E/TwoActivity: onCreate: E/TwoActivity: onStart: E/TwoActivity: onResume: E/MainActivity: onStop: ``` 没什么问题，和预想的一致，然后回到桌面再打开应用，看下 log： ``` E/TwoActivity: onPause: E/TwoActivity: onStop: E/TwoActivity: onStart: E/TwoActivity: onResume: ``` 嗯，没问题，现在任务栈里有两个 Activity，点击返回键依次退出再来看下 log： ``` E/TwoActivity: onPause: E/MainActivity: onStart: E/MainActivity: onResume: E/TwoActivity: onStop: E/TwoActivity: onDestroy: E/MainActivity: onPause: E/MainActivity: onStop: ``` 从第二个 Activity 回到第一个 Activity 可以理解，但是大家有没有发现第一个 Activity 并没有走 onDestroy ，这里引用下一个厉害的大哥文章中的描述吧： **Android 12 以前，当我们处于 Root Activity 时，点击返回键时，应用返回桌面， Activity 执行 onDestroy，程序结束。Android 12 起同样场景下 Activity 只会 onStop，不再执行 onDestroy。** 到这里标准模式就差不多了，因为这是默认的启动模式，大家使用也最频繁，也就不再啰嗦。 #### ② **栈顶模式——singleTop** 栈顶模式其实很好理解，如果栈顶存在该activity的实例，则复用，不存在新建放入栈顶，它的表现几乎和上面刚说的标准模式一模一样，栈顶模式的 Activity 实例可以无限多，唯一的区别是如果在栈顶已经有一个相同类型的 Activity 实例，那么 Intent 则不会再去创建一个 Activity，而是通过 `onNewIntent()` 发送到现有的Activity。比如应用现在在一个详情页面，而且这个页面启动模式为栈顶模式，这个时候来了一个通知，点击通知正好要跳转到详情页面，那么这个时候任务栈就不会为这个 Activity 再创建一个实例而用已经在栈顶的之前创建好的 Activity 实例。 #### **③栈内复用——singleTask** 这个模式之前真的没有理解透彻，之前我理解的就是如果栈内存在该 Activity 的实例则进行复用，如果不存在则创建。接下来将刚才的 Demo 中的主 Activity 的启动模式改为栈内复用，先来看下启动应用后点击跳转到第二个 Activity 的 log： ``` E/MainActivity: onCreate: E/MainActivity: onStart: E/MainActivity: onResume: E/MainActivity: onPause: E/TwoActivity: onCreate: E/TwoActivity: onStart: E/TwoActivity: onResume: E/MainActivity: onStop: ``` 目前来看还是比较正常的，接下来直接回到桌面，再来看下 log： ``` E/TwoActivity: onPause: E/TwoActivity: onStop: ``` 也还对着呢，然后再次打开应用再看 log： ``` E/TwoActivity: onDestroy: E/MainActivity: onStart: E/MainActivity: onResume: ``` 是不是不对了，我本来想让应用回到第二个 Activity，但为什么第二个 Activity 直接销毁了？其实栈内复用中还有一点要注意，也正是我忽略的重要一点：栈内复用模式会将该实例上边的 Activity 全部出栈，将该实例置于栈顶，这也就是出现文章开头我说的那个问题的根本原因。 #### **④单例模式——singleInstance** 单例模式，顾名思义，就是新开一个任务栈，该栈内只存放当前实例。比如说项目中语音通话功能，来电显示页面采用的就可以采用单例模式进行处理。当然还有别的方法来新开任务栈，比如说启动 Activity 的时候加上 `FLAG_ACTIVITY_NEW_TASK` ，也会开启一个新的任务栈。这里需要注意，即使将 Activity 的启动模式设置为单例模式或者添加了 flag，也不会出现像上面某信那种效果，因为 Activity 的 taskAffinity 是一样的，但如果将 Activity 的 taskAffinity 修改下，就可以出现类似于上面某信的效果，如下图所示： ![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6534826802de455f925b43369ff3ceeb~tplv-k3u1fbpfcp-watermark.image?) ### 6.Activity四大启动方式生命周期 #### ①Standard 标准模式启动 android:launchMode=“standard” 归纳：直接在栈顶新建一个Activity进行启动生命周期： ===>开启一个Activity I/LifecycleActivity_A: onCreate: I/LifecycleActivity_A: onStart: I/LifecycleActivity_A: onResume: ===>退出 I/LifecycleActivity_A: onPause: I/LifecycleActivity_A: onStop: I/LifecycleActivity_A: onDestroy: #### ②SingleTop 栈顶启动 manifest：android:launchMode=“singleTop” FLAG：FLAG_ACTIVITY_SINGLE_TOP 归纳：当启动的Activity在栈顶时，则进行复用，如果栈顶没有时使用默认的Standard模式生命周期： ===> 启动A： A: onCreate: A: onStart: A: onResume: ===> 栈顶启动： A: onPause: A: onNewIntent: A: onResume: `FLAG_ACTIVITY_CLEAR_TOP`启动栈顶复用不走`newIntent（）`，将栈内的需要启动的activity移到最顶处启动，并将上面的activity全部出栈销毁。 ===> 启动A FLAG_ACTIVITY_NEW_TASK I/LifecycleActivity_A: onCreate: I/LifecycleActivity_A: onStart: I/LifecycleActivity_A: onResume: I/LifecycleActivity_A: onPause: ===> 启动B FLAG_ACTIVITY_NEW_TASK I/LifecycleActivity_A: onPause: I/LifecycleActivity_B: onCreate: I/LifecycleActivity_B: onStart: I/LifecycleActivity_B: onResume: I/LifecycleActivity_A: onStop: ===> 启动A FLAG_ACTIVITY_CLEAR_TOP I/LifecycleActivity_B: onPause: I/LifecycleActivity_A: onDestroy: I/LifecycleActivity_A: onCreate: I/LifecycleActivity_A: onStart: I/LifecycleActivity_A: onResume: I/LifecycleActivity_B: onStop: I/LifecycleActivity_B: onDestroy: ===>A退出 I/LifecycleActivity_A: onPause: I/LifecycleActivity_A: onStop: I/LifecycleActivity_A: onDestroy: #### ③SingleTask 栈内复用模式 android:launchMode=“singleTask” 归纳：当栈内有需要启动的Activity时，则将该Activity移动到栈顶，并在栈中这个activity顶部的activity全部出栈销毁。生命周期： ===> 启动A： A: onCreate: A: onStart: A: onResume: ===> 启动B： A: onPause: B: onCreate: B: onStart: B: onResume: A: onStop: ===> 栈内启动A： B: onPause: A: onNewIntent: A: onRestart: A: onStart: A: onResume: B: onStop: B: onDestroy: #### ④FLAG_ACTIVITY_REORDER_TO_FRONT启动 ===>启动A FLAG_ACTIVITY_NEW_TASK I/LifecycleActivity_A: onCreate: I/LifecycleActivity_A: onStart: I/LifecycleActivity_A: onResume: ===> 启动B FLAG_ACTIVITY_NEW_TASK I/LifecycleActivity_A: onPause: I/LifecycleActivity_B: onCreate: I/LifecycleActivity_B: onStart: I/LifecycleActivity_B: onResume: I/LifecycleActivity_A: onStop: ===> 启动A FLAG_ACTIVITY_REORDER_TO_FRONT I/LifecycleActivity_B: onPause: I/LifecycleActivity_A: onNewIntent: I/LifecycleActivity_A: onRestart: I/LifecycleActivity_A: onStart: I/LifecycleActivity_A: onResume: I/LifecycleActivity_B: onStop: ===>A退出 I/LifecycleActivity_A: onPause: I/LifecycleActivity_B: onRestart: I/LifecycleActivity_B: onStart: I/LifecycleActivity_B: onResume: I/LifecycleActivity_A: onStop: I/LifecycleActivity_A: onDestroy: ===>B退出 I/LifecycleActivity_B: onPause: I/LifecycleActivity_B: onStop: I/LifecycleActivity_B: onDestroy: #### ⑤SingleInstance 单例启动模式 android:launchMode=“singleinstance” 归纳：单独创建一个栈控件启动这个Activity，常用于启动壁纸，电话，闹钟等界面实现。 ### 7.有序广播实例有序广播：按照接收者的优先级接收，只有一个广播接收者能接收信息，在此广播接收者的逻辑执行完毕后，才会继续传递。 abortBroadcast（）；终止广播有序广播功能概述： ![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9ca197e5d49f47448057d3237d79bb1a~tplv-k3u1fbpfcp-watermark.image?) 广播类型： ![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/65c01d6f61c64176ad80d95d6c1209b4~tplv-k3u1fbpfcp-watermark.image?) activity_main.xml ```