@Autowired注解相信每个Spring开发者都不陌生了！在DD的Spring Boot基础教程和Spring Cloud基础教程中也都经常会出现。

但是当我们使用IDEA写代码的时候，经常会发现@Autowired注解下面是有小黄线的，我们把小鼠标悬停在上面，可以看到这个如下图所示的警告信息：

那么为什么IDEA会给出Field injection is not recommended这样的警告呢？

下面带着这样的问题，一起来全面的了解下Spring中的三种注入方式以及他们之间在各方面的优劣。

Spring中的三种依赖注入方式

Field Injection

@Autowired注解的一大使用场景就是Field Injection。

具体形式如下：

@Controller

public class UserController {



    @Autowired

    private UserService userService;



}

这种注入方式通过Java的反射机制实现，所以private的成员也可以被注入具体的对象。

Constructor Injection

Constructor Injection是构造器注入，是我们日常最为推荐的一种使用方式。

具体形式如下：

@Controller

public class UserController {



    private final UserService userService;



    public UserController(UserService userService){

        this.userService = userService;

    }



}

这种注入方式很直接，通过对象构建的时候建立关系，所以这种方式对对象创建的顺序会有要求，当然Spring会为你搞定这样的先后顺序，除非你出现循环依赖，然后就会抛出异常。

Setter Injection

Setter Injection也会用到@Autowired注解，但使用方式与Field Injection有所不同，Field Injection是用在成员变量上，而Setter Injection的时候，是用在成员变量的Setter函数上。

具体形式如下：

@Controller

public class UserController {



    private UserService userService;



    @Autowired

    public void setUserService(UserService userService){

        this.userService = userService;

    }

}

这种注入方式也很好理解，就是通过调用成员变量的set方法来注入想要使用的依赖对象。

三种依赖注入的对比

在知道了Spring提供的三种依赖注入方式之后，我们继续回到本文开头说到的问题：IDEA为什么不推荐使用Field Injection呢？

我们可以从多个开发测试的考察角度来对比一下它们之间的优劣：

可靠性

从对象构建过程和使用过程，看对象在各阶段的使用是否可靠来评判：

• Field Injection：不可靠


• Constructor Injection：可靠


• Setter Injection：不可靠

由于构造函数有严格的构建顺序和不可变性，一旦构建就可用，且不会被更改。

可维护性

主要从更容易阅读、分析依赖关系的角度来评判：

• Field Injection：差


• Constructor Injection：好


• Setter Injection：差

还是由于依赖关键的明确，从构造函数中可以显现的分析出依赖关系，对于我们如何去读懂关系和维护关系更友好。

可测试性

当在复杂依赖关系的情况下，考察程序是否更容易编写单元测试来评判

• Field Injection：差


• Constructor Injection：好


• Setter Injection：好

Constructor Injection和Setter Injection的方式更容易Mock和注入对象，所以更容易实现单元测试。

灵活性

主要根据开发实现时候的编码灵活性来判断：

• Field Injection：很灵活


• Constructor Injection：不灵活


• Setter Injection：很灵活

由于Constructor Injection对Bean的依赖关系设计有严格的顺序要求，所以这种注入方式不太灵活。相反Field Injection和Setter Injection就非常灵活，但也因为灵活带来了局面的混乱，也是一把双刃剑。

循环关系的检测

对于Bean之间是否存在循环依赖关系的检测能力：

• Field Injection：不检测


• Constructor Injection：自动检测


• Setter Injection：不检测

性能表现

不同的注入方式，对性能的影响

• Field Injection：启动快


• Constructor Injection：启动慢


• Setter Injection：启动快

主要影响就是启动时间，由于Constructor Injection有严格的顺序要求，所以会拉长启动时间。

所以，综合上面各方面的比较，可以获得如下表格：

结果一目了然，Constructor Injection在很多方面都是优于其他两种方式的，所以Constructor Injection通常都是首选方案！

而Setter Injection比起Field Injection来说，大部分都一样，但因为可测试性更好，所以当你要用@Autowired的时候，推荐使用Setter Injection的方式，这样IDEA也不会给出警告了。同时，也侧面也反映了，可测试性的重要地位啊！

总结

最后，对于今天的问题讨论，我们给出两个结论，方便大家记忆：

1. 依赖注入的使用上，Constructor Injection是首选。


2. 使用@Autowired注解的时候，要使用Setter Injection方式，这样代码更容易编写单元测试。

好了，今天的学习就到这里！如果您学习过程中如遇困难？可以加入我们超高质量的Spring技术交流群，参与交流与讨论，更好的学习与进步！

题目

杨辉三角

给定一个非负整数 numRows， 生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:

输入: numRows = 5

输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

示例 2:

输入: numRows = 1

输出: [[1]]

提示:

• 1 <= numRows <= 30

题解

解题分析

杨辉三角介绍：

杨辉三角，是二项式系数在三角形中的一种几何排列，南宋时期数学家杨辉在 1261年 所著《详解九章算法》中出现。

在欧洲，帕斯卡（1623-1662）在1654年发现这一数学规律，所以这个又叫做帕斯卡三角形。帕斯卡的发现比 杨辉 要迟393年，比 贾宪 迟600年。
杨辉三角是中国数学史上的一个伟大成就。

杨辉三角形的规律如题目中所示。

题解思路

1. 定义一个集合存储结果集


2. 定义一个两重循环，分别进行运算，row 数为 numRows, 列数的值为 0 -> i 其中 i 表示当前是第几行.


3. 如果当前 row 的列是第一列或最后一个列的当前的值为 1。


4. 当前行其他的列的其他数据, 等于 re.get(i-1).get(j-) + re.get(i -1).get(j) 之和

复杂度分析

• 时间复杂度：O(num * numRow ^2)


• 空间复杂度：O(1)

解题代码

题解代码如下（代码中有详细的注释说明）：

class Solution {

    public List<List<Integer>> generate(int numRows) {

        List<List<Integer>> re = new ArrayList<>();

        for (int i =0; i< numRows; i++) {

            List<Integer>  row = new ArrayList<>();

            for (int j=0; j<=i; j++) {

                // 行中的第一数据和最后一个数据的值为 1

                if (j == 0 || j == i) {

                    row.add(1);

                } else {

                    // 其他数据, 等于 re.get(i-1).get(j-) + re.get(i -1).get(j) 之和

                    row.add(re.get(i -1).get(j -1) + re.get(i -1).get(j));

                }

            }

            re.add(row);

        }

        return re;

    }

}

提交后反馈结果：

前言

打开Android架构组件页面,我们可以发现一些最新发布的jetpack组件，如Room，DataStore, Paging3,DataBinding 等都支持了Flow

Google开发者账号最近也发布了几篇使用Flow的文章，比如：从 LiveData 迁移到 Kotlin 数据流

看起来官方在大力推荐使用Flow取代LiveData，那么问题来了,有必要吗？

我LiveData用得好好的，有必要再学Flow吗?本文主要回答这个问题,具体包括以下内容

1.LiveData有什么不足?

2.Flow介绍以及为什么会有Flow

3.SharedFlow与StateFlow的介绍与它们之间的区别

本文具体目录如下所示：

1. LiveData有什么不足?

1.1 为什么引入LiveData?

要了解LiveData的不足，我们先了解下LiveData为什么被引入

LiveData 的历史要追溯到 2017 年。彼时，观察者模式有效简化了开发，但诸如 RxJava 一类的库对新手而言有些太过复杂。为此，架构组件团队打造了 LiveData: 一个专用于 Android 的具备自主生命周期感知能力的可观察的数据存储器类。LiveData 被有意简化设计，这使得开发者很容易上手；而对于较为复杂的交互数据流场景，建议您使用 RxJava，这样两者结合的优势就发挥出来了

可以看出,LiveData就是一个简单易用的，具备感知生命周期能力的观察者模式

它使用起来非常简单，这是它的优点，也是它的不足，因为它面对比较复杂的交互数据流场景时，处理起来比较麻烦

1.2 LiveData的不足

我们上文说过LiveData结构简单，但是不够强大，它有以下不足

1.LiveData只能在主线程更新数据

2.LiveData的操作符不够强大,在处理复杂数据流时有些捉襟见肘

关于LiveData只能在主线程更新数据，有的同学可能要问，不是有postValue吗？其实postValue也是需要切换到到主线程的,如下图所示：



这意味着当我们想要更新LiveData对象时，我们会经常更改线程（工作线程→主线程）,如果在修改LiveData后又要切换回到工作线程那就更麻烦了,同时postValue可能会有丢数据的问题。

2. Flow介绍

Flow 就是 Kotlin 协程与响应式编程模型结合的产物，你会发现它与 RxJava 非常像，二者之间也有相互转换的 API，使用起来非常方便。

2.1 为什么引入Flow

为什么引入Flow，我们可以从Flow解决了什么问题的角度切入

1. LiveData不支持线程切换，所有数据转换都将在主线程上完成，有时需要频繁更改线程，面对复杂数据流时处理起来比较麻烦


2. 而RxJava又有些过于麻烦了，有许多让人傻傻分不清的操作符，入门门槛较高，同时需要自己处理生命周期，在生命周期结束时取消订阅

可以看出，Flow是介于LiveData与RxJava之间的一个解决方案，它有以下特点

• Flow 支持线程切换、背压


• Flow 入门的门槛很低，没有那么多傻傻分不清楚的操作符


• 简单的数据转换与操作符，如 map 等等


• 冷数据流，不消费则不生产数据,这一点与LiveData不同：LiveData的发送端并不依赖于接收端。


• 属于kotlin协程的一部分，可以很好的与协程基础设施结合

关于Flow的使用，比较简单，有兴趣的同学可参阅文档：Flow文档

3. SharedFlow介绍

我们上面介绍过,Flow 是冷流，什么是冷流？

• 冷流 :只有订阅者订阅时，才开始执行发射数据流的代码。并且冷流和订阅者只能是一对一的关系，当有多个不同的订阅者时，消息是重新完整发送的。也就是说对冷流而言，有多个订阅者的时候，他们各自的事件是独立的。


• 热流:无论有没有订阅者订阅，事件始终都会发生。当 热流有多个订阅者时，热流与订阅者们的关系是一对多的关系，可以与多个订阅者共享信息。

3.1 为什么引入SharedFlow

上面其实已经说得很清楚了，冷流和订阅者只能是一对一的关系，当我们要实现一个流，多个订阅者的需求时(这在开发中是很常见的)，就需要热流了

从命名上也很容易理解，SharedFlow即共享的Flow，可以实现一对多关系,SharedFlow是一种热流

3.2 SharedFlow的使用

我们来看看SharedFlow的构造函数

public fun <T> MutableSharedFlow(

    replay: Int = 0,

    extraBufferCapacity: Int = 0,

    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND

): MutableSharedFlow<T>

其主要有3个参数

1.replay表示当新的订阅者Collect时，发送几个已经发送过的数据给它，默认为0，即默认新订阅者不会获取以前的数据

2.extraBufferCapacity表示减去replay，MutableSharedFlow还缓存多少数据，默认为0

3.onBufferOverflow表示缓存策略，即缓冲区满了之后Flow如何处理，默认为挂起

简单使用如下：

//ViewModel

val sharedFlow=MutableSharedFlow<String>()



viewModelScope.launch{

      sharedFlow.emit("Hello")

      sharedFlow.emit("SharedFlow")

}



//Activity

lifecycleScope.launch{

    viewMode.sharedFlow.collect { 

       print(it)

    }

}

3.3 将冷流转化为SharedFlow

普通flow可使用shareIn扩展方法，转化成SharedFlow

    val sharedFlow by lazy {

        flow<Int> {

        //...

        }.shareIn(viewModelScope, WhileSubscribed(500), 0)

    }

shareIn主要也有三个参数：

@param scope 共享开始时所在的协程作用域范围

@param started 控制共享的开始和结束的策略

@param replay 状态流的重播个数

started 接受以下的三个值:

1.Lazily: 当首个订阅者出现时开始，在scope指定的作用域被结束时终止。

2.Eagerly: 立即开始，而在scope指定的作用域被结束时终止。

3.WhileSubscribed: 这种情况有些复杂，后面会详细讲解

对于那些只执行一次的操作，您可以使用Lazily或者Eagerly。然而，如果您需要观察其他的流，就应该使用WhileSubscribed来实现细微但又重要的优化工作

3.4 Whilesubscribed策略

WhileSubscribed策略会在没有收集器的情况下取消上游数据流,通过shareIn运算符创建的SharedFlow会把数据暴露给视图 (View)，同时也会观察来自其他层级或者是上游应用的数据流。

让这些流持续活跃可能会引起不必要的资源浪费，例如一直通过从数据库连接、硬件传感器中读取数据等等。当您的应用转而在后台运行时，您应当保持克制并中止这些协程。

public fun WhileSubscribed(

   stopTimeoutMillis: Long = 0,

   replayExpirationMillis: Long = Long.MAX_VALUE

)

如上所示，它支持两个参数：

• 1.stopTimeoutMillis 控制一个以毫秒为单位的延迟值，指的是最后一个订阅者结束订阅与停止上游流的时间差。默认值是 0 (立即停止).这个值非常有用，因为您可能并不想因为视图有几秒钟不再监听就结束上游流。这种情况非常常见——比如当用户旋转设备时，原来的视图会先被销毁，然后数秒钟内重建。


• 2.replayExpirationMillis表示数据重播的过时时间，如果用户离开应用太久，此时您不想让用户看到陈旧的数据，你可以用到这个参数

4. StateFlow介绍

4.1 为什么引入StateFlow

我们前面刚刚看了SharedFlow，为什么又冒出个StateFlow?

StateFlow 是 SharedFlow 的一个比较特殊的变种，StateFlow 与 LiveData 是最接近的，因为:

• 1.它始终是有值的。


• 2.它的值是唯一的。


• 3.它允许被多个观察者共用 (因此是共享的数据流)。


• 4.它永远只会把最新的值重现给订阅者，这与活跃观察者的数量是无关的。

可以看出，StateFlow与LiveData是比较接近的，可以获取当前的值，可以想像之所以引入StateFlow就是为了替换LiveData

总结如下：

1.StateFlow继承于SharedFlow,是SharedFlow的一个特殊变种

2.StateFlow与LiveData比较相近，相信之所以推出就是为了替换LiveData

4.2 StateFlow的简单使用

我们先来看看构造函数：

public fun <T> MutableStateFlow(value: T): MutableStateFlow<T> = StateFlowImpl(value ?: NULL)

1.StateFlow构造函数较为简单，只需要传入一个默认值

2.StateFlow本质上是一个replay为1，并且没有缓冲区的SharedFlow,因此第一次订阅时会先获得默认值

3.StateFlow仅在值已更新，并且值发生了变化时才会返回，即如果更新后的值没有变化，也没会回调Collect方法，这点与LiveData不同

与SharedFlow类似，我们也可以用stateIn将普通流转化成StateFlow

val result: StateFlow<Result<UiState>> = someFlow

    .stateIn(

        scope = viewModelScope, 

        started = WhileSubscribed(5000), 

        initialValue = Result.Loading

    )

与shareIn类似，唯一不同的时需要传入一个默认值

同时之所以WhileSubscribed中传入了5000，是为了实现等待5秒后仍然没有订阅者存在就终止协程的功能，这个方法有以下功能

• 用户将您的应用转至后台运行，5 秒钟后所有来自其他层的数据更新会停止，这样可以节省电量。


• 最新的数据仍然会被缓存，所以当用户切换回应用时，视图立即就可以得到数据进行渲染。


• 订阅将被重启，新数据会填充进来，当数据可用时更新视图。


• 在屏幕旋转时，因为重新订阅的时间在5s内，因此上游流不会中止

4.3 在页面中观察StateFlow

与LiveData类似，我们也需要经常在页面中观察StateFlow

观察StateFlow需要在协程中，因此我们需要协程构建器，一般我们会使用下面几种

1. lifecycleScope.launch : 立即启动协程，并且在本 Activity或Fragment 销毁时结束协程。


2. LaunchWhenStarted 和 LaunchWhenResumed,它会在lifecycleOwner进入X状态之前一直等待，又在离开X状态时挂起协程

如上图所示：

1.使用launch是不安全的，在应用在后台时也会接收数据更新，可能会导致应用崩溃

2.使用launchWhenStarted或launchWhenResumed会好一些，在后台时不会接收数据更新，但是，上游数据流会在应用后台运行期间保持活跃，因此可能浪费一定的资源

这么说来，我们使用WhileSubscribed进行的配置岂不是无效了吗？订阅者一直存在，只有页面关闭时才会取消订阅

官方推荐repeatOnLifecycle来构建协程

在某个特定的状态满足时启动协程，并且在生命周期所有者退出该状态时停止协程,如下图所示。



比如在某个Fragment的代码中:

onCreateView(...) {

    viewLifecycleOwner.lifecycleScope.launch {

        viewLifecycleOwner.lifecycle.repeatOnLifecycle(STARTED) {

            myViewModel.myUiState.collect { ... }

        }

    }

}

当这个Fragment处于STARTED状态时会开始收集流，并且在RESUMED状态时保持收集，最终在Fragment进入STOPPED状态时结束收集过程。

结合使用repeatOnLifecycle API和WhileSubscribed,可以帮助您的应用妥善利用设备资源的同时，发挥最佳性能

4.4 页面中观察Flow的最佳方式

通过ViewModel暴露数据，并在页面中获取的最佳方式是:

• ✔️ 使用带超时参数的 WhileSubscribed 策略暴露 Flow。示例 1


• ✔️ 使用 repeatOnLifecycle 来收集数据更新。示例 2

最佳实践如上图所示，如果采用其他方式，上游数据流会被一直保持活跃，导致资源浪费

当然，如果您并不需要使用到Kotlin Flow的强大功能，就用LiveData好了 :)

5 StateFlow与SharedFlow有什么区别？

从上文其实可以看出，StateFlow与SharedFlow其实是挺像的，让人有些傻傻分不清，有时候也挺难选择该用哪个的

我们总结一下，它们的区别如下:

1. SharedFlow配置更为灵活，支持配置replay,缓冲区大小等，StateFlow是SharedFlow的特化版本，replay固定为1，缓冲区大小默认为0


2. StateFlow与LiveData类似，支持通过myFlow.value获取当前状态，如果有这个需求，必须使用StateFlow


3. SharedFlow支持发出和收集重复值，而StateFlow当value重复时，不会回调collect


4. 对于新的订阅者，StateFlow只会重播当前最新值，SharedFlow可配置重播元素个数（默认为0，即不重播）

可以看出,StateFlow为我们做了一些默认的配置，在SharedFlow上添加了一些默认约束，这些配置可能并不符合我们的要求

1. 它忽略重复的值，并且是不可配置的。这会带来一些问题，比如当往List中添加元素并更新时，StateFlow会认为是重复的值并忽略


2. 它需要一个初始值，并且在开始订阅时会回调初始值，这有可能不是我们想要的


3. 它默认是粘性的，新用户订阅会获得当前的最新值，而且是不可配置的,而SharedFlow可以修改replay

StateFlow施加在SharedFlow上的约束可能不是最适合您，如果不需要访问myFlow.value，并且享受SharedFlow的灵活性，可以选择考虑使用SharedFlow

总结

简单往往意味着不够强大，而强大又常常意味着复杂,两者往往不能兼得，软件开发过程中常常面临这种取舍。

LiveData的简单并不是它的缺点，而是它的特点。StateFlow与SharedFlow更加强大，但是学习成本也显著的更高.

我们应该根据自己的需求合理选择组件的使用

1. 如果你的数据流比较简单，不需要进行线程切换与复杂的数据变换，LiveData对你来说相信已经足够了


2. 如果你的数据流比较复杂，需要切换线程等操作，不需要发送重复值，需要获取myFlow.value，StateFlow对你来说是个好的选择


3. 如果你的数据流比较复杂，同时不需要获取myFlow.value，需要配置新用户订阅重播无素的个数，或者需要发送重复的值，可以考虑使用SharedFlow

线程间通信在 Android 系统中应用十分广泛，本文是一个系列文章，主要梳理了Android Java层的线程间通信机制-Handler

还是以一个简单的Handler示例开头

public void egHandler() {

    Looper.prepare();

    Looper.loop();

    

    Handler handler = new Handler() {

        @Override

        public void handleMessage(@NonNull Message msg) {

            // TODO; 处理 Event

        }

    };



    new Thread() {

        @Override

        public void run() {

            Message msg = Message.obtain(); // 注意： 此处和上篇文章中的示例不同

            msg.what = 0;

            handler.sendMessage(msg);

        }

    }.start();

}

为了避免重复的创建以及销毁 Message 对象带来的系统开销，Google 团队在Message.java中搞了一个MessagePool，在MessagePool中缓存了定量的Message对象

上面示例中使用的Message.obtain()是从Pool中拿到一个message对象。

MessagePool

源码路径：frameworks/base/core/java/android/os/Message.java

在Message.java中定义了四个成员变量

// MessagePool 同步锁

public static final Object sPoolSync = new Object();

// MessagePool Node节点

private static Message sPool;

// MessagePool Node个数

private static int sPoolSize = 0;

// MessagePool 最大容量

private static final int MAX_POOL_SIZE = 50;

从MessagePool中获取一个message对象，需要调用obtain方法，该方法重载了多个

obtain message

Message.obtain()

public static Message obtain() {

    // 上锁

    synchronized (sPoolSync) {

        if (sPool != null) {

            // 从sPool链表拿出头节点

            Message m = sPool;

            sPool = m.next;

            m.next = null;

            m.flags = 0; // clear in-use flag

            sPoolSize--;

            return m;

        }

    }

    return new Message();

}

Message.obtain(Message orig)

public static Message obtain(Message orig) {

    // 获取一个message

    Message m = obtain();

    // 将m和形参orig同步

    m.what = orig.what;

    m.arg1 = orig.arg1;

    m.arg2 = orig.arg2;

    m.obj = orig.obj;

    m.replyTo = orig.replyTo;

    m.sendingUid = orig.sendingUid;

    m.workSourceUid = orig.workSourceUid;

    if (orig.data != null) {

        m.data = new Bundle(orig.data);

    }

    m.target = orig.target;

    m.callback = orig.callback;



    return m;

}

Message.obtain(Handler h)

public static Message obtain(Handler h) {

    Message m = obtain();

    // 单独为新msg设置handler

    m.target = h;



    return m;

}

另外还有一些构造方法，整体实现思路差不多。

recycle message

Message.recycle

public void recycle() {

    if (isInUse()) {

        // InUse中被释放会抛出异常

        if (gCheckRecycle) {

            throw new IllegalStateException("This message cannot be recycled because it "

                                            + "is still in use.");

        }

        return;

    }

    // 释放

    recycleUnchecked();

}

Message.recycleUnchecked

@UnsupportedAppUsage

void recycleUnchecked() {

    // Mark the message as in use while it remains in the recycled object pool.

    // Clear out all other details.

    // 初始化flag，标记为InUse

    flags = FLAG_IN_USE;

    what = 0;

    arg1 = 0;

    arg2 = 0;

    obj = null;

    replyTo = null;

    sendingUid = UID_NONE;

    workSourceUid = UID_NONE;

    when = 0;

    target = null;

    callback = null;

    data = null;



    // 上锁，将需要释放的msg插入到链表头

    synchronized (sPoolSync) {

        // 注意这里，回收的过程中会判断当前链表的长度是否大于最大长度

        if (sPoolSize < MAX_POOL_SIZE) {

            next = sPool;

            sPool = this;

            sPoolSize++;

        }

    }

}

recycle与recycleUnchecked的区别在于：

• recycleUnchecked 不会检查当前msg是否在使用中，而是会直接回收掉该msg，放在链表的头部


• recycle 会判断当前的msg是否在使用，在使用中会抛出异常，非使用中直接调用recycleUnchecked进行回收

另外，recycleUnchecked不支持app是否，App中只能是否recycle

Message.isInUse

// Message 中两个成员变量

/*package*/ static final int FLAG_IN_USE = 1 << 0;



/** If set message is asynchronous */

/*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;



/*package*/ boolean isInUse() {

    return ((flags & FLAG_IN_USE) == FLAG_IN_USE);

}

Message.markInUse

@UnsupportedAppUsage

/*package*/ void markInUse() {

	flags |= FLAG_IN_USE;

}

这个flag的判断方式我有点不理解，还不如直接用数字判断，例如flag = 1就是InUse，难道是为了判断的更快一点采用|、&的方式？

理解为什么这么做的大佬在下面评论一下，不吝指出。

🔥 应用场景

Toast提示默认显示在界面底部，使用Toast.setGravity()将提示显示在中间，如下：

        Toast toast = Toast.makeText(this, str, Toast.LENGTH_SHORT);

        toast.setGravity(Gravity.CENTER, 0, 0);

        toast.show();

运行在在Android 12上无法显示，查看Logcat提示如下：

Toast: setGravity() shouldn't be called on text toasts, the values won't be used

意思就是：你不能使用toast调用setGravity，调用无效。哎呀，看给牛气的，咱看看源码找找原因

🔥 源码

💥 Toast.setGravity()

    /**

     * 设置Toast出现在屏幕上的位置。

     *

     * 警告：从 Android R 开始，对于面向 API 级别 R 或更高级别的应用程序，此方法在文本 toast 上调用时无效。

     */

    public void setGravity(int gravity, int xOffset, int yOffset) {

        if (isSystemRenderedTextToast()) {

            Log.e(TAG, "setGravity() shouldn't be called on text toasts, the values won't be used");

        }

        mTN.mGravity = gravity;

        mTN.mX = xOffset;

        mTN.mY = yOffset;

    }

妥了，人家就告诉你了 版本>=Android R(30),调用该方法无效。无效就无效呗，还不给显示了，过分。

Logcat的提示居然是在这里提示的，来都来了，咱们看看isSystemRenderedTextToast()方法。

💥 Toast.isSystemRenderedTextToast()

    /**

     *Text Toast 将由 SystemUI 呈现，而不是在应用程序内呈现，因此应用程序无法绕过后台自定义 Toast 限制。

     */

    @ChangeId

    @EnabledAfter(targetSdkVersion = Build.VERSION_CODES.Q)

    private static final long CHANGE_TEXT_TOASTS_IN_THE_SYSTEM = 147798919L;

    

    private boolean isSystemRenderedTextToast() {

        return Compatibility.isChangeEnabled(CHANGE_TEXT_TOASTS_IN_THE_SYSTEM) && mNextView == null;

    }

重点了。Text Toast 将由 SystemUI 呈现，而不是在应用程序内呈现。

清晰明了，可以这样玩，但是你级别不够，不给你玩。

事情整明白了，再想想解决解决方案。他说了Text Toast 将由 SystemUI 呈现，那我不用 Text 不就行了。

🔥 Toast 提供的方法

先看看Tast提供的方法：

有这几个方法。咱们实践一下。保险起见看看源码

💥 Toast.setView() 源码

    /**

     * 设置显示的View

     * @deprecated 自定义 Toast 视图已弃用。 应用程序可以使用 makeText 方法创建标准文本 toast，

     * 或使用 Snackbar

     */

    @Deprecated

    public void setView(View view) {

        mNextView = view;

    }

这个更狠，直接弃用。

• 
  

  要么老老实实的用默认的Toast。

  
  


• 
  

  要么使用 Snackbar。

  
  

🔥 Snackbar

Snackbar 就是一个类似Toast的快速弹出消息提示的控件(我是刚知道，哈哈)。

与Toast相比：

• 
  

  一次只能显示一个

  
  


• 
  

  与用户交互

  
  
  
  
  • 在右侧设置按钮来添加事件，根据 Material Design 的设计原则，只显示 1 个按钮 (添加多个,以最后的为准)
  
  
  
  


• 
  

  提供Snackbar显示和关闭的监听事件

  
  
  
  
  • BaseTransientBottomBar.addCallback(BaseCallback)
  
  
  
  

💥 代码实现

    showMessage(findViewById(android.R.id.content), str, Snackbar.LENGTH_INDEFINITE);

  

    public static void showMessage(View view, String str, int length) {

        Snackbar snackbar = Snackbar.make(view, str, length);



        View snackbarView = snackbar.getView();

        //设置布局居中

        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(snackbarView.getLayoutParams().width, snackbarView.getLayoutParams().height);

        params.gravity = Gravity.CENTER;

        snackbarView.setLayoutParams(params);

        //文字居中

        TextView message = (TextView) snackbarView.findViewById(R.id.snackbar_text);

        //View.setTextAlignment需要SDK>=17

        message.setTextAlignment(View.TEXT_ALIGNMENT_GRAVITY);

        message.setGravity(Gravity.CENTER);

        message.setMaxLines(1);

        snackbar.addCallback(new BaseTransientBottomBar.BaseCallback<Snackbar>() {

            @Override

            public void onDismissed(Snackbar transientBottomBar, int event) {

                super.onDismissed(transientBottomBar, event);

                //Snackbar关闭

            }



            @Override

            public void onShown(Snackbar transientBottomBar) {

                super.onShown(transientBottomBar);

                //Snackbar显示

            }

        });

        snackbar.setAction("取消", new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                //显示一个默认的Snackbar。

                Snackbar.make(view, "我先走", BaseTransientBottomBar.LENGTH_LONG).show();

            }

        });

        snackbar.show();

    }

Snackbar.make的三个参数：

• View：从View中找出当前窗口最外层视图，然后在其底部显示。


• 第二个参数(text)：
  
  
  
  • CharSequence
  
  
  • StringRes
  
  
  
  


• duration(显示时长)
  
  
  
  • Snackbar.LENGTH_INDEFINITE 从 show()开始显示,直到它被关闭或显示另一个 Snackbar。
  
  
  • Snackbar.LENGTH_SHORT 短时间
  
  
  • Snackbar.LENGTH_LONG 长时间
  
  
  • 自定义持续时间 以毫秒为单位
  
  
  
  

💥 效果

Android 12

Android 5.1

💥 工具类

如果觉得设置麻烦可以看看下面这边文章，然后整合一套适合自己的。

一、前言

学习目标：

• 掌握 原码 反码 补码 基本运算以及转换


• 熟练应用 与 或 非 同或 异或 应用


• 对于 移位运算 在题目中熟练应用，后面会出位运算的题目

二、概述

计算机最主要的功能是处理数值、文字、声音、图形图像等信息。

在计算机内部，各种信息都必须经过数字化编码后才能被传送、存储和处理，所有的数据以二进制的形式存储在设备中，即 0、1 这两种状态。

计算机对二进制数据进行的运算(+、-、*、/)都是叫位运算，例如下面的计算：

int a=74;

int b=58;

int c=a+b;



a  74 ：  1 0 0 1 0 1 0

b  58 :     1 1 1 0 1 0

c 132 : 1 0 0 0 0 1 0 0

十进制数字转换成底层的二进制数字之后，二进制逐位相加，满2进1。

三、原码 反码 补码

1.原码

在计算机的运算中，计算机只能做加法，减法、乘除都没法计算。原码是最简单的机器数表示法，用最高位表示符号位，其他位存放该数的二进制的绝对值。

首位的0表示正数、1表示负数。

特点：

• 表示直观易懂，正负数区分清晰


• 加减法运算复杂，要先判断符号是正号还是负号、相同还是相反

2.反码

正数的反码还是等于原码，负数的反码就是它的原码除符号位外，按位取反。

特点：

• 反码的表示范围与原码的表示范围相同


• 反码表示在计算机中往往作为数码变换的中间环节

3.补码

正数的补码等于它的原码，负数的补码等于反码+1。

特点：

• 在计算机运算时，都是以补码的方式运算的，下面的位运算也是补码形式计算

四、基本运算

1.与

符号：&

运算规则：两个二进制位都为1时才为1，否则为0

示例：1001&1111=1001

2.或

符号：|

运算规则：两个二进制位都为0时才为0，否则为1

示例：1001&1100=1101

3.非

符号：~

运算规则：0变成1，1变成0

示例：~1001 = 0110

4.同或

符号：~

运算规则：数字相同时为1，相反为0

示例：1001~1100=1010

5.异或

符号：^

运算规则：两个二进制位相反为1，相同为0

示例：1001^0111=1110

五、移位运算

1.左移

符号：<<

运算规则：符号位不变，低位补0

示例：

a<<b 代表十进制数字a向左移动b个进位

/* 左移：

 * 左移1位，相当于原数值 * 2

 * 左移2位，相当于原数值 * 4

 * 左移n位，相当于原数值 * 2^n

 */

计算 10 << 1

10的补码：0000 1010

-----------------------

结果补码：0001 0100 ==> 正数，即 10*2=20



计算 10 << 2

10的补码：0000 1010

-----------------------

结果补码：0010 1000 ==> 正数，即 10*2^2=40



计算 10 << 3

10的补码：0000 1010

-----------------------

结果补码：0101 0000 ==> 正数，即 10*2^3=80



计算 12 << 1

12的补码：0000 1100

-----------------------

结果补码：0001 1000 ==> 正数，即 12*2=24

2.右移

符号：>>

运算规则：低位溢出，符号位不变，并用符号位补溢出的高位

示例：

a>>b 代表十进制数字a向右移动b个进位

/* 右移：

 * 右移1位，相当于原数值 / 2

 * 右移2位，相当于原数值 / 4

 * 右移3位，相当于原数值 / 2^n

 * 结果没有小数(向下取整)

 */

计算 80 >> 1

80的补码：0101 0000

-----------------------

结果补码：0010 1000 ==> 正数，即 80/2=40



计算 80 >> 2

80的补码：0101 0000

-----------------------

结果补码：0001 01000 ==> 正数，即 80/2^2=20



计算 80 >> 3

80的补码：0101 0000

-----------------------

结果补码：0000 1010 ==> 正数，即 80/2^3=10



计算 24 >> 1

12的补码：0001 1000

-----------------------

结果补码：0000 1100 ==> 正数，即 24/2=12

前言

前段时间，学习到了Flutter动画，正愁不知道写个项目练习巩固，突然有一天产品在群里发了一个链接【ios中的动画标签】(下面有例图)，我心里直呼"好家伙"，要是产品都要求做成这样，产品经理和程序员又又又又又又得打起来! 还好只是让我们参考，刚好可以拿来练习。

GitHub地址：github.com/longer96/fl…

我们每天都会看到底部导航菜单，它们在应用程序内引导用户，允许他们在不同的tag之间快速切换。但是谁说切换标签就应该很无聊？
让我们一起探索标签栏中有趣的动画。虽然你在应用程序中可能不会使用到，但看看它的实现可能会给你提供一些灵感、设计参考。

如果恰好能给你带来一点点帮助，那是再好不过啦~ 路过的帅逼帮忙点个 star

先上几张花里胡哨的底部菜单 参考图

效果分析

咳咳，有的动效确实挺难的，需要设计师的鼎力支持，我只好选软的柿子捏

首先我们观察，它是由文字和指示器组成的。点击之后指示器切换，文字缩放。

• 每个tag 均分了屏幕宽度


• 点击之后，指示器从之前的tag中部位置拉长到选中tag的中部位置


• 指示器到达选中tag之后，长度立马向选中tag位置收缩

稍微复杂一点的是指示器的动画，看上去有3个变量：左边距、右边距、指示器宽度。
但变量越多，越不方便控制，细心想一下 我们发现其实只需要控制： 左、右边距就可以了，指示器宽度设置成自适应（或者只控制左边距和指示器宽度）

实现效果

其实很多类似底部菜单都可以如法炮制，指示器位于tag后面，根据不同的条件调整位置和尺寸。

实现一款底部菜单

常见的还有另一种展开类似的菜单，比如这样

咱们还是先简单分析一下

• 由一个按钮、多个tag按钮组成


• 点击之后，tag呈扇状展开或收缩

看上去只有2步，还是很简单的嘛

第一步：我们用帧布局叠放按钮和tag

Stack(

    children: [

      // tag菜单



      // 菜单/关闭 按钮

    ]

  )

第二步：管理好tag的位置
简单介绍一下Flow，Flutter中Flow是一个对子组件尺寸以及位置调整非常高效的控件。

Flow用转换矩阵在对子组件进行位置调整的时候进行了优化：在Flow定位过后，如果子组件的尺寸或者位置发生了变化，在FlowDelegate中的paintChildren()方法中调用context.paintChild 进行重绘，而context.paintChild在重绘时使用了转换矩阵，并没有实际调整组件位置。

使用起来也很简单，只需要实现FlowDelegate的paintChildren()方法，就可以自定义布局策略。所以我们需要计算好每一个tag的轨迹位置。

经过你的细心观察，你发现tag的轨迹呈半圆状展开，对 没错 就是需要翻出三角函数

经过你的又一次细心观察，你发现有5个tag，半圆实际可以放7个，但是为了有更好的显示效果，可以将需要展示的tag放在中间位置（过滤掉第一个和最后一个）

所以我们可以列出简单的计算

final total = context.childCount + 1;



for (int i = 0; i < childCount; i++) {

  x = cos(pi * (total - i - 1) / total) * Radius;

  y = sin(pi * (total - i - 1) / total) * Radius;

}

你发现太规整的圆其实并不是那么好看，优化一下

• 将x轴半径设置为 父级约束宽度的一半


• 将Y轴半径设置为 父级约束高度


• 给动画加上曲线，让tag有类似回弹效果


• 注意y轴得转换为负数，因为我们的坐标点位于下方

微调一下，好啦 恭喜你!
3句代码，让产品经理给你点了18杯茶

class FlowAnimatedCircle extends FlowDelegate {

  final Animation<double> animation;



  /// icon 尺寸

  final double iconSize = 48.0;



  /// 菜单左右边距

  final paddingHorizontal = 8.0;



  FlowAnimatedCircle(this.animation) : super(repaint: animation);



  @override

  void paintChildren(FlowPaintingContext context) {

    // 进度等于0，也就是收起来的时候不绘制

    final progress = animation.value;

    if (progress == 0) return;



    final xRadius = context.size.width / 2 - paddingHorizontal;

    final yRadius = context.size.height - iconSize;



    // 开始(0,0)在父组件的中心

    double x = 0;

    double y = 0;



    final total = context.childCount + 1;



    for (int i = 0; i < context.childCount; i++) {

      x = progress * cos(pi * (total - i - 1) / total) * xRadius;

      y = progress * sin(pi * (total - i - 1) / total) * yRadius;



      // 使用Matrix定位每个子组件

      context.paintChild(

        i,

        transform: Matrix4.translationValues(

            x, -y + (context.size.height / 2) - (iconSize / 2), 0),

      );

    }

  }



  @override

  bool shouldRepaint(FlowAnimatedCircle oldDelegate) => false;

}

只要理解到了上面的实现，下面这3种也能很轻松完成

最后

收集、参考实现了几个底部导航，当然可能很多地方需要优化，大家不要喷我哦

• 有很棒的底部菜单希望推荐


• 需要使用的，建议大家clone下来，直接引入，具体需求(如未读消息)自己添加


• 欢迎Fork & pr贡献您的代码，大家共同学习❤


• Android 体验下载 d.cc53.cn/sn6c


• Web在线体验 footer.eeaarr.cn

相信绝大多数朋友做 PPT（幻灯片 / Slides / Deck 等各种称呼了）都是用的 PowerPoint 或者 KeyNote 吧？功能是比较强大，但你有没有遇到过这样的痛点：

• 各种标题、段落的格式不统一，比如字体大小、行间距等等各个页面不太一样，然后得用格式刷来挨个刷一下。


• 想给 PPT 做版本控制，然后就保存了各种复制版本，比如“一版”、“二版”、“终版”、“最终版”、“最终不改版”、“最终稳定不改版”等等，想必大家都见过类似这样的场景吧。


• 想插入代码，但是插入之后发现格式全乱了或者高亮全没了，然后不得不截图插入进去。


• 想插入个公式，然后发现 PPT、Keynote 对 Latex 兼容不太好或者配置稍微麻烦，就只能自己重新敲一遍或者贴截图。


• 想插入一个酷炫的交互组件，比如嵌入一个微博的网页页面实时访问、插入一个可以交互的组件、插入一个音乐播放器组件，原生的 PPT 功能几乎都不支持，这全得依赖于 PowerPoint 或者 KeyNote 来支持才行。

如果你遇到这些痛点，那请你一定要看下去。如果你没有遇到，那也请你看下去吧（拜托。

好，说回正题，我列举了那么多痛点，那这些痛点咋解决呢？

能！甚至解决方案更加轻量级，那就是用 Markdown 来做 PPT！

你试过用 Markdown 写 PPT 吗？没有吧，试试吧，试过之后你就发现上面的功能简直易如反掌。

具体怎么实现呢？

接下来，就有请今天的主角登场了！它就是 Slidev。

什么是 Slidev？

简而言之，Slidev 就是可以让我们用 Markdown 写 PPT 的工具库，基于 Node.js、Vue.js 开发。

利用它我们可以简单地把 Markdown 转化成 PPT，而且它可以支持各种好看的主题、代码高亮、公式、流程图、自定义的网页交互组件，还可以方便地导出成 pdf 或者直接部署成一个网页使用。

官方主页：sli.dev/

GitHub：github.com/slidevjs/sl…

安装和启动

下面我们就来了解下它的基本使用啦。

首先我们需要先安装好 Node.js，推荐 14.x 及以上版本，安装方法见 setup.scrape.center/nodejs。

接着，我们就可以使用 npm 这个命令了。

然后我们可以初始化一个仓库，运行命令如下：

npm init slidev@latest

这个命令就是初始化一个 Slidev 的仓库，运行之后它会让我们输入和选择一些选项，如图所示：

比如上图就是先输入项目文件夹的名称，比如这里我取名叫做 slidevtest。

总之一些选项完成之后，Slidev 会在本地 3000 端口上启动，如图所示：

接着，我们就可以打开浏览器 http://localhost:3000 来查看一个 HelloWorld 版本的 PPT 了，如图所示：

我们可以点击空格进行翻页，第二页展示了一张常规的 PPT 的样式，包括标题、正文、列表等，如图所示：

那这一页的 Markdown 是什么样的呢？其实就是非常常规的 Markdown 文章的写法，内容如下：

# What is Slidev?



Slidev is a slides maker and presenter designed for developers, consist of the following features



- 📝 **Text-based** - focus on the content with Markdown, and then style them later

- 🎨 **Themable** - theme can be shared and used with npm packages

- 🧑‍💻 **Developer Friendly** - code highlighting, live coding with autocompletion

- 🤹 **Interactive** - embedding Vue components to enhance your expressions

- 🎥 **Recording** - built-in recording and camera view

- 📤 **Portable** - export into PDF, PNGs, or even a hostable SPA

- 🛠 **Hackable** - anything possible on a webpage



<br>

<br>



Read more about [Why Slidev?](https://sli.dev/guide/why)

是不是？我们只需要用同样格式的 Markdown 语法就可以轻松将其转化为 PPT 了。

快捷键操作

再下一页介绍了各种快捷键的操作，这个就很常规了，比如点击空格、上下左右键来进行页面切换，如图所示：

更多快捷键的操作可以看这里的说明：sli.dev/guide/navig…，一些简单的快捷键列举如下：

• f：切换全屏


• right / space：下一动画或幻灯片


• left：上一动画或幻灯片


• up：上一张幻灯片


• down：下一张幻灯片


• o：切换幻灯片总览


• d：切换暗黑模式


• g：显示“前往...”

代码高亮

接下来就是代码环节了，因为 Markdown 对代码编写非常友好，所以展示自然也不是问题了，比如代码高亮、代码对齐等都是常规操作，如图所示：

那左边的代码定义就直接这么写就行了：

# Code



Use code snippets and get the highlighting directly![^1]



```ts {all|2|1-6|9|all}

interface User {

  id: number

  firstName: string

  lastName: string

  role: string

}



function updateUser(id: number, update: User) {

  const user = getUser(id)

  const newUser = {...user, ...update}  

  saveUser(id, newUser)

}

```

由于是 Markdown，所以我们可以指定是什么语言，比如 TypeScript、Python 等等。

网页组件

接下来就是非常酷炫的环节了，我们还可以自定义一些网页组件，然后展示出来。

比如我们看下面的一张图。左边就呈现了一个数字计数器，点击左侧数字就会减 1，点击右侧数字就会加 1；另外图的右侧还嵌入了一个组件，这里显示了一个推特的消息，通过一个卡片的形式呈现了出来，不仅仅可以看内容，甚至我们还可以点击下方的喜欢、回复、复制等按钮来进行一些交互。

这些功能在网页里面并不稀奇，但是如果能做到 PPT 里面，那感觉就挺酷的。

那这一页怎么做到的呢？这个其实是引入了一些基于 Vue.js 的组件，本节对应的 Markdown 代码如下：

# Components



<div grid="~ cols-2 gap-4">

<div>



You can use Vue components directly inside your slides.



We have provided a few built-in components like `<Tweet/>` and `<Youtube/>` that you can use directly. And adding your custom components is also super easy.



```html

<Counter :count="10" />

```



<!-- ./components/Counter.vue -->

<Counter :count="10" m="t-4" />



Check out [the guides](https://sli.dev/builtin/components.html) for more.



</div>

<div>



```html

<Tweet id="1390115482657726468" />

```



<Tweet id="1390115482657726468" scale="0.65" />



</div>

</div>

这里我们可以看到，这里引入了 Counter、Tweet 组件，而这个 Counter 就是 Vue.js 的组件，代码如下：

<script setup lang="ts">

import { ref } from 'vue'



const props = defineProps({

  count: {

    default: 0,

  },

})



const counter = ref(props.count)

</script>



<template>

  <div flex="~" w="min" border="~ gray-400 opacity-50 rounded-md">

    <button

      border="r gray-400 opacity-50"

      p="2"

      font="mono"

      outline="!none"

      hover:bg="gray-400 opacity-20"

      @click="counter -= 1"

    >

      -

    </button>

    <span m="auto" p="2">{{ counter }}</span>

    <button

      border="l gray-400 opacity-50"

      p="2"

      font="mono"

      outline="!none"

      hover:bg="gray-400 opacity-20"

      @click="counter += 1"

    >

      +

    </button>

  </div>

</template>

这就是一个标准的基于 Vue.js 3.x 的组件，都是标准的 Vue.js 语法，所以如果我们要添加想要的组件，直接自己写就行了，什么都能实现，只要网页能支持的，统统都能写！

主题定义

当然，一些主题定制也是非常方便的，我们可以在 Markdown 文件直接更改一些配置就好了，比如就把 theme 换个名字，整个主题样式就变了，看如下的对比图：

上面就是一些内置主题，当然我们也可以去官方文档查看一些别人已经写好的主题，见：sli.dev/themes/gall…。

另外我们自己写主题也是可以的，所有的主题样式都可以通过 CSS 等配置好，想要什么就可以有什么，见：sli.dev/themes/writ…

公式和图表

接下来就是一个非常强大实用的功能，公式和图表，支持 Latex、流程图，如图所示：

比如上面的 Latex 的源代码就是这样的：

Inline $\sqrt{3x-1}+(1+x)^2$



Block

$$

\begin{array}{c}



\nabla \times \vec{\mathbf{B}} -\, \frac1c\, \frac{\partial\vec{\mathbf{E}}}{\partial t} &

= \frac{4\pi}{c}\vec{\mathbf{j}}    \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\



\nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\



\nabla \cdot \vec{\mathbf{B}} & = 0



\end{array}

$$

其语法也是和 Latex 一样的。

其背后是怎么实现的呢？其实是因为 Slidev 默认集成了 Katex 这个库，见：katex.org/，有了 Katex 的加持，所有公式的显示都不是事。

页面分隔

有的朋友就好奇了，既然是用 Markdown 写 PPT，那么每一页之间是怎么分割的呢？

其实很简单，最常规的，用三条横线分割就好了，比如：

---

layout: cover

---



# 第 1 页



This is the cover page.



---



# 第 2 页



The second page

当然，除了使用三横线，我们还可以使用更丰富的定义模式，可以给每一页制定一些具体信息，就是使用两层三横线。

比如这样：

---

theme: seriph

layout: cover

background: 'https://source.unsplash.com/1600x900/?nature,water'

---

上面这样的配置可以替代三横线，是另一种可以用作页面分隔的写法，借助这种写法我们可以定义更多页面的具体信息。

备注

当然我们肯定也想给 PPT 添加备注，这个也非常简单，通过注释的形式写到 Markdown 源文件就好了：

---

layout: cover

---



# 第 1 页



This is the cover page.



<!-- 这是一条备注 -->

这里可以看到其实就是用了注释的特定语法。

演讲者头像

当然还有很多酷炫的功能，比如说，我们在讲 PPT 的时候，可能想同时自己也出镜，Slidev 也可以支持。

因为开的是网页，而网页又有捕捉摄像头的功能，所以最终效果可以是这样子：

是的没错！右下角就是演讲者的个人头像，它被嵌入到了 PPT 中！是不是非常酷！

演讲录制

当然，Slidev 还支持演讲录制功能，因为它背后集成了 WebRTC 和 RecordRTC 的 API，一些录制配置如下所示：

所以，演讲过程的录制完全不是问题。

具体的操作可以查看：sli.dev/guide/recor…。

部署

当然用 Slidev 写的 PPT 还可以支持部署，因为这毕竟就是一个网页。

而且部署非常简单和轻量级，因为这就是一些纯静态的 HTML、JavaScript 文件，我们可以轻松把它部署到 GitHub Pages、Netlify 等站点上。

试想这么一个场景：别人在演讲之前还在各种拷贝 PPT，而你打开了一个浏览器直接输入了一个网址，PPT 就出来了，众人惊叹，就问你装不装逼？

具体的部署操作可以查看：sli.dev/guide/hosti…

让我们看几个别人已经部署好的 PPT，直接网页打开就行了：

• demo.sli.dev/composable-…


• masukin.link/talks/simpl…

就是这么简单方便。

版本控制

什么？你想实现版本控制，那再简单不过了。

Markdown 嘛，配合下专业版本管理工具 Git，版本控制再也不是难题。

总结

以上就是对 Slidev 的简单介绍，确实不得不说有些功能真的非常实用，而且我本身特别喜欢 Markdown 和网页开发，所以这个简直对我来说太方便了。

Flutter 保证数据操作原子性

Flutter 是单线程架构，按道理理说，Flutter 不会出现 Java 的多线程相关的问题。

但在我使用 Flutter 过程中，却发现 Flutter 依然会存在数据操作原子性的问题。

其实 Flutter 中存在多线程的（Isolate 隔离池），只是 Flutter 中的多线程更像 Java 中的多进程，因为 Flutter 中线程不能像 Java 一样，可以两个线程去操作同一个对象。

我们一般将计算任务放在 Flutter 单独的线程中，例如一大段 Json 数据的解析，可以将解析计算放在单独的线程中，然后将解析完后的 Map<String, dynamic> 返回到主线程来用。

Flutter单例模式

在 Java 中，我们一般喜欢用单例模式来理解 Java 多线程问题。这里我们也以单例来举例，我们先来一个正常的：

class FlutterSingleton {

  static FlutterSingleton? _instance;



  /// 将构造方法声明成私有的

  FlutterSingleton._();



  static FlutterSingleton getInstance() {

    if (_instance == null) {

      _instance = FlutterSingleton._();

    }

    return _instance!;

  }

}

由于 Flutter 是单线程架构的, 所以上述代码是没有问题的。

问题示例

但是, 和 Java 不同的是, Flutter 中存在异步方法。

做 App 开发肯定会涉及到数据持久化，Android 开发应该都熟悉 SharedPreferences，Flutter 中也存在 SharedPreferences 库，我们就以此来举例。同样实现单例模式，只是这次无可避免的需要使用 Flutter 中的异步：

class SPSingleton {

  static SPSingleton? _instance;



  String? data;



  /// 将构造方法声明成私有的

  SPSingleton._fromMap(Map<String, dynamic> map) : data = map['data'];



  static Future<SPSingleton> _fromSharedPreferences() async {

    // 模拟从 SharedPreferences 中读取数据, 并以此来初始化当前对象

    Map<String, String> map = {'data': 'mockData'};

    await Future.delayed(Duration(milliseconds: 10));

    return SPSingleton._fromMap(map);

  }



  static Future<SPSingleton> getInstance() async {

    if (_instance == null) {

      _instance = await SPSingleton._fromSharedPreferences();

    }

    return _instance!;

  }

}



void main() async {

  SPSingleton.getInstance().then((value) {

    print('instance1.hashcode = ${value.hashCode}');

  });

  SPSingleton.getInstance().then((value) {

    print('instance2.hashcode = ${value.hashCode}');

  });

}

运行上面的代码，打印日志如下：

instance1.hashcode = 428834223

instance2.hashcode = 324692380

可以发现，我们两次调用 SPSingleton.getInstance() 方法，分别创建了两个对象，说明上面的单例模式实现有问题。

我们来分析一下 getInstance() 方法：

static Future<SPSingleton> getInstance() async {

  if (_instance == null) { // 1

    _instance = await SPSingleton._fromSharedPreferences(); //2

  }

  return _instance!;

}

当第一次调用 getInstance() 方法时，代码在运行到 1 处时，发现 _instance 为 null, 就会进入 if 语句里面执行 2 处, 并因为 await 关键字挂起, 并交出代码的执行权, 直到被 await 的 Future 执行完毕，最后将创建的 SPSingleton 对象赋值给 _instance 并返回。

当第二次调用 getInstance() 方法时，代码在运行到 1 处时，可能会发现 _instance 还是为 null (因为 await SPSingleton._fromSharedPreferences() 需要 10ms 才能返回结果), 然后和第一次调用 getInstance() 方法类似, 创建新的 SPSingleton 对象赋值给 _instance。

最后导致两次调用 getInstance() 方法, 分别创建了两个对象。

解决办法

问题原因知道了，那么该怎样解决这个问题呢？

究其本质，就是 getInstance() 方法的执行不具有原子性，即：在一次 getInstance() 方法执行结束前，不能执行下一次 getInstance() 方法。

幸运的是, 我们可以借助 Completer 来将异步操作原子化，下面是借助 Completer 改造后的代码：

import 'dart:async';



class SPSingleton {

  static SPSingleton? _instance;

  static Completer<bool>? _monitor;



  String? data;



  /// 将构造方法声明成私有的

  SPSingleton._fromMap(Map<String, dynamic> map) : data = map['data'];



  static Future<SPSingleton> _fromSharedPreferences() async {

    // 模拟从 SharedPreferences 中读取数据, 并以此来初始化当前对象

    Map<String, String> map = {'data': 'mockData'};

    await Future.delayed(Duration(milliseconds: 10));

    return SPSingleton._fromMap(map);

  }



  static Future<SPSingleton> getInstance() async {

    if (_instance == null) {

      if (_monitor == null) {

        _monitor = Completer<bool>();

        _instance = await SPSingleton._fromSharedPreferences();

        _monitor!.complete(true);

      } else {

        // Flutter 的 Future 支持被多次 await

        await _monitor!.future;

        _monitor = null;

      }

    }

    return _instance!;

  }

}



void main() async {

  SPSingleton.getInstance().then((value) {

    print('instance1.hashcode = ${value.hashCode}');

  });

  SPSingleton.getInstance().then((value) {

    print('instance2.hashcode = ${value.hashCode}');

  });

}

我们再次分析一下 getInstance() 方法:

static Future<SPSingleton> getInstance() async {

  if (_instance == null) { // 1

    if (_monitor == null) { // 2

      _monitor = Completer<bool>(); // 3

      _instance = await SPSingleton._fromSharedPreferences(); // 4

      _monitor!.complete(true); // 5

    } else {

      // Flutter 的 Future 支持被多次 await

      await _monitor!.future; //6

      _monitor = null;

    }

  }

  return _instance!; // 7

}

当第一次调用 getInstance() 方法时, 1 处和 2 处都会判定为 true, 然后进入执行到 3 处创建一个的 Completer 对象, 然后在 4 的 await 处挂起, 并交出代码的执行权, 直到被 await 的 Future 执行完毕。

此时第二次调用的 getInstance() 方法开始执行，1 处同样会判定为 true, 但是到 2 处时会判定为 false, 从而进入到 else, 并因为 6 处的 await 挂起, 并交出代码的执行权;

此时, 第一次调用 getInstance() 时的 4 处执行完毕, 并执行到 5, 并通过 Completer 通知第二次调用的 getInstance() 方法可以等待获取代码执行权了。

最后，两次调用 getInstance() 方法都会返回同一个 SPSingleton 对象，以下是打印日志：

instance1.hashcode = 786567983

instance2.hashcode = 786567983

由于 Flutter 的 Future 是支持多次 await 的, 所以即便是连续 n 次调用 getInstance() 方法, 从第 2 到 n 次调用会 await 同一个 Completer.future, 最后也能返回同一个对象。

Flutter任务队列

虽然我们经常拿单例模式来解释说明 Java 多线程问题，可这并不代表着 Java 只有在单例模式时才有多线程问题。

同样的，也并不代表着 Flutter 只有在单例模式下才有原子操作问题。

问题示例

我们同样以数据持久化来举例，只是这次我们以数据库操作来举例。

我们在操作数据库时，经常会有这样的需求：如果数据库表中存在这条数据，就更新这条数据，否则就插入这条数据。

为了实现这样的需求，我们可能会先从数据库表中查询数据，查询到了就更新，没查询到就插入，代码如下：

class Item {

  int id;

  String data;

  Item({

    required this.id,

    required this.data,

  });

}



class DBTest {

  DBTest._();

  static DBTest instance = DBTest._();

  bool _existsData = false;

  Future<void> insert(String data) async {

    // 模拟数据库插入操作,10毫秒过后,数据库中才有数据

    await Future.delayed(Duration(milliseconds: 10));

    _existsData = true;

    print('执行了插入');

  }



  Future<void> update(String data) async {

    // 模拟数据库更新操作

    await Future.delayed(Duration(milliseconds: 10));

    print('执行了更新');

  }



  Future<Item?> selected(int id) async {

    // 模拟数据库查询操作

    await Future.delayed(Duration(milliseconds: 10));

    if (_existsData) {

      // 数据库中有数据才返回

      return Item(id: 1, data: 'mockData');

    } else {

      // 数据库没有数据时,返回null

      return null;

    }

  }



  /// 先从数据库表中查询数据，查询到了就更新，没查询到就插入

  Future<void> insertOrUpdate(int id, String data) async {

    Item? item = await selected(id);

    if (item == null) {

      await insert(data);

    } else {

      await update(data);

    }

  }

}



void main() async {

  DBTest.instance.insertOrUpdate(1, 'data');

  DBTest.instance.insertOrUpdate(1, 'data');

}

我们期望的输出日志为:

执行了插入

执行了更新

但不幸的是, 输出的日志为:

执行了插入

执行了插入

原因也是异步方法操作数据, 不是原子操作, 导致逻辑异常。

也许我们也可以效仿单例模式的实现，利用 Completer 将 insertOrUpdate() 方法原子化。

但对于数据库操作是不合适的，因为我们可能还有其它需求，比如说：调用插入数据的方法，然后立即从数据库中查询这条数据，发现找不到。

如果强行使用 Completer，那么到最后，可能这个类中会出现一大堆的 Completer ，代码难以维护。

解决办法

其实我们想要的效果是，当有异步方法在操作数据库时，别的操作数据的异步方法应该阻塞住，也就是同一时间只能有一个方法来操作数据库。我们其实可以使用任务队列来实现数据库操作的需求。

我这里利用 Completer 实现了一个任务队列:

import 'dart:async';

import 'dart:collection';



/// TaskQueue 不支持 submit await submit, 以下代码就存在问题

///

/// TaskQueue taskQueue = TaskQueue();

/// Future<void> task1(String arg)async{

///   await Future.delayed(Duration(milliseconds: 100));

/// }

/// Future<void> task2(String arg)async{

///   在这里submit时, 任务会被添加到队尾, 且当前方法任务不会结束

///   添加到队尾的任务必须等到当前方法任务执行完毕后, 才能继续执行

///   而队尾的任务必须等当前任务执行完毕后, 才能执行

///   这就导致相互等待, 使任务无法进行下去

///   解决办法是, 移除当前的 await, 让当前任务结束

///   await taskQueue.submit(task1, arg);

/// }

///

/// taskQueue.submit(task2, arg);

///

/// 总结:

/// 被 submit 的方法的内部如果调用 submit 方法, 此方法不能 await, 否则任务队列会被阻塞住

///

/// 如何避免此操作, 可以借鉴以下思想:

/// 以数据库操作举例, 有个save方法的逻辑是插入或者更新(先查询数据库select,再进行下一步操作);

/// sava方法内部submit,并且select也submit, 就容易出现submit await submit的情况

///

/// 我们可以这样操作,假设当前类为 DBHelper:

/// 将数据库的增,删,查,改操作封装成私有的 async 方法, 且私有方法不能使用submit

/// DBHelper的公有方法, 可以调用自己的私有 async 方法, 但不能调用自己的公有方法, 公有方法可以使用submit

/// 这样就不会存在submit await submit的情况了

class TaskQueue {

  /// 提交任务

  Future<O> submit<A, O>(Function fun, A? arg) async {

    if (!_isEnable) {

      throw Exception('current TaskQueue is recycled.');

    }

    Completer<O> result = new Completer<O>();



    if (!_isStartLoop) {

      _isStartLoop = true;

      _startLoop();

    }



    _queue.addLast(_Runnable<A, O>(

      fun: fun,

      arg: arg,

      completer: result,

    ));

    if (!(_emptyMonitor?.isCompleted ?? true)) {

      _emptyMonitor?.complete();

    }



    return result.future;

  }



  /// 回收 TaskQueue

  void recycle() {

    _isEnable = false;

    if (!(_emptyMonitor?.isCompleted ?? true)) {

      _emptyMonitor?.complete();

    }

    _queue.clear();

  }



  Queue<_Runnable> _queue = Queue<_Runnable>();

  Completer? _emptyMonitor;

  bool _isStartLoop = false;

  bool _isEnable = true;



  Future<void> _startLoop() async {

    while (_isEnable) {

      if (_queue.isEmpty) {

        _emptyMonitor = new Completer();

        await _emptyMonitor!.future;

        _emptyMonitor = null;

      }



      if (!_isEnable) {

        // 当前TaskQueue不可用时, 跳出循环

        return;

      }



      _Runnable runnable = _queue.removeFirst();

      try {

        dynamic result = await runnable.fun(runnable.arg);

        runnable.completer.complete(result);

      } catch (e) {

        runnable.completer.completeError(e);

      }

    }

  }

}



class _Runnable<A, O> {

  final Completer<O> completer;

  final Function fun;

  final A? arg;



  _Runnable({

    required this.completer,

    required this.fun,

    this.arg,

  });

}

由于 Flutter 中的 future 不支持暂停操作, 一旦开始执行, 就只能等待执行完。

所以这里的任务队列实现是基于方法的延迟调用来实现的。

TaskQueue 的用法示例如下:

void main() async {

  Future<void> test1(String data) async {

    await Future.delayed(Duration(milliseconds: 20));

    print('执行了test1');

  }



  Future<String> test2(Map<String, dynamic> args) async {

    await Future.delayed(Duration(milliseconds: 10));

    print('执行了test2');

    return 'mockResult';

  }



  TaskQueue taskQueue = TaskQueue();

  taskQueue.submit(test1, '1');

  taskQueue.submit(test2, {

    'data1': 1,

    'data2': '2',

  }).then((value) {

    print('test2返回结果:${value}');

  });



  await Future.delayed(Duration(milliseconds: 200));

  taskQueue.recycle();

}

/*

执行输出结果如下:



执行了test1

执行了test2

test2返回结果:mockResult

*/

值得注意的是: 这里的 TaskQueue 不支持 submit await submit, 原因及示例代码已在注释中说明，这里不再赘述。

为了避免出现 submit await submit 的情况，我代码注释中也做出了建议（假设当前类为 DBHelper）：

• 
  

  将数据库的增、删、查、改操作封装成私有的异步方法, 且私有异步方法不能使用 submit；

  
  


• 
  

  DBHelper 的公有方法, 可以调用自己的私有异步方法, 但不能调用自己的公有异步方法, 公有异步方法可以使用 submit；

  
  

这样就不会出现 submit await submit 的情况了。

于是，上述的数据库操作示例代码就变成了以下的样子：

class Item {

  int id;

  String data;

  Item({

    required this.id,

    required this.data,

  });

}



class DBTest {

  DBTest._();

  static DBTest instance = DBTest._();

  TaskQueue _taskQueue = TaskQueue();

  bool _existsData = false;

  Future<void> _insert(String data) async {

    // 模拟数据库插入操作,10毫秒过后,数据库才有数据

    await Future.delayed(Duration(milliseconds: 10));

    _existsData = true;

    print('执行了插入');

  }



  Future<void> insert(String data) async {

    await _taskQueue.submit(_insert, data);

  }



  Future<void> _update(String data) async {

    // 模拟数据库更新操作

    await Future.delayed(Duration(milliseconds: 10));

    print('执行了更新');

  }



  Future<void> update(String data) async {

    await _taskQueue.submit(_update, data);

  }



  Future<Item?> _selected(int id) async {

    // 模拟数据库查询操作

    await Future.delayed(Duration(milliseconds: 10));

    if (_existsData) {

      // 数据库中有数据才返回

      return Item(id: 1, data: 'mockData');

    } else {

      // 数据库没有数据时,返回null

      return null;

    }

  }



  Future<Item?> selected(int id) async {

    return await _taskQueue.submit(_selected, id);

  }



  /// 先从数据库表中查询数据，查询到了就更新，没查询到就插入

  Future<void> _insertOrUpdate(Map<String, dynamic> args) async {

    int id = args['id'];

    String data = args['data'];

    Item? item = await _selected(id);

    if (item == null) {

      await _insert(data);

    } else {

      await _update(data);

    }

  }



  Future<Item?> insertOrUpdate(int id, String data) async {

    return await _taskQueue.submit(_insertOrUpdate, {

      'id': id,

      'data': data,

    });

  }

}



void main() async {

  DBTest.instance.insertOrUpdate(1, 'data');

  DBTest.instance.insertOrUpdate(1, 'data');

}

输出日志也变成了我们期望的样子:

执行了插入

执行了更新

总结

• 
  

  Flutter 异步方法修改数据时, 一定要注意数据操作的原子性, 不能因为 Flutter 是单线程架构，就忽略多个异步方法竞争导致数据异常的问题。

  
  


• 
  

  Flutter 保证数据操作的原子性，也有可行办法，当逻辑比较简单时，可直接使用 Completer，当逻辑比较复杂时，可以考虑使用任务队列。

  
  

另外，本文中的任务队列实现有很大的缺陷，不支持 submit await submit，否则整个任务队列会被阻塞住。

如果诸位有其它的任务队列实现方式，或者保证数据操作原子性的方法，欢迎留言。

背景

在上篇文章，我们系统地学习了where 1=1 相关的知识点，大家可以回看《不要再用where 1=1了！有更好的写法！》这篇文章。文章中涉及到了Mybatis的替代方案，有好学的朋友在评论区有朋友问了基于Mybatis写法的问题。

于是，就有了这篇文章。本篇文章会将Mybatis中where标签的基本使用形式、小技巧以及容易踩到的坑进行总结梳理，方便大家更好地实践运用d

原始的手动拼接

在不使用Mybatis的where标签时，我们通常是根据查询条件进行手动拼接，也就是用到了上面提到的where 1=1的方式，示例如下：

  <select id="selectSelective" resultType="com.secbro.entity.User">

    select * from t_user

    where 1=1

    <if test="username != null and username != ''">

     and username = #{username}

    </if>

    <if test="idNo != null and idNo != ''">

      and id_no = #{idNo}

    </if>

  </select>

这种方式主要就是为了避免语句拼接错误，出现类似如下的错误SQL：

select * from t_user where and username = 'Tom' and id = '1001';

select * from t_user where and id = '1001';

当添加上1=1时，SQL语句便是正确的了：

select * from t_user where 1=1 and username = 'Tom' and id = '1001';

select * from t_user where 1=1 and id = '1001';

这个我们之前已经提到过，多少对MySQL数据库的有一定的压力。因为1=1条件的优化过滤是需要MySQL做的。如果能够将这部分放到应用程序来做，就减少了MySQL的压力。毕竟，应用程序是可以轻易地横向扩展的。

Mybatis where标签的使用

为了能达到MySQL性能的调优，我们可以基于Mybatis的where标签来进行实现。where标签是顶层的遍历标签，需要配合if标签使用，单独使用无意义。通常有下面两种实现形式。

方式一：

  <select id="selectSelective" resultType="com.secbro.entity.User">

    select * from t_user

    <where>

      <if test="username != null and username != ''">

        username = #{username}

      </if>

      <if test="idNo != null and idNo != ''">

        and id_no = #{idNo}

      </if>

    </where>

  </select>

方式二：

  <select id="selectSelective" resultType="com.secbro.entity.User">

    select * from t_user

    <where>

      <if test="username != null and username != ''">

        and username = #{username}

      </if>

      <if test="idNo != null and idNo != ''">

        and id_no = #{idNo}

      </if>

    </where>

  </select>

仔细观察会发现，这两种方式的区别在于第一if条件中的SQL语句是否有and。

这里就涉及到where标签的两个特性：

• 第一，只有if标签有内容的情况下才会插入where子句；


• 第二，若子句的开通为 “AND” 或 “OR”，where标签会将它替换去除；

所以说，上面的两种写法都是可以了，Mybatis的where标签会替我们做一些事情。

但需要注意的是：where标签只会 智能的去除（忽略）首个满足条件语句的前缀。所以建议在使用where标签时，每个语句都最好写上 and 前缀或者 or 前缀，否则像以下写法就会出现问题：

  <select id="selectSelective" resultType="com.secbro.entity.User">

    select * from t_user

    <where>

      <if test="username != null and username != ''">

        username = #{username}

      </if>

      <if test="idNo != null and idNo != ''">

        id_no = #{idNo}

      </if>

    </where>

  </select>

生成的SQL语句如下：

select * from t_user      WHERE username = ?  id_no = ?

很显然，语法是错误的。

因此，在使用where标签时，建议将所有条件都添加上and或or；

进阶：自定义trim标签

上面使用where标签可以达到拼接条件语句时，自动去掉首个条件的and或or，那么如果是其他自定义的关键字是否也能去掉呢？

此时，where标签就无能为力了，该trim标签上场了，它也可以实现where标签的功能。

  <select id="selectSelective" resultType="com.secbro.entity.User">

    select * from t_user

    <trim prefix="where" prefixOverrides="and | or ">

      <if test="username != null and username != ''">

        and username = #{username}

      </if>

      <if test="idNo != null and idNo != ''">

        and id_no = #{idNo}

      </if>

    </trim>

  </select>

将上面基于where标签的写改写为trim标签，发现执行效果完全一样。而且trim标签具有了更加灵活的自定义性。

where语句的坑

另外，在使用where语句或其他语句时一定要注意一个地方，那就是：注释的使用。

先来看例子：

  <select id="selectSelective" resultType="com.secbro.entity.User">

    select * from t_user

    <where>

      <if test="username != null and username != ''">

        and username = #{username}

      </if>

      <if test="idNo != null and idNo != ''">

        /* and id_no = #{idNo}*/

        and id_no = #{idNo}

      </if>

    </where>

  </select>

上述SQL语句中添加了 /**/的注释，生成的SQL语句为：

select * from t_user WHERE username = ? /* and id_no = ?*/ and id_no = ? 

执行时，直接报错。

还有一个示例：

  <select id="selectSelective" resultType="com.secbro.entity.User">

    select * from t_user

    <where>

      <if test="username != null and username != ''">

        -- and username = #{username}

        and username = #{username}

      </if>

      <if test="idNo != null and idNo != ''">

        and id_no = #{idNo}

      </if>

    </where>

  </select>

生成的SQL语句为：

select * from t_user WHERE -- and username = ? and username = ? and id_no = ? 

同样会导致报错。

这是因为我们使用 XML 方式配置 SQL 时，如果在 where 标签之后添加了注释，那么当有子元素满足条件时，除了 < !-- --> 注释会被 where 忽略解析以外，其它注释例如 // 或 /**/ 或 -- 等都会被 where 当成首个子句元素处理，导致后续真正的首个 AND 子句元素或 OR 子句元素没能被成功替换掉前缀，从而引起语法错误。

同时，个人在实践中也经常发现因为在XML中使用注释不当导致SQL语法错误或执行出错误的结果。强烈建议，非必要，不要在XML中注释掉SQL，可以通过版本管理工具来追溯历史记录和修改。

小结

本文基于Mybatis中where标签的使用，展开讲了它的使用方式、特性以及拓展到trim标签的替代作用，同时，也提到了在使用时可能会出现的坑。内容虽然简单，但如果能够很好地实践、避免踩坑也是能力的体现。

泪目，想不到我用了这么久的Java编程语言，竟然使用的是值传递。本篇文章我们将带大家搞清楚Java值传递的特性。

前言

是不是有人会这样认为Java在传递参数时，参数如果是普通类型，那就是值传递，如果是对象，那就是引用传递。

如果是这样认为那就大错特错了。

下面我们一起看一下Java的值传递特性。

Java 真的是值传递

检验是值传递最好的方法就是交换方法，我们在交换方法中将两个对象的引用互换，再看一下原来的值会不会被影响。

我们可以看如下例子:

• 首先创建两个用户一个张三，一个李四。
• 然后我们调用身份互换方法swap
• 在身份互换方法中确认两人是否身份互换成功（可以看到结果是成功的）
• 如果是引用传递的话我们创建的两个用户已经完成了身份互换
• 但实际结果是两个用户

package com.zhj.interview;



public class Test15 {



    public static void main(String[] args) {

        User ZhangSan = new User("张三");

        User LiSi = new User("李四");

        System.out.println("开始交换---------------------------------");

        swap(ZhangSan, LiSi);

        System.out.println("交换结束---------------------------------");

        System.out.println("交换后ZhangSan的名字：" + ZhangSan.name);

        System.out.println("交换后LiSi的名字：" + LiSi.name);

    }



    private static void swap(User ZhangSan, User LiSi){

        User user;

        user = ZhangSan;

        ZhangSan = LiSi;

        LiSi = user;

        System.out.println("交换后ZhangSan的名字：" + ZhangSan.name);

        System.out.println("交换后LiSi的名字：" + LiSi.name);

    }

}

class User{

    String name;

    User(String name) {

        this.name = name;

    }

}

运行结果：

开始交换---------------------------------

交换后ZhangSan的名字：李四

交换后LiSi的名字：张三

交换结束---------------------------------

交换后ZhangSan的名字：张三

交换后LiSi的名字：李四

如下图所示，值传递的意思是将引用进行值传递，希望下图能对大家理解上有所帮助。

造成错觉的原因

造成我们认为Java在传递参数时，参数如果是普通类型，那就是值传递，如果是对象，那就是引用传递的原因就是，我们将传入的对象修改后，开始创建的对象内容也会改变。

最好的理解方式就是：

我们传入的参数只是钥匙，值传递就是配两把钥匙给方法，引用传递就是把自己的钥匙给方法；

如果把自己的钥匙给方法，方法内交换了钥匙之后，我们自己的钥匙也就被掉包了（引用传递）；

如果是额外配两把钥匙给对方，方法内交换的钥匙是新配的钥匙，不会影响我们自己的钥匙（值传递）；

需要注意的是，无论是使用自己的钥匙，还是后配的钥匙，打开房门，修改房屋内结构，这个变化是不受影响钥匙影响的，因为改变的不是钥匙。

在JVM中对象引用与对象信息的体现，如下图所示。

一. 前言

太极生两仪,两仪生四相，四相生八卦,八卦定吉凶

中国的八卦与西方的二进制其实原理上有极其相似的一面. 但是演化和推算方面, 八卦更胜一筹.

阴: 0, 阳: 1;

老阴: 00, 少阳: 10, 少阴: 01, 老阳: 11;

坤: 000, 艮: 100, 坎: 010,巽 :110, ,震: 001, 离:101, 兑: 011, 乾: 111;

二.正文.

计算机就是一个二进制的逻辑机器

计算机三大件:主板,CPU,内存; 而最主要的就是cpu, cpu的主要组成就是可以理解为晶体管, 晶体管也就相当于是个开关, 即打电报中的.和_. 这种二进制的简单也造就了计算机快的特性.

**计算机只会二进制, 那怎样才能让计算机有用呢? **

那就是约定大于配置

先是字符集

• ASCII字符集


• ISO 8859-1字符集


• GB2312字符集


• GBK字符集


• utf8字符集

数字, 以int为例子:

二进制在源码的巧妙使用(我们以java示例)

很多源码中使用了二进制来区分各个状态, 而且状态可以组合的形式.
主要使用的是& 和 |的计算来实现的.

0&0 = 0;           0|0 = 0;

0&1 = 0;           0|1 = 1;   

1&0 = 0;           1|0 = 1;   

1&1 = 1;           1|1 = 1;

例如:

Streams

public int characteristics() {

    // 既包含所有的特性

    return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED |

           Spliterator.IMMUTABLE | Spliterator.NONNULL |

           Spliterator.DISTINCT | Spliterator.SORTED;

}



public int characteristics() {

    if (beforeSplit) {

        // 两个共同都有的特性: aSpliterator.characteristics() & bSpliterator.characteristics()

        return aSpliterator.characteristics() & bSpliterator.characteristics()

               & ~(Spliterator.DISTINCT | Spliterator.SORTED

                   | (unsized ? Spliterator.SIZED | Spliterator.SUBSIZED : 0));

    }

    else {

        return bSpliterator.characteristics();

    }

}

public interface Spliterator<T> {

    public static final int ORDERED    = 0x00000010;



    public static final int DISTINCT   = 0x00000001;



    public static final int SORTED     = 0x00000004;



    public static final int SIZED      = 0x00000040;



    public static final int NONNULL    = 0x00000100;



    public static final int IMMUTABLE  = 0x00000400;



    public static final int CONCURRENT = 0x00001000;



    public static final int SUBSIZED = 0x00004000;

}

二进制在一些记录中的头信息巧妙使用

mysql中 COMPACT行格式 中一条记录.

JVM中一个对象的二进制的巧妙使用

二进制解决一些有趣的问题

有1000桶酒，其中1桶有毒。而一旦吃了，毒性会在1周后发作。现在我们用小老鼠做实验，要在1周后找出那桶毒酒，问最少需要多少老鼠。

这个问题其实大家都见到过. 解题思路也巧妙地使用了二进制来完成.

• 
  

  把10只老鼠依次排队为：0 - 9，关在笼子里

  
  


• 
  

  把1000瓶药依次编号，并换算成二进制，如 8 = 1000，根据二进制中出现1的位数对相应位置小鼠喝药。 因为我们选择的是10只

  
  

  小鼠，2^10 = 1024 > 1000,能够保证所有的编号的酒都能被喂小鼠而不会遗漏被转为二进制的1的位.

  
  


• 
  

  长时间的等待，等待小鼠的死亡

  
  


• 
  

  把死亡小鼠的依次记录，然后10位的二进制中, 死亡老鼠编号对应10位中的二进制数为1, 没死的老鼠编号对应10为中的二进制数为0, 即知毒药的编号.

首先我们需要去了解一下, 二叉搜索树的性质:

1. 对于 BST的每一个节点 node，左子树节点的值都比 node的值要小,右子树的值都要比node的值大。
2. 对于BST的每一个节点node， 它的左侧和右侧都是 BST

这里需要说明一下的是,从刷算法的角度来讲,还有一个重要的性质: BST的中序遍历的结果是有序的(升序)。

那么我们开始吧, 最近一直拖更，很不好意思.

230. 二叉搜索树中第K个小的元素

思路梳理 如果这么理解, 产生一个升序的序列(数组)，那么我们可以根据第k个小的元素 1,2,3,4,5这里第1个小的元素在哪里？那不就是1嘛.刚好借助于BST中序遍历的结果。是不是就很巧了呢。

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {TreeNode} root

 * @param {number} k

 * @return {number}

 */

// BST 的两个性质 左边的比右边的大

// 中序遍历的结果是 升序的 



var kthSmallest = function(root, k) {

    // 返回结果 记录结果

    let res = 0;

    // 记录升序之后的排名

    let count = 0;

    function traverse(root, k) {

        // base case

        if (root === null) return

        

        traverse(root.left, k)

        //中序

        count++;

        if (count === k) {

           res = root.val;

           return res;

        }

        traverse(root.right, k)

    }

    

    //定义函数

    traverse(root, k)

    return res;

}

538. 把二叉搜索树转换为累加树

思路梳理

其实这道题需要需要一个反过来的想法, BST的中序遍历的结果是升序的, 如果我们稍微作为一下修改呢？

function traverse(root) {

    

    traverse(root.right)

    // 中序遍历的结果是不是就成了 逆序(降序)的方式排列呢

    // 这里做累加的结果

    traverse(root.left)

}

traverse(root)

通过逆向的思考方式, 我从 8开始，也就是右子树开始依次去右中左的方式去遍历和累加和，是不是会更好一点呢，你可以思考一下,仔细去看一下那颗实例树:

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {TreeNode} root

 * @return {TreeNode}

 */

 

 var convertBST = function(root) {

     // 升序变为降序

     // sum 记录累加和

     let sum = 0;

     

     function traverse(root) {

         // base case

         if (root === null) return

         

         traverse(root.right)

         // 维护累加值

         sum += root.val;

         root.val = sum;

         traverse(root.left)

     }

     traverse(root)

     return root;

 }

1038. 从搜索树到更大的和树

思路梳理

这道题和上题完全一样的思路和写法这里就不做赘述了

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {TreeNode} root

 * @return {TreeNode}

 */

var bstToGst = function(root) {

    // 升序变降序

    // 记录累加和

    let sum = 0;

    

    function traverse(root) {

        if (root === null) return;

        

        traverse(root.right)

        // 累加和

        sum += root.val;

        root.val = sum;

        traverse(root.left)

    }

    traverse(root)

    return root;

}

654. 最大二叉树

思路梳理

其实对于构建一颗二叉树最关键的是把root也就是把根节点找出来就好了。 那么我们就需要去遍历去找出数组中最大的值maxVal，把根节点root找出来了。 那么就可以把 maxVal左边和右边的数组进行递归，作为root的左右子树

// 伪代码

var constructMaximumBinaryTree = function([3,2,1,6,0,5]) {

    // 找出数组中的最大值

    let root = TreeNode(6)

    

    let root.left = constructMaximumBinaryTree([3,2,1])

    let root.right = constructMaximumBinaryTree([0,5])

    return root;

}

这里我们需要的注意的是如何去构建一个递归函数: 参数是如何要求的？ 因为需要 分离左子树和右子树 我们需要不断的确认子树的开始和结束的位置

function build (nums, start, end) {

    // base case

    if (left > right) return;

    

    let maxValue = -1, index = -1; // index 是最大值的索引值是重要的分离条件

    // find

    for (let i = start; i < end; i++) {

        if (nums[i] > maxValue) {

           maxValue = nums[i];

           index = i;

        }

    }

    // 此时去构建树 root;

    let root = new TreeNode(maxValue);

    

    root.left = build(nums, start, index - 1)

    root.right = build(nums, index + 1, end)

    // 别忘了返回 

    return root;

}

这里其实我们已经写出来的本题的核心代码了,需要我们自己耐心的组合一下就好了啊

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {number[]} nums

 * @return {TreeNode}

 */

var constructMaximumBinaryTree = function(nums) {

    let root = build(nums, 0, nums.length-1)

    return root;

}



function build(nums, start, end) {

     // base case 

     if (left > right) return;

     

     let maxVal = -1, index = -1;

     for (let i = start; i < end; i++) {

         if (nums[i] > maxVal) {

            maxVal = nums[i]

            index = i;

         }

     }

     

     // 制作树

     let root = new TreeNode(maxVal)

     

     root.left = build(nums, start, index - 1)

     root.right = build(nums, index + 1, end)

     return root;

}

98. 验证二叉搜索树

思路分析

BST类似的代码逻辑就是利用 左小右大的特性

function BST(root, target) {

    if (root.val === target) {

       // 找到目标做点什么呢

    }

    if (root.val < target) {

       // 右 比 root 大

       BST(root.right, target)

    }

    if (root.val > target) {

       // 左 比 root 小

       BST(root.left, target)

    }

}

那么对于我们去验证一棵树是不是合法的是需要注意一些事情的：

1. 对于每一个节点 root代码值都需要去检查它的左右孩子节点是否都是符合左小右大的原则
2. 从 BST的定义出发的话, root的整个左子树都要小于 root.val, 整个右子树都要大于 root.val

但是就会产生一个问题,就是对于某个节点,它只能管得了自己的左右子节点,如何去把约束关系传递给左右子树呢？

left.val < root.val < right.val

是不是可以借助于这种关系去约束他们呢？

主函数的定义

function isValidBST(root, null, null)

对于左子树来说 每一个左子树的 val 都需要满足于 min.val < val < root.val

isValidBST(root.left, min, root) 

那么同样的对于 每一个右子树的 val 都需要满足于 root.val < val < max.val

isValidBST(root.right, root, max)

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {TreeNode} root

 * @return {boolean}

 */

var isValidBST = function(root) {

    return isValid(root, null, null)

}



function isValid(root, min, max) {

    // 怎么就合法了呢？ 找完还一直没报false 不就是满足条件的吗

    if (root === null) return true;

    // 比最小的还小 不合法

    if (min !== null && root.val <= min.val) return false;

    // 比最大的还大。不合法

    if (max !== null && root.val >= max.val) return false;

    

    return isvalid(root.left, min, root) && isValid(root.right, root, max)

}

700. 二叉搜索树中的搜索

思路分析

其实，你看像不像我们上面提到的二叉树的思维模版呢？ 题目要求是 找到对应的val的节点, 并返回以该节点为根的子树 其实就是可以理解为 返回当前节点就好了 会带有以 该节点为根的一颗子树的。

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {TreeNode} root

 * @param {number} val

 * @return {TreeNode}

 */

 

 var searchBST = function(root, val) {

     // base case 

     if (root === null) return null;

     

     if (root.val === val) {

        return root;

     }

     

     if (root.val < val) {

       searchBST(root.right)

     }

     if (root.val > val) {

       searchBST(root.left)

     }



 }

701. 二叉搜索树中的插入操作

思路分析

这里 需要注意的一点就是你你怎么样才能插入呢？如果是 target === val说明不是空位置, 那就插不进去啊, 所以我们要插入的位置肯定是一个空位置, 你如果认真分析过 这个过程 你对 base case 有没有一个全新的认识呢？ 就是这里

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {TreeNode} root

 * @param {number} val

 * @return {TreeNode}

 */

var insertIntoBST = function(root, val) {

    // base case

    if (root === null) // 插入

    return new TreeNode(val)

    

    // if (root === val) 不需要了

    if (root.val < val) {

        insertIntoBST(root.right)

    }

    if (root.val > val) {

        insertIntoBST(root.left)

    }

}

450. 删除二叉搜索树中的节点

思路分析

先上一个基本的模版：

var deleteNode = function(root, key) {

    // 基本的摹本

    if (root === null) return null;

    

    if (root.val === key) {

       // 删除操作

    }

    

    if (root.val < key) {

       deleteNode(root.right, val)

    }

    if (root.val > key) {

       deleteNode(root.left, val)

    }

}

当 root.val === key的时候 需要我们去执行一个删除的逻辑了

case1: 没有子孩子

if (root.left === null && root.right) reture null;

case2: 只有一个非空节点的情况,那么需要这个非空的节点接替自己的位置

if (root.left === null) return root.right;

if (root.right === null) return root.left;

case3: 如果有两个节点就麻烦了,我们就需要把 左子树中最大的或者是右子树中最小的元素来接替自己， 我们采用第二种方式

if (root.left !== null && root.right !== null) {

    // 找到右子树中的最小的节点

    let minNode = getMin(root.right)

    // 把当前的值 替换为最小的值

    root.val = minNode;

    // 我们还需要把右子树中最小的值 删除掉

    root.right = deleteNode(root.right, minNode.val)

}

获取右子树中最小的元素

// 其实这里的最小的就是 左子树

function getMin(node) {

    while (node.left !== null)  继续找下面的左子树

    node = node.left;

    return node;  // 没有发现和前端的原型链好像啊

}

代码实现

/**

 * Definition for a binary tree node.

 * function TreeNode(val, left, right) {

 *     this.val = (val===undefined ? 0 : val)

 *     this.left = (left===undefined ? null : left)

 *     this.right = (right===undefined ? null : right)

 * }

 */

/**

 * @param {TreeNode} root

 * @param {number} key

 * @return {TreeNode}

 */

var deleteNode = function(root, key) {

    // 基本的摹本

    if (root === null) return null;

    

    if (root.val === key) {

       // 删除操作

       // case1, 2

       if (root.left === null) return root.right;

       if (root.right === null) return root.left;

       // case 3

       let minNode = getMin(root.right);

       root.val = minNode.val; // 一加

       root.right = deleteNode(root.right, minNode); // 一减

    }

    

    if (root.val < key) {

       deleteNode(root.right, val)

    }

    if (root.val > key) {

       deleteNode(root.left, val)

    }

    

    function getMin(node) {

        while(node.left !== null) node = node.left;

        return node;

    }

}

嗯，当然

不能

进入正题，Kotlin中，高阶函数的身影无处不在，听上去高端大气上档次的高阶函数，简化一点讲，其实就是Lambda + 函数。

如果，Lambda学不好，就会导致高阶函数学不好，就会导致协程等等一系列的Kotlin核心学不好，Kotlin自然就一知半解了。所以，下面，一起来学习吧。

开始一个稍微复杂一点的实现

需求如下：传入一个参数，打印该参数，并且返回该参数

分析

乍看需求，这还不简单，一个print加一个return不就完事了，但是如果用Lambda，该怎么写呢？

val myPrint = { str: String ->

    print("str is $str")

    str

}

• 这里划第一个重点，Lambda的最后一行作为返回值输出。此时，如果直接打印myPrint，是可以直接输出的

fun main() {

    println(myPrint("this is kotlin"))

}

结果和预想一致。如果对这种函数的写法结构有什么疑惑的，可以查看juejin.cn/post/701173…

String.()

一脸懵逼，这是啥玩意？（此处应有表情 尼克杨问号脸）

先写个例子看看

val testStr : String.() -> Unit = {

    print(this)

}

• 官方一点解释，在.和()之间没有函数名，所以这是给String增加了一个匿名的扩展函数，这个函数的功能是打印String。在括号内，也就是Lambda体中，会持有String本身，也就是this。怎么调用呢？如下：

fun main() {

    "hello kotlin".testStr()

}

// 执行结果：hello kotlin

• 此外这里还有一个重点：扩展函数是可以全局调用的


• 扩展函数有啥用？举个例子，如果对Glide提供的方法不满意，可以直接扩展一个Glide.xxx函数供自己调用，在xxx函数内部，可以取到this，也就是Glide本身。


• 有兴趣可以看一下Compose的源码，原来扩展函数还可以这么用

终极形态

先看代码

val addInt : Int.(Int) -> String = {

    "两数相加的结果是${this + it}"

}

用已有的知识分析一下：

• Int.():匿名的扩展函数


• this：当前的Int，也就是调用这个扩展函数的对象


• "两数相加的结果是${this + it}" ： Lambda的最后一行，也就返回值

如何调用

一般有如下两种调用方式：

fun main() {

    println(addInt(1,2))

    println(1.addInt(2)) 

}

• 第二种更加符合规范，之所以可以有第一种写法，是因为this会默认作为第一个参数


• 此处可以记住一个知识点，扩展了某一个函数，扩展函数内部的this就是被扩展的函数本身

Kotlin函数返回值那些事

在Kotlin函数中，如果不指定函数的返回值类型，则默认为Unit

fun output() {println("helle kotlin")}

• 上述函数的返回值为Unit类型

当函数体中出现return的时候，则需要手动为函数指定类型

fun output2() : Int {

    return 0

}

• 返回Int类型的0，需要手动指定函数的返回值类型，否则报错

如果是以下的函数，那么返回值为？

fun output3() = {}

• 此处的返回值为() -> Unit，可省略，写全了，就是如下的样子：

fun output3() : () -> Unit = {}

• 此处函数返回函数，已经是高阶函数的范畴了

如果函数接着套一个函数呢，比如

fun output4() = run { println("hello kotlin") }

• 虽说run是一个函数，但是此处的返回值就不是() -> Unit


• 此处的返回就是run的返回值，但是run是什么？

@kotlin.internal.InlineOnly

public inline fun <R> run(block: () -> R): R {

    contract {

        callsInPlace(block, InvocationKind.EXACTLY_ONCE)

    }

    return block()

}

• run的作用就是执行内部的函数，在这里就是println方法。


• run的返回自是R，也就是泛型，具体一点就是println的返回值，这里println的返回值是Unit，所以可以得出上面的output4的返回值就是Unit。


• 这里如果不是很懂的话，可以看一个简单一点的例子

fun output5() = run {true}

• 此处，函数的返回值就是true的类型，Boolen

函数中套一个函数怎么传参呢

刚刚的例子中，知道了怎么写一个函数中套函数，那么其中嵌套得函数怎么传参呢

fun output6() = {a: Int ->  println("this is $a")}

• a为参数，函数是println，所以output6的返回值类型为(Int) -> Unit


• 如果需要调用的话，需要这么写：

output6()(1)

最后一个重点：在写Lambda的时候，记住换行

几种函数写法的区别

fun a()

常见的函数

val a = {}

a是一个变量，只不过是一个接受了匿名函数的变量，可以执行这个函数，和第一种现象一致。

这里的a还可以赋值给另一个变量 val a2 = a，但是函数本身不能直接赋给一个变量，可以使用::，让函数本身变成函数的引用

--end---

列表流畅度优化

这是一个通用的流畅度优化方案，通过分帧渲染优化由构建导致的卡顿，例如页面切换或者复杂列表快速滚动的场景。

代码中 example 运行在 VIVO X23（骁龙 660），在相同的滚动操作下优化前后 200 帧采集数据指标对比（录屏在文章最后）：

优化前	优化后

监控工具来自：fps_monitor，指标详细信息：页面流畅度不再是谜！调试神器开箱即用，Flutter FPS检测工具

• 流畅：一帧耗时低于 18ms
• 良好：一帧耗时在 18ms-33ms 之间
• 轻微卡顿：一帧耗时在 33ms-67ms 之间
• 卡顿：一帧耗时大于 66.7ms

采用分帧优化后，卡顿次数从 平均 33.3 帧出现了一帧，降低到 200 帧中仅出现了一帧，峰值也从 188ms 降低到 90ms。卡顿现象大幅减轻，流畅帧占比显著提升，整体表现更流畅。下方是详细数据。

页面切换流畅度提升

在打开一个页面或者 Tab 切换时，系统会渲染整个页面并结合动画完成页面切换。对于复杂页面，同样会出现卡顿掉帧。借助分帧组件，将页面的构建逐帧拆解，通过 DevTools 中的性能工具查看。切换过程的峰值由 112.5ms 降低到 30.2 ms，整体切换过程更加流畅。

实际优化合集：Keframe 流畅度优化实践合集

如何使用？

项目依赖：

在 pubspec.yaml 中添加 keframe 依赖

dependencies:

  keframe: version

组件仅区分非空安全与空安全版本

非空安全使用： 1.0.2

空安全版本使用： 2.0.2

github 地址：github.com/LianjiaTech…

pub 查看：pub.dev/packages/ke…

Dont forget star ~

快速上手：

如下图所示

假如现在页面由 A、B、C、D 四部分组成，每部分耗时 10ms，在页面时构建为 40ms。使用分帧组件 FrameSeparateWidget 嵌套每一个部分。页面构建时会在第一帧渲染简单的占位，在后续四帧内分别渲染 A、B、C、D。

对于列表，在每一个 item 中嵌套 FrameSeparateWidget，并将 ListView 嵌套在 SizeCacheWidget 内即可。

构造函数说明

FrameSeparateWidget ：分帧组件，将嵌套的 widget 单独一帧渲染

SizeCacheWidget：缓存子节点中，分帧组件嵌套的实际 widget 的尺寸信息

方案设计与分析：

卡顿的本质，就是 单帧的绘制时间过长。基于此自然衍生出两种思路解决：

1、减少一帧的绘制耗时，因为导致耗时过长的原因有很多，比如不合理的刷新，或者绘制时间过长，都有可能，需要具体问题具体分析，后面我会分享一些我的优化经验。

2、在不对耗时优化下，将一帧的任务拆分到多帧内，保证每一帧都不超时。这也是本组件的设计思路，分帧渲染。

如下图所示:

原理并不复杂，问题在于如何在 Flutter 中实践这一机制。

因为涉及到帧与系统的调度，自然联想到看 SchedulerBinding 中有无现成的 API。

发现了 scheduleTask 方法，这是系统提供的一个执行任务的方法，但这个方法存在两个问题：

• 1、其中的渲染任务是优先级进行堆排序，而堆排序是不稳定排序，这会导致任务的执行顺序并非 FIFO。从效果上来看，就是列表不会按照顺序渲染，而是会出现跳动渲染的情况

• 2、这个方法本身存在调度问题，我已经提交 issue 与 pr，不过一直卡在单元测试上，如果感兴趣可以以在这里交流谈论。

fix: Tasks scheduled through 'SchedulerBinding.instance.scheduleTask'… #82781

最终，参考这个设计结合 endOfFrame 方法的使用，完成了分帧队列。整个渲染流程变为下图所示：

对于列表构建场景来说，假设屏幕上能显示五个 item。首先在第一帧的时候，列表会渲染 5 个占位的 Widget，同时添加 5 个高优先级任务到队列中，这里的任务可以是简单的将占位 Widget 和实际 item进行替换，也可通过渐变等动画提升体验。在后续的五帧中占位 Widget 依次被替换成实际的列表 item。

在 ListView流畅度翻倍！！Flutter卡顿分析和通用优化方案 这篇文章中有更加详细的分析。

一些展示效果（Example 说明请查看 Github）

卡顿的页面往往都是由多个复杂 widget 同时渲染导致。通过为复杂的 widget 嵌套分帧组件 FrameSeparateWidget。渲染时，分帧组件会在第一帧同时渲染多个 palceHolder，之后连续的多帧内依次渲染复杂子项，以此提升页面流畅度。

例如 example 中的优化前示例：

ListView.builder(

              itemCount: childCount,

              itemBuilder: (c, i) => CellWidget(

                color: i % 2 == 0 ? Colors.red : Colors.blue,

                index: i,

              ),

            )

其中 CellWidget 高度为 60，内部嵌套了三个 TextField 的组件（整体构建耗时在 9ms 左右）。

优化仅需为每一个 item 嵌套分帧组件，并为其设置 placeHolder（placeHolder 尽量简单，样式与实际 item 接近即可）。

在列表情况下，给 ListView 嵌套 SizeCacheWidget，同时建议将预加载范围 cacheExtent 设置大一点，例如 500（该属性默认为 250），提升慢速滑动时候的体验。

此外，也可以给 item 嵌套透明度/位移等动画，优化视觉上的效果。

效果如下图：

分帧的成本

当然分帧方案也非十全十美，在我看来主要有两点成本：

1、额外的构建开销：整个构建过程的构建消耗由「n * widget消耗 」变成了「n *（ widget + 占位）消耗 + 系统调度 n 帧消耗」。可以看出，额外的开销主要由占位的复杂度决定。如果占位只是简单的 Container，测试后发现整体构建耗时大概提升在 15 % 左右。这种额外开销对于当下的移动设备而言，成本几乎可以不计。

2、视觉上的变化：如同上面的演示，组件会将 item 分帧渲染，页面在视觉上出现占位变成实际 widget 的过程。但其实由于列表存在缓存区域（建议将缓存区调大），在高端机或正常滑动情况下用户并无感知。而在中低端设备上快速滑动能感觉到切换的过程，但比严重顿挫要好。

优化前后对比演示

注：gif 帧率只有20

优化前	优化后

最后：一点点思考

列表优化篇到此告一段落，在整个开源实践过程中，有两点感触较深：

「点」与「面」的关系

我们在思考技术方案的时候可以由「点」到「面」，站在一个较高视野去想问题的本质。

而在执行的时候则需要由「面」到「点」的进行逐级拆分，抓住问题的关键节点，并且拟定进度计划，逐步破解。

很多时候，这种向上和向下的逻辑思维才是我们的核心竞争力。

以不变应万变

对于未知的东西，我们往往会过度的将它想复杂。在一开始分析列表构建原理的时候，我也苦于无从下手，走了很多弯路。但其实对于 Flutter 这套 「UI」 框架而言，核心仍然在于三棵树的构建机制。

在这套体系内，抓住不变的东西，无论是生命周期、路由等等问题都可以从里面找到答案。我之前也有过总结：Flutter 核心渲染机制 与 Flutter路由设计与源码解析 。

前言

大家好，我是林三心，用最通俗的话讲最难的知识点是我的座右铭，基础是进阶的前提是我的初心，今天跟大家来唠唠嗑，如果后端真的返回给前端10万条数据，咱们前端要怎么优雅地展示出来呢？（哈哈假设后端真的能传10万条数据到前端）

前置工作

先把前置工作给做好，后面才能进行测试

后端搭建

新建一个server.js文件，简单起个服务，并返回给前端10w条数据，并通过nodemon server.js开启服务

没有安装nodemon的同学可以先全局安装npm i nodemon -g

// server.js



const http = require('http')

const port = 8000;



http.createServer(function (req, res) {

  // 开启Cors

  res.writeHead(200, {

    //设置允许跨域的域名，也可设置*允许所有域名

    'Access-Control-Allow-Origin': '*',

    //跨域允许的请求方法，也可设置*允许所有方法

    "Access-Control-Allow-Methods": "DELETE,PUT,POST,GET,OPTIONS",

    //允许的header类型

    'Access-Control-Allow-Headers': 'Content-Type'

  })

  let list = []

  let num = 0



  // 生成10万条数据的list

  for (let i = 0; i < 100000; i++) {

    num++

    list.push({

      src: 'https://p3-passport.byteacctimg.com/img/user-avatar/d71c38d1682c543b33f8d716b3b734ca~300x300.image',

      text: `我是${num}号嘉宾林三心`,

      tid: num

    })

  }

  res.end(JSON.stringify(list));

}).listen(port, function () {

  console.log('server is listening on port ' + port);

})

复制代码

前端页面

先新建一个index.html

// index.html



// 样式

<style>

    * {

      padding: 0;

      margin: 0;

    }

    #container {

      height: 100vh;

      overflow: auto;

    }

    .sunshine {

      display: flex;

      padding: 10px;

    }

    img {

      width: 150px;

      height: 150px;

    }

  </style>



// html部分

<body>

  <div id="container">

  </div>

  <script src="./index.js"></script>

</body>

复制代码

然后新建一个index.js文件，封装一个AJAX函数，用来请求这10w条数据

// index.js



// 请求函数

const getList = () => {

    return new Promise((resolve, reject) => {

        //步骤一:创建异步对象

        var ajax = new XMLHttpRequest();

        //步骤二:设置请求的url参数,参数一是请求的类型,参数二是请求的url,可以带参数

        ajax.open('get', 'http://127.0.0.1:8000');

        //步骤三:发送请求

        ajax.send();

        //步骤四:注册事件 onreadystatechange 状态改变就会调用

        ajax.onreadystatechange = function () {

            if (ajax.readyState == 4 && ajax.status == 200) {

                //步骤五 如果能够进到这个判断 说明 数据 完美的回来了,并且请求的页面是存在的

                resolve(JSON.parse(ajax.responseText))

            }

        }

    })

}



// 获取container对象

const container = document.getElementById('container')

复制代码

直接渲染

最直接的方式就是直接渲染出来，但是这样的做法肯定是不可取的，因为一次性渲染出10w个节点，是非常耗时间的，咱们可以来看一下耗时，差不多要消耗12秒，非常消耗时间

const renderList = async () => {

    console.time('列表时间')

    const list = await getList()

    list.forEach(item => {

        const div = document.createElement('div')

        div.className = 'sunshine'

        div.innerHTML = `<img src="${item.src}" /><span>${item.text}</span>`

        container.appendChild(div)

    })

    console.timeEnd('列表时间')

}

renderList()

复制代码

setTimeout分页渲染

这个方法就是，把10w按照每页数量limit分成总共Math.ceil(total / limit)页，然后利用setTimeout，每次渲染1页数据，这样的话，渲染出首页数据的时间大大缩减了

const renderList = async () => {

    console.time('列表时间')

    const list = await getList()

    console.log(list)

    const total = list.length

    const page = 0

    const limit = 200

    const totalPage = Math.ceil(total / limit)



    const render = (page) => {

        if (page >= totalPage) return

        setTimeout(() => {

            for (let i = page * limit; i < page * limit + limit; i++) {

                const item = list[i]

                const div = document.createElement('div')

                div.className = 'sunshine'

                div.innerHTML = `<img src="${item.src}" /><span>${item.text}</span>`

                container.appendChild(div)

            }

            render(page + 1)

        }, 0)

    }

    render(page)

    console.timeEnd('列表时间')

}

复制代码