[Java、Android面试]_24_Compose为什么绘制要比XML快？(高频问答)

本人今年参加了很多面试，也有幸拿到了一些大厂的offer，整理了众多面试资料，后续还会分享众多面试资料。

整理成了面试系列，由于时间有限，每天整理一点，后续会陆续分享出来，感兴趣的朋友可关注+收藏

文章目录

- [1. XML结构](#1. XML结构)
- [2. Compose](#2. Compose)

1. XML结构

XML布局文件的界面层级要尽量地少，越少越好，因为层级的增加会大幅拖慢界面的加载。这种拖慢的主要原因就在于各种 Layout 的重复测量。虽然重复测量对于布局过程是必不可少的，但这也确实让界面层级的数量对加载时间的影响变成了指数级。

java 复制代码

1.<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.    android:layout_width="wrap_content"  
3.    android:layout_height="wrap_content"  
4.    android:orientation="vertical">  
5.    <View  
6.        android:layout_width="match_parent"  
7.        android:layout_height="48dp" />  
8.    <View  
9.        android:layout_width="120dp"  
10.        android:layout_height="48dp" />  
11.    <View  
12.        android:layout_width="160dp"  
13.        android:layout_height="48dp" />  
14.</LinearLayout>

如上代码：LinearLayout的宽度是"wrap_content"，而子布局有个"match_parent"!这时候， LinearLayout 就会先以 0 为强制宽度测量一下这个子 View，并正常地测量剩下的其他子 View，然后再用其他子 View 里最宽的那个的宽度，二次测量这个match_parent 的子 View，最终得出它的尺寸，并把这个宽度作为自己最终的宽度。这时就对子View造成了二次测量。

这是对单个子 View 的二次测量，如果有多个子 View 写了 match_parent ，那就需要对它们每一个都进行二次测量。

重复测量是 ViewGroup 实现正确测量所必需的手段，但同时也让我们需要非常注意尽量减少布局的层级。为什么呢？来看一个最简单的例子，如果我们的布局有两层，其中父 View 会对每个子 View 做二次测量，那它的每个子 View 一共需要被测量 2 次。

如果增加到三层，并且每个父 View 依然都做二次测量，这时候最下面的子 View 被测量的次数就直接翻倍了，变成 4 次。如下图所示：

当然了，现实中并不是每个父 View 都会进行二次测量，以及有些父 View 会对子 View 做三次或者更多次的测量，所以这只是一个粗略估计，不过------大致就是这个数量级了。

而 O(2ⁿ) 这种指数型的时间复杂度，说白了就是，View 的层级每增加 1，加载时间就会翻一倍。

2. Compose

Compose 禁用了二次测量，但加入了一个新东西：Intrinsic Measurement，官方把它翻译做「固有特性测量」。

所谓的 Intrinsic Measurement，指的是 Compose 允许父组件在对子组件进行测量之前，先测量一下子组件的「固有尺寸」，直白地说就是「你内部内容的最大或者最小尺寸是多少」。这是一种粗略的测量，虽说没有真正的「二次测量」模式那么自由，但功能并不弱，因为各种 Layout 里的重复测量，其实本来就是先进行这种「粗略测量」再进行最终的「正式测量」的------比如刚才说的那种「外面 wrap_content 里面 match_parent」的，对吧？想想是不是？这种「粗略」的测量是很轻的，并不是因为它量得快，而是因为它在机制上不会像传统的二次测量那样，让组件的测量时间随着层级的加深而不断加倍。

当界面需要这种 Intrinsic Measurement------也就是说那个所谓的「固有特性测量」------的时候，Compose 会先对整个组件树进行一次 Intrinsic 测量，然后再对整体进行正式的测量。这样开辟两个平行的测量过程，就可以避免因为层级增加而对同一个子组件反复测量所导致的测量时间的不断加倍了。

此时的时间复杂度为O(2n)=O(n)，所以更快！