一、题目

难度中等

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"输出: 3解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"输出: 1解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"输出: 3解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 请注意，你的答案必须是 子串 的长度，"pwke" 是一个*子序列，*不是子串。

示例 4:

输入: s = ""输出: 0

提示：

• 0 <= s.length <= 5 * 104

• s 由英文字母、数字、符号和空格组成

二、我的解答

第一次解答：

我的思路跟官方的差不多，把光标从第一个开始，寻找最长

只不过我是每次删除第一个就全部重新加，而不是他那个窗口移动的概念

public static int lengthOfLongestSubstring(String s) {

    int selection = 0;

    int maxSize=0;

    while (selection < s.length()) {

        HashMap map = new HashMap<>();

        List mapList = new ArrayList<>();

        for (int i = selection; i < s.length(); i++) {

            char val = s.charAt(i);

            if (!map.containsKey(val)) {

                map.put(val, val);

                mapList.add(val);

            } else {

                break;

            }

        }

        maxSize=Math.max(mapList.size(),maxSize);

        selection++;

        if (mapList.size() >= (s.length() - selection)) {

            break;

        }

    }

    return maxSize;

}

通过：

三、系统解答

方法一：滑动窗口

思路及算法

我们先用一个例子考虑如何在较优的时间复杂度内通过本题。

我们不妨以示例一中的字符串abcabcbb 为例，找出从每一个字符开始的，不包含重复字符的最长子串，那么其中最长的那个字符串即为答案。对于示例一中的字符串，我们列举出这些结果，其中括号中表示选中的字符以及最长的字符串：

以(a)bcabcbb 开始的最长字符串为(abc)abcbb；

以a(b)cabcbb 开始的最长字符串为a(bca)bcbb；

以 ab(c)abcbb 开始的最长字符串为ab(cab)cbb；

以 abc(a)bcbb 开始的最长字符串为 abc(abc)bb；

以 abca(b)cbb 开始的最长字符串为abca(bc)bb；

以abcab(c)bb 开始的最长字符串为abcab(cb)b；

以abcabc(b)b 开始的最长字符串为abcabc(b)b；

以abcabcb(b) 开始的最长字符串为 abcabcb(b)。

发现了什么？如果我们依次递增地枚举子串的起始位置，那么子串的结束位置也是递增的！这里的原因在于，假设我们选择字符串中的第 k 个字符作为起始位置，并且得到了不包含重复字符的最长子串的结束位置为 r_k 。那么当我们选择第 k+1 个字符作为起始位置时，首先从 k+1到 r_k的字符显然是不重复的，并且由于少了原本的第 k 个字符，我们可以尝试继续增大 r_k，直到右侧出现了重复字符为止。

这样一来，我们就可以使用「滑动窗口」来解决这个问题了：

我们使用两个指针表示字符串中的某个子串（或窗口）的左右边界，其中左指针代表着上文中「枚举子串的起始位置」，而右指针即为上文中的 r_k；

在每一步的操作中，我们会将左指针向右移动一格，表示 我们开始枚举下一个字符作为起始位置，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。在移动结束后，这个子串就对应着 以左指针开始的，不包含重复字符的最长子串。我们记录下这个子串的长度；

在枚举结束后，我们找到的最长的子串的长度即为答案。

判断重复字符

在上面的流程中，我们还需要使用一种数据结构来判断是否有重复的字符，常用的数据结构为哈希集合（即 C++ 中的 std::unordered_set，Java 中的 HashSet，Python 中的 set, JavaScript 中的 Set）。在左指针向右移动的时候，我们从哈希集合中移除一个字符，在右指针向右移动的时候，我们往哈希集合中添加一个字符。

至此，我们就完美解决了本题。

注释：思路和我一样，代码比我写的简单太多了吧

class Solution {    public int lengthOfLongestSubstring(String s) {

        // 哈希集合，记录每个字符是否出现过

        Set<Character> occ = new HashSet<Character>();

        int n = s.length();

        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动

        int rk = -1, ans = 0;

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

            if (i != 0) {

                // 左指针向右移动一格，移除一个字符

                occ.remove(s.charAt(i - 1));

            }

            //判断rk+1<n是为了确定右指针是否已经走到了最后

            //右指针走到最后的情况，说明后续都可以走到最后，只需用rk-i+1确定

            while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {

                // 不断地移动右指针

                occ.add(s.charAt(rk + 1));

                ++rk;

            }

            // 第 i 到 rk 个字符是一个极长的无重复字符子串

            ans = Math.max(ans, rk - i + 1);

        }

        return ans;

    }

}

复杂度分析

• 时间复杂度：O(N)，其中 N 是字符串的长度。左指针和右指针分别会遍历整个字符串一次。

• 空间复杂度：O(∣Σ∣)，其中Σ 表示字符集（即字符串中可以出现的字符），∣Σ∣ 表示字符集的大小。在本题中没有明确说明字符集，因此可以默认为所有 ASCII 码在 [0,128) 内的字符，即 ∣Σ∣=128。我们需要用到哈希集合来存储出现过的字符，而字符最多有 ∣Σ∣ 个，因此空间复杂度为 O(∣Σ∣)。

这个网友的很精彩

class Solution {    public int lengthOfLongestSubstring(String s) {

        // 记录字符上一次出现的位置

        int[] last = new int[128];

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

            last[i] = -1;

        }

        int n = s.length();



        int res = 0;

        int start = 0; // 窗口开始位置

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

            int index = s.charAt(i);

            start = Math.max(start, last[index] + 1);

            res   = Math.max(res, i - start + 1);

            last[index] = i;

        }



        return res;

    }

}

答案有个缺点，左指针并不需要依次递增，即多了很多无谓的循环。 发现有重复字符时，可以直接把左指针移动到第一个重复字符的下一个位置即可。

每次左指针右移一位，移除set的一个字符，这一步会导致很多无用的循环。while循环发现的重复字符不一定就是Set最早添加那个，还要好多次循环才能到达，这些都是无效循环，不如直接用map记下每个字符的索引，直接进行跳转

文字环绕

需求

最近接到一个需求，类似于文字环绕，标题最多两行，超出省略，标题后面可以添加标签。效果如下：

富文本不能控制省略和折行，Flutter 提供了 TextPainter可以实现。

分析

标签有文字和颜色两个属性，个数不定：

class Tag {



  /// 标签文本

  final String label;

  /// 标签背景颜色

  final Color color;



  Tag({required this.label, required this.color});

}

标题最大行数可变，可能明天产品要最多显示三行；

文本样式可变；

先创建出来对应的Widget：

class TagTitle extends StatefulWidget {

  const TagTitle(

    this.text, {

    Key? key,

    required this.tags,

    this.maxLines = 2,

    this.style = const TextStyle(color: Colors.black, fontSize: 16),

  }) : super(key: key);

  

  final String text;

  final int maxLines;

  final TextStyle style;

  final List<Tag> tags;

  }

实现

标题文字和标签文字有两种显示情况：

1. 超出最大行数；


2. 未超出最大行数；

先假设第一种情况，因为标签前后有间距，所以每个标签前后补一个空格，再把标题和文字拼接创建对应的TextSpan：

    tagTexts = widget.tags.fold<String>(

        ' ', (previousValue, element) => '$previousValue${element.label} ');

        

    _allSp = TextSpan(

      text: '${widget.text}$tagTexts',

      style: widget.style,

    );

        

要绘制标题、省略号、标签、都需要TextSpan，所以一并创建出来，当然还有最重要的TextPainter：

// 标签

final tagsSp = TextSpan(

  text: tagTexts,

  style: widget.style,

);



// 省略号

final ellipsizeTextSp = TextSpan(

  text: ellipsizeText,

  style: widget.style,

);



// 标题

final textSp = TextSpan(

  text: widget.text,

  style: widget.style,

);



final textPainter = TextPainter(

  text: tagsSp,

  textDirection: TextDirection.ltr,

  maxLines: widget.maxLines,

)..layout(

    minWidth: constraints.minWidth,

    maxWidth: constraints.maxWidth,

  );

拿到标签、省略号、标题的尺寸：

final tagsSize = textPainter.size;



textPainter.text = ellipsizeTextSp;

textPainter.layout(

  minWidth: constraints.minWidth,

  maxWidth: constraints.maxWidth,

);



final ellipsizeSize = textPainter.size;



textPainter.text = textSp;

textPainter.layout(

  minWidth: constraints.minWidth,

  maxWidth: constraints.maxWidth,

);

final textSize = textPainter.size;

算出标题超出最大长度的位置：

textPainter.text = _allSp;

textPainter.layout(

  minWidth: constraints.minWidth,

  maxWidth: constraints.maxWidth,

);



final pos = textPainter.getPositionForOffset(Offset(

  textSize.width - tagsSize.width - ellipsizeSize.width,

  textSize.height,

));



final endIndex = textPainter.getOffsetBefore(pos.offset);

如果超出的话，文字显示区域的宽度减去标签宽度减去省略号宽度，剩下的位置就是标题最大宽度偏移量，根据偏移量得到此位置的文字位置下标。

textPainter.didExceedMaxLines返回的是是否超出最大长度，也就是一开始分析的两种情况的哪一种，如果超出，就根据上面计算出来的下标截取标题文字，添加省略号，然后添加上标签；否则，直接显示标题文本和标签：

TextSpan textSpan;



if (textPainter.didExceedMaxLines) {

  textSpan = TextSpan(

    style: widget.style,

    text: widget.text.substring(0, endIndex) + ellipsizeText,

    children: _getWidgetSpan(),

  );

} else {

  textSpan = TextSpan(

    style: widget.style,

    text: widget.text,

    children: _getWidgetSpan(),

  );

}

return RichText(

  text: textSpan,

  overflow: TextOverflow.ellipsis,

  maxLines: widget.maxLines,

);

标签因为带有背景，所以可以用WidgetSpan加上标签背景，这里使用CustomPaint实现：

List<WidgetSpan> _getWidgetSpan() {

  return widget.tags

      .map((e) => WidgetSpan(

            child: CustomPaint(

              painter: BgPainter(e.color),

              child: Text(

                ' ' + e.label + ' ',

                style: widget.style,

              ),

            ),

          ))

      .toList();

}

这个BgPainter就一个功能，绘制背景色：

class BgPainter extends CustomPainter {

  final Paint _painter;



  final Color color;



  BgPainter(this.color) : _painter = Paint()..color = color;



  @override

  void paint(Canvas canvas, Size size) {

    canvas.drawRect(Rect.fromLTWH(2, 0, size.width - 2, size.height), _painter);

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) =>

      oldDelegate != this;

}

使用：

TagTitle(

  '据法新社报道，法国总统府爱丽舍宫发布消息称，法国',

  tags: [

    Tag(label: '热门', color: Colors.red),

    Tag(label: '国际', color: Colors.blue),

  ],

),

const Divider(

  color: Color(0xFF167F67),

),

TagTitle(

  '据法新社报道，法国总统府爱丽舍宫发布消息称，法国总统马克龙提议俄罗斯总统普京和美国总统sadaasdadadada',

  tags: [

    Tag(label: '热门', color: Colors.red),

    Tag(label: '国际', color: Colors.blue),

  ],

),

const Divider(

  color: Color(0xFF167F67),

),

TagTitle(

  '据法新社报道，法国总统府爱丽舍宫发布',

  tags: [

    Tag(label: '热门', color: Colors.red),

    Tag(label: '国际', color: Colors.blue),

  ],

),

const Divider(

  color: Color(0xFF167F67),

),

TagTitle(

  '据法新社报道，法国总统府爱丽舍宫发布消息称，法国总统马克龙提议俄罗',

  tags: [

    Tag(label: '热门', color: Colors.red),

    Tag(label: '国际', color: Colors.blue),

  ],

),

附上完整代码：

main.dart

import 'package:custom/review/tag_title.dart';

import 'package:flutter/material.dart';



void main() {

  runApp(const MyApp());

}



class MyApp extends StatelessWidget {

  const MyApp({Key? key}) : super(key: key);



  @override

  Widget build(BuildContext context) {

    return MaterialApp(

      title: 'Flutter Demo',

      theme: ThemeData(

        primarySwatch: Colors.blue,

      ),

      home: const MyHomePage(title: 'Flutter Demo Home Page'),

    );

  }

}



class MyHomePage extends StatefulWidget {

  const MyHomePage({Key? key, required this.title}) : super(key: key);



  final String title;



  @override

  State<MyHomePage> createState() => _MyHomePageState();

}



class _MyHomePageState extends State<MyHomePage> {

  @override

  Widget build(BuildContext context) {

    return Scaffold(

      appBar: AppBar(

        title: Text(widget.title),

      ),

      body: Column(

        crossAxisAlignment: CrossAxisAlignment.start,

        children: [

          TagTitle(

            '据法新社报道，法国总统府爱丽舍宫发布消息称，法国',

            tags: [

              Tag(label: '热门', color: Colors.red),

              Tag(label: '国际', color: Colors.blue),

            ],

          ),

          const Divider(

            color: Color(0xFF167F67),

          ),

          TagTitle(

            '据法新社报道，法国总统府爱丽舍宫发布消息称，法国总统马克龙提议俄罗斯总统普京和美国总统sadaasdadadada',

            tags: [

              Tag(label: '热门', color: Colors.red),

              Tag(label: '国际', color: Colors.blue),

            ],

          ),

          const Divider(

            color: Color(0xFF167F67),

          ),

          TagTitle(

            '据法新社报道，法国总统府爱丽舍宫发布',

            tags: [

              Tag(label: '热门', color: Colors.red),

              Tag(label: '国际', color: Colors.blue),

            ],

          ),

          const Divider(

            color: Color(0xFF167F67),

          ),

          TagTitle(

            '据法新社报道，法国总统府爱丽舍宫发布消息称，法国总统马克龙提议俄罗',

            tags: [

              Tag(label: '热门', color: Colors.red),

              Tag(label: '国际', color: Colors.blue),

            ],

          ),

        ],

      ),

    );

  }

}

Tag_title.dart:

//@dart=2.12

import 'package:flutter/material.dart';



import 'bg_painter.dart';



class TagTitle extends StatefulWidget {

  const TagTitle(

    this.text, {

    Key? key,

    required this.tags,

    this.maxLines = 2,

    this.style = const TextStyle(color: Colors.black, fontSize: 16),

  }) : super(key: key);



  final String text;

  final int maxLines;

  final TextStyle style;

  final List<Tag> tags;



  @override

  TagTitleState createState() => TagTitleState();

}



class TagTitleState extends State<TagTitle> {

  late final String tagTexts;

  late final TextSpan _allSp;

  final String ellipsizeText = '...';



  @override

  void initState() {

    super.initState();

    tagTexts = widget.tags.fold<String>(

        ' ', (previousValue, element) => '$previousValue${element.label} ');

    _allSp = TextSpan(

      text: '${widget.text}$tagTexts',

      style: widget.style,

    );

  }



  List<WidgetSpan> _getWidgetSpan() {

    return widget.tags

        .map((e) => WidgetSpan(

              child: CustomPaint(

                painter: BgPainter(e.color),

                child: Text(

                  ' ' + e.label + ' ',

                  style: widget.style,

                ),

              ),

            ))

        .toList();

  }



  @override

  Widget build(BuildContext context) {

    return LayoutBuilder(

      builder: (BuildContext context, BoxConstraints constraints) {

        assert(constraints.hasBoundedWidth);

        // 标签

        final tagsSp = TextSpan(

          text: tagTexts,

          style: widget.style,

        );



        // 省略号

        final ellipsizeTextSp = TextSpan(

          text: ellipsizeText,

          style: widget.style,

        );



        // 标题

        final textSp = TextSpan(

          text: widget.text,

          style: widget.style,

        );



        final textPainter = TextPainter(

          text: tagsSp,

          textDirection: TextDirection.ltr,

          maxLines: widget.maxLines,

        )..layout(

            minWidth: constraints.minWidth,

            maxWidth: constraints.maxWidth,

          );

        final tagsSize = textPainter.size;



        textPainter.text = ellipsizeTextSp;

        textPainter.layout(

          minWidth: constraints.minWidth,

          maxWidth: constraints.maxWidth,

        );



        final ellipsizeSize = textPainter.size;



        textPainter.text = textSp;

        textPainter.layout(

          minWidth: constraints.minWidth,

          maxWidth: constraints.maxWidth,

        );

        final textSize = textPainter.size;



        textPainter.text = _allSp;

        textPainter.layout(

          minWidth: constraints.minWidth,

          maxWidth: constraints.maxWidth,

        );



        final pos = textPainter.getPositionForOffset(Offset(

          textSize.width - tagsSize.width - ellipsizeSize.width,

          textSize.height,

        ));



        final endIndex = textPainter.getOffsetBefore(pos.offset);



        TextSpan textSpan;



        if (textPainter.didExceedMaxLines) {

          textSpan = TextSpan(

            style: widget.style,

            text: widget.text.substring(0, endIndex) + ellipsizeText,

            children: _getWidgetSpan(),

          );

        } else {

          textSpan = TextSpan(

            style: widget.style,

            text: widget.text,

            children: _getWidgetSpan(),

          );

        }

        return RichText(

          text: textSpan,

          overflow: TextOverflow.ellipsis,

          maxLines: widget.maxLines,

        );

      },

    );

  }

}

class Tag {



  /// 标签文本

  final String label;

  /// 标签背景颜色

  final Color color;



  Tag({required this.label, required this.color});

}

bg_painter.dart:

//@dart=2.12

import 'dart:ui' as ui;



import 'package:flutter/cupertino.dart';

import 'package:flutter/material.dart';



class BgPainter extends CustomPainter {

  final Paint _painter;



  final Color color;



  BgPainter(this.color) : _painter = Paint()..color = color;



  @override

  void paint(Canvas canvas, Size size) {

    canvas.drawRect(Rect.fromLTWH(2, 0, size.width - 2, size.height), _painter);

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) =>

      oldDelegate != this;

}

记得在之前掘金上看到Google开发者的账号发了一篇《从 LiveData 迁移到 Kotlin 数据流》的文章。在之前接触ViewModel和LiveDta的时候就有在思考，ViewModel和Repository之间交互，通过什么来实现。后来翻了一下资料，发现官方推荐在ViewModel和Repository通过Flow来作为桥梁进行交互。

为了响应官方号召，我又一顿了解Flow。但在了解了Flow之后，当时心中就有大大的疑惑，Flow能够实现LiveData的功能，并且比LiveData功能更加强大，为什么不使用Flow来作为View和ViewModel之间的桥梁。

而现在官方确实推荐将Flow作为方案来替代LiveData。LiveData一脸懵逼：那我走？

LiveData

LiveData在2017年推出以来，作为Jetpack大家族的元老级人物，为安卓的MVVM架构作出了非凡的贡献，毕竟在当时的背景环境，大家都深陷RxJava的支配。而LiveData作为观察者模式的框架，能够以更平滑的学习曲线来实现变量的订阅，比起RxJava那一套更加轻量级，而且作为Google的亲儿子，在生命周期的管理上也有更出色的表现。

LiveData的缺点：

而LiveData它的缺点其实也非常明显，LiveData肩负着为UI提供数据订阅的能力，所以他的数据订阅只能在主线程，可能会有小伙伴说可以在子线程通过postValue去发布数据啊。但是其实这个postValue是有坑的，被坑过的小伙伴都应该知道短时间通过多次postValue，中间可能会存在数据的丢失。

而且在复杂的场景LiveData支持的能力确实有一些尴尬。

总结一下LiveDta有几个缺点：

• 
  

  在异步线程修改数据可能存在数据丢失的问题

  
  


• 
  

  在复杂的场景，LiveData的能力有一些捉襟见肘

  
  

LiveData你别走

但我们也不应该踩一捧一，确实LiveData整体上有更低的学习成本，在一些简单的场景LiveData已经完全能够满足我们的需要。

而且官方也说过并不会废弃LiveData，原因是：

• 用 Java 写 Android 的人还需要它，因为Flow是协程的东西，所以如果你是用 Java 的，是没有办法使用Flow的，所以LiveData还是有意义的。


• LiveData 的使用比较简单，而且功能上对于简单场景也是足够的，而 RxJava 和 Flow 这种东西学起来就没 LiveData 那么直观。

Flow

Flow是Google官方提供的一个类似于RxJava的响应式编程模型。它是基于Kotlin协程的。
它相对于Rxjava具有以下特点：

• 具有更友好的API，学习成本较低


• 跟Kotlin协程、LiveData结合更紧密，Flow能够转换成LiveData，在ViewModel中直接使用


• 结合协程的作用域，当协程被取消时，Flow也会被取消，避免内存泄漏

我们知道Flow的特点之一就是冷流。那么什么是冷流呢？

• 
  

  冷流：当数据被订阅的时候，发布者才开始执行发射数据流的代码。并且当有多个订阅者的时候，每一个订阅者何发布者都是一对一的关系，每个订阅者都会收到发布者完整的数据。

  
  


• 
  

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

  
  

StateFlow

因为Flow是冷流，这与LiveData的特点完全不一样，因此Flow提供了StateFlow来实现热流。

StateFlow 是 SharedFlow 的一个比较特殊的变种，而 SharedFlow 又是 Kotlin 数据流当中比较特殊的一种类型。StateFlow 与 LiveData 是最接近的，因为:

• 它始终是有值的。


• 它的值是唯一的。


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


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

官方推荐当暴露 UI 的状态给视图时，应该使用 StateFlow。这是一种安全和高效的观察者，专门用于容纳 UI 状态。

StateFlow使用

StateFlow替换掉LiveData是简单的。我们来看看StateFlow的构造函数：

/**

 * Creates a [MutableStateFlow] with the given initial [value].

 */

@Suppress("FunctionName")

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

我们在ViewModel上游中不断的发送值，View层通过collect函数去获取到上游发送的数据。

StateFlow只有在值发生改变时才会返回，如果发生更新但值没有变化时，StateFlow不会回调collect函数，但LiveData会进行回调。

stateIn

StateIn 能够将普通的流转换为StateFlow，但转换之后还需要一些配置工作.

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


• started 控制共享的开始和结束的策略
  
  
  
  • Lazily: 当首个订阅者出现时开始，在 scope 指定的作用域被结束时终止。
  
  
  • Eagerly: 立即开始，而在 scope 指定的作用域被结束时终止。
  
  
  • WhileSubscribed能够指定当前不有订阅者后，多少时间取消上游数据和能够指定多少时间后，缓存中的数据被丢失，回复称initialValue的值。
  
  
  
  


• initialValue 初始值

WhileSubscribed

WhileSubscribed 策略会在没有收集器的情况下取消上游数据流。通过 stateIn 运算符创建的 StateFlow 会把数据暴露给视图 (View)，同时也会观察来自其他层级或者是上游应用的数据流。让这些流持续活跃可能会引起不必要的资源浪费，例如一直通过从数据库连接、硬件传感器中读取数据等等。当您的应用转而在后台运行时，您应当保持克制并中止这些协程。

@Suppress("FunctionName")

public fun WhileSubscribed(

    stopTimeoutMillis: Long = 0,

    replayExpirationMillis: Long = Long.MAX_VALUE

): SharingStarted =

    StartedWhileSubscribed(stopTimeoutMillis, replayExpirationMillis)

WhileSubscribed

WhileSubscribed支持传入stopTimeoutMillis和replayExpirationMillis参数。

其中stopTimeoutMillis支持设置超时停止的效果，单位为ms。当最后一个订阅者不再订阅上游时，StateFlow会停止上游数据的发送。

这样就可以提供APP的性能，当没有订阅者时或者应用被切到后台后会等待stopTimeoutMillis设置的时间后上游会停止发送数据，并且会缓存停止前的缓存数据。

replayExpirationMillis

如果当上游如果停止发送太久，这时候StateFlow中缓存的数据是比较陈旧的数据，当这时候有订阅者时，我们不希望给订阅者陈旧的数据。我们可以设置replayExpirationMillis参数，当停止共享携程超过设置的replayExpirationMillis时间后，StateFlow中会将缓存重置为默认值。

在视图中观察数据

ViewModel中的StateFlow需要结合生命周期知道他们已经不在需要感知到何时不再需要被监听。我们在View视图层提供了若干个协程构建器。

• Activity.lifecycleScope.launch : 启动协程，并且在本 Activity 销毁时结束协程。


• Fragment.lifecycleScope.launch : 启动协程，并且在本 Fragment 销毁时结束协程。


• Fragment.viewLifecycleOwner.lifecycleScope.launch : 启动协程，并且在本 Fragment 中的视图生命周期结束时取消协程。


• launchWhenX :启动协程，它会在 lifecycleOwner 进入 X 状态之前一直等待，又在离开 X 状态时挂起协程。

通过上面官方的这个图，我们可以看出当APP进入后台时，如果APP还在后台收集数据更新可能引发应用崩溃和资源的浪费。

repeatOnLifecycle

因此google官方提供了新的API接口repeatOnLifecycle能够在某个特定的状态满足时启动协程，并且在生命周期所有者退出该状态时停止协程。

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

使用repeatOnLifecycle和StateFlow能够帮助我们应用根据应用生命周期优化性能和设备资源。

通过repeatOnLifecycle和StateFlow能够帮助我们更好管理数据流。最后以官方的一句话结束本文。

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

距离上一篇自定义view已经过去了一年多了，这次主要给大家介绍的是可滑动的星星评价，虽然Google官方也提供了 RatingBar 但是没办法满足我的需要只能自己定义一个了，废话不多说先上图：

这个选中以及默认的心型都是UI提供的图片，上代码：

1.自定义view的代码

import android.content.Context

import android.graphics.*

import android.graphics.drawable.Drawable

import android.util.AttributeSet

import android.view.MotionEvent

import android.view.View

import android.view.ViewConfiguration

import cn.neoclub.uki.R

import kotlin.math.abs

import kotlin.math.ceil

import kotlin.math.roundToInt



/**

 * Author: Mr.Dong

 * Date: 2022/2/15 4:31 下午

 * Description: 点击心心评价

 */

class HeartRatingBar : View {

    private var starDistance = 0 //星星间距

    private var starCount = 5 //星星个数

    private var starSize = 0 //星星高度大小，星星一般正方形，宽度等于高度

    private var starMark = 0 //评分星星

    private var starFillBitmap: Bitmap? = null //亮星星

    private var starEmptyDrawable : Drawable? = null//暗星星

    private var onStarChangeListener : OnStarChangeListener? = null//监听星星变化接口

            

    private var paint : Paint? = null//绘制星星画笔

    //是否显示整数的星星       

    private var integerMark = false

    //初始化可以被定义为滑动的距离（超过这个距离就是滑动，否则就是点击事件）

    private var scaledTouchSlop:Int=0



    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {

        init(context, attrs)

    }



    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(

        context,

        attrs,

        defStyleAttr

    ) {

        init(context, attrs)

    }



    /**

     * 初始化UI组件

     *

     * @param context

     * @param attrs

     */

    private fun init(context: Context, attrs: AttributeSet?) {

        //获取滑动的有效距离

        scaledTouchSlop=ViewConfiguration.get(context).scaledTouchSlop

        isClickable = true

        //获取各种属性的值

        val mTypedArray = context.obtainStyledAttributes(attrs, R.styleable.HeartRatingBar)

        starDistance = mTypedArray.getDimension(R.styleable.HeartRatingBar_starDistance, 0f).toInt()

        starSize = mTypedArray.getDimension(R.styleable.HeartRatingBar_starSize, 20f).toInt()

        starCount = mTypedArray.getInteger(R.styleable.HeartRatingBar_starCount, 5)

        starEmptyDrawable = mTypedArray.getDrawable(R.styleable.HeartRatingBar_starEmpty)

        starFillBitmap = drawableToBitmap(mTypedArray.getDrawable(R.styleable.HeartRatingBar_starFill))

        mTypedArray.recycle()

        paint = Paint()

        //设置抗锯齿

        paint?.isAntiAlias = true

        //设置渲染器

        paint?.shader = BitmapShader(starFillBitmap!!, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)

    }



    /**

     * 设置是否需要整数评分

     * @param integerMark

     */

    fun setIntegerMark(integerMark: Boolean) {

        this.integerMark = integerMark

    }



    /**

     * 设置显示的星星的分数

     *

     * @param mark

     */

    private fun setStarMark(mark: Int) {

        starMark = if (integerMark) {

            //ceil函数 去除小数点后面的 返回 double 类型，返回值大于或等于给定的参数 例Math.ceil(100.675) = 101.0

            ceil(mark.toDouble()).toInt()

        } else {

            (mark * 10).toFloat().roundToInt() * 1 / 10

        }

        if (onStarChangeListener != null) {

            onStarChangeListener?.onStarChange(starMark) //调用监听接口

        }

        invalidate()

    }



    /**

     * 获取显示星星的数目

     *

     * @return starMark

     */

    fun getStarMark(): Int {

        return starMark

    }



    /**

     * 定义星星点击的监听接口

     */

    interface OnStarChangeListener {

        fun onStarChange(mark: Int)

    }



    /**

     * 设置监听

     * @param onStarChangeListener

     */

    fun setOnStarChangeListener(onStarChangeListener: OnStarChangeListener?) {

        this.onStarChangeListener = onStarChangeListener

    }



    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {

        super.onMeasure(widthMeasureSpec, heightMeasureSpec)

        //设置view的宽度和高度 继承view必须重写此方法

        setMeasuredDimension(starSize * starCount + starDistance * (starCount - 1), starSize)

    }



    override fun onDraw(canvas: Canvas) {

        super.onDraw(canvas)

        if (starFillBitmap == null || starEmptyDrawable == null) {

            return

        }

        //绘制空的星星

        for (i in 0 until starCount) {

            //设置starEmptyDrawable绘制的长方形区域，当调用draw()方法后就可以直接绘制

            starEmptyDrawable?.setBounds(

                (starDistance + starSize) * i,

                0,

                (starDistance + starSize) * i + starSize,

                starSize

            )

            starEmptyDrawable?.draw(canvas)

        }

        if (starMark > 1) {

            //绘制了第一个star

            canvas.drawRect(0f, 0f, starSize.toFloat(), starSize.toFloat(), paint!!)

            if (starMark - starMark == 0) { //第一步必走这里 

                //绘制亮星星

                for (i in 1 until starMark) {

                    //每次位移start的宽度+间距

                    canvas.translate((starDistance + starSize).toFloat(), 0f)

                    canvas.drawRect(0f, 0f, starSize.toFloat(), starSize.toFloat(), paint!!)

                }

            } else { //非整形的star绘制走这里

                for (i in 1 until starMark - 1) {

                    canvas.translate((starDistance + starSize).toFloat(), 0f)

                    canvas.drawRect(0f, 0f, starSize.toFloat(), starSize.toFloat(), paint!!)

                }

                canvas.translate((starDistance + starSize).toFloat(), 0f)

                canvas.drawRect(

                    0f,

                    0f,

                    starSize * (((starMark - starMark) * 10).toFloat().roundToInt() * 1.0f / 10),

                    starSize.toFloat(),

                    paint!!

                )

            }

        } else {

            //startMark=0 啥都没绘制

            canvas.drawRect(0f, 0f, (starSize * starMark).toFloat(), starSize.toFloat(), paint!!)

        }

    }



    //记录一下上次down的x的位置

    private var downX:Int=0



    override fun onTouchEvent(event: MotionEvent): Boolean {

        var x = event.x.toInt()

        if (x < 0) x = 0

        if (x > measuredWidth) x = measuredWidth

        when (event.action) {

            MotionEvent.ACTION_DOWN -> {

                downX=x

                //对于除数不能为0的限制

                if(starCount==0||(measuredWidth * 1 / starCount)==0){

                    return false

                }

                val count=x * 1 / (measuredWidth * 1 / starCount)

                setStarMark(count+1)

            }

            MotionEvent.ACTION_MOVE -> {

                //当滑动距离的绝对值小于官方定义的有效滑动距离则不走move当做down处理

                if(abs(event.x-downX)<scaledTouchSlop){

                    return false

                }

                if(starCount==0||(measuredWidth * 1 / starCount)==0){

                    return false

                }

                setStarMark(x * 1 / (measuredWidth * 1 / starCount))

            }

            MotionEvent.ACTION_UP -> {}

        }

        invalidate()

        return super.onTouchEvent(event)

    }



    /**

     * drawable转bitmap

     *

     * @param drawable

     * @return

     */

    private fun drawableToBitmap(drawable: Drawable?): Bitmap? {

        if (drawable == null) return null

        val bitmap = Bitmap.createBitmap(starSize, starSize, Bitmap.Config.ARGB_8888)

        val canvas = Canvas(bitmap)

        drawable.setBounds(0, 0, starSize, starSize)

        drawable.draw(canvas)

        return bitmap

    }

}

2.自定义View的使用

    <cn.neoclub.uki.message.widget.HeartRatingBar

        android:id="@+id/rb_rating_bar"

        android:layout_width="match_parent"

        android:layout_height="40dp"

        app:starCount="5"

        app:starDistance="7dp"

        app:starEmpty="@drawable/icon_heart_rating_default"

        app:starFill="@drawable/icon_heart_rating_select"

        app:starSize="40dp" />

3.attrs.xml文件中的属性

 <declare-styleable name="HeartRatingBar">

        <attr name="starDistance" format="dimension"/>

        <attr name="starSize" format="dimension"/>

        <attr name="starCount" format="integer"/>

        <attr name="starEmpty" format="reference"/>

        <attr name="starFill" format="reference"/>

    </declare-styleable>

4.送你两张图，怕你运行不起来

1.icon_heart_rating_select.png

2.icon_heart_rating_default.png

是不是感觉这边少了个icon,对了就是少一张😄（其实是有图的）

Android系统没有提供默认的截屏事件监听方式，需要开发者自己想办法实现。查看了网上推荐的实现方式，主要是通过内容观察者（ContentObserver）监听媒体数据库的变化，根据内容名称（路径）中是否包含关键字，判断是否为截屏事件。
关键字：

    private static final String[] KEYWORDS = {

            "screenshot", "screen_shot", "screen-shot", "screen shot",

            "screencapture", "screen_capture", "screen-capture", "screen capture",

            "screencap", "screen_cap", "screen-cap", "screen cap", "snap", "截屏"

    };

第一步：对ContentResolver添加内、外存储变化监听；

mInternalObserver = new MediaContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI, MainHandler.get());

mExternalObserver = new MediaContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, MainHandler.get());

mResolver = AppContext.get().getContentResolver();

// 添加监听

mResolver.registerContentObserver(

        MediaStore.Images.Media.INTERNAL_CONTENT_URI,

        false,

        mInternalObserver

);

mResolver.registerContentObserver(

        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,

        false,

        mExternalObserver

);

第二步：当内容观察者（ContentObserver）监听到变化时，会调用onChange方法，此时，我们使用ContentResolver去查询最新的一条数据；
需要注意的是，查询外部存储一定要有读取存储权限（Manifest.permission.READ_EXTERNAL_STORAGE），否则会在查询的时候报错；
第三步：判断查到到数据是否为截图文件；在这里有一个很难处理到问题，在华为荣耀手机上，截图预览图生成的同时就会通知存储内容变化，而小米则是在截图预览图消失后通知变化；
解决方案：

1. 判断当前文件路径是否与上次有效路径相同，相同执行步骤2，不相同则执行步骤3；


2. 当前路径与上次路径相同，取消回调请求，重新延迟发送回调请求；


3. 当前路径与上次路径不同，判断内容的生成时间(MediaStore.Images.ImageColumns.DATE_TAKEN)和添加时间(MediaStore.Images.ImageColumns.DATE_ADDED)是否相同，相同执行步骤4，不相同则执行步骤5；


4. 内容的生成时间和添加时间相同，认为此时为生成长截图，立刻取消回调请求，执行空回调（用于取消弹窗等操作）；


5. 内容的生成时间和添加时间不同，检查是否含有关键字，若判定为截图，更新上次有效路径，取消回调请求，重新延迟发送回调请求；

 // 获取各列的索引

            int dataIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);

            int dateTakenIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_TAKEN);

            int dateAddIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_ADDED);

            // 获取行数据

            final String data = cursor.getString(dataIndex);

            long dateTaken = cursor.getLong(dateTakenIndex);

            long dateAdded = cursor.getLong(dateAddIndex);

            if (data.length() > 0) {

                if (TextUtils.equals(lastData, data)) {

                    MainHandler.get().removeCallbacks(shotCallBack);

                    MainHandler.get().postDelayed(shotCallBack, 500);

                } else if (dateTaken == 0 || dateTaken == dateAdded * 1000) {

                    MainHandler.get().removeCallbacks(shotCallBack);

                    if (listener != null) {

                        listener.onShot(null);

                    }

                } else if (checkScreenShot(data)) {

                    MainHandler.get().removeCallbacks(shotCallBack);

                    lastData = data;

                    MainHandler.get().postDelayed(shotCallBack, 500);

                }

            }

完整代码：（其中AppContext为全局Application单例，MainHandler为全局主线程Handler单例）

public class ScreenShotHelper {

    private static final String[] KEYWORDS = {

            "screenshot", "screen_shot", "screen-shot", "screen shot",

            "screencapture", "screen_capture", "screen-capture", "screen capture",

            "screencap", "screen_cap", "screen-cap", "screen cap", "snap", "截屏"

    };



    /**

     * 读取媒体数据库时需要读取的列

     */

    private static final String[] MEDIA_PROJECTIONS = {

            MediaStore.Images.ImageColumns.DATA,

            MediaStore.Images.ImageColumns.DATE_TAKEN,

            MediaStore.Images.ImageColumns.DATE_ADDED,

    };

    /**

     * 内部存储器内容观察者

     */

    private ContentObserver mInternalObserver;

    /**

     * 外部存储器内容观察者

     */

    private ContentObserver mExternalObserver;

    private ContentResolver mResolver;

    private OnScreenShotListener listener;

    private String lastData;

    private Runnable shotCallBack = new Runnable() {

        @Override

        public void run() {

            if (listener != null) {

                final String path = lastData;

                if (path != null && path.length() > 0) {

                    listener.onShot(path);

                }

            }

        }

    };



    private ScreenShotHelper() {

        // 初始化

        mInternalObserver = new MediaContentObserver(MediaStore.Images.Media.INTERNAL_CONTENT_URI, null);

        mExternalObserver = new MediaContentObserver(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, null);



        mResolver = AppContext.get().getContentResolver();

        // 添加监听

        mResolver.registerContentObserver(

                MediaStore.Images.Media.INTERNAL_CONTENT_URI,

                false,

                mInternalObserver

        );

        mResolver.registerContentObserver(

                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,

                false,

                mExternalObserver

        );

    }



    private static class Instance {

        static ScreenShotHelper mInstance = new ScreenShotHelper();

    }



    public static ScreenShotHelper get() {

        return Instance.mInstance;

    }



    public void setScreenShotListener(OnScreenShotListener listener) {

        this.listener = listener;

    }



    public void removeScreenShotListener(OnScreenShotListener listener) {

        if (this.listener == listener) {

            synchronized (ScreenShotHelper.class) {

                if (this.listener == listener) {

                    this.listener = null;

                }

            }

        }

    }



    public void stopListener() {

        mResolver.unregisterContentObserver(mInternalObserver);

        mResolver.unregisterContentObserver(mExternalObserver);

    }



    private void handleMediaContentChange(Uri contentUri) {

        Cursor cursor = null;

        try {

            // 数据改变时查询数据库中最后加入的一条数据

            cursor = mResolver.query(

                    contentUri,

                    MEDIA_PROJECTIONS,

                    null,

                    null,

                    MediaStore.Images.ImageColumns.DATE_ADDED + " desc limit 1"

            );

            if (cursor == null) {

                return;

            }

            if (!cursor.moveToFirst()) {

                return;

            }

            // 获取各列的索引

            int dataIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);

            int dateTakenIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_TAKEN);

            int dateAddIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATE_ADDED);

            // 获取行数据

            final String data = cursor.getString(dataIndex);

            long dateTaken = cursor.getLong(dateTakenIndex);

            long dateAdded = cursor.getLong(dateAddIndex);

            if (data.length() > 0) {

                if (TextUtils.equals(lastData, data)) {

                    //更改资源文件名也会触发，并且传递过来的是之前的截屏文件，所以只对分钟以内的有效

                    if (System.currentTimeMillis() - dateTaken < 3 * 3600) {

                        MainHandler.get().removeCallbacks(shotCallBack);

                        MainHandler.get().postDelayed(shotCallBack, 500);

                    }

                } else if (dateTaken == 0 || dateTaken == dateAdded * 1000) {

                    MainHandler.get().removeCallbacks(shotCallBack);

                    if (listener != null) {

                        listener.onShot(null);

                    }

                } else if (checkScreenShot(data)) {

                    MainHandler.get().removeCallbacks(shotCallBack);

                    lastData = data;

                    MainHandler.get().postDelayed(shotCallBack, 500);

                }

            }

        } catch (Exception e) {

            //

        } finally {

            if (cursor != null && !cursor.isClosed()) {

                cursor.close();

            }

        }

    }



    /**

     * 根据包含关键字判断是否是截屏

     */

    private boolean checkScreenShot(String data) {

        if (data == null || data.length() < 2) {

            return false;

        }

        data = data.toLowerCase();

        for (String keyWork : KEYWORDS) {

            if (data.contains(keyWork)) {

                return true;

            }

        }

        return false;

    }



    private class MediaContentObserver extends ContentObserver {

        private Uri mContentUri;



        MediaContentObserver(Uri contentUri, Handler handler) {

            super(handler);

            mContentUri = contentUri;

        }



        @Override

        public void onChange(boolean selfChange) {

            super.onChange(selfChange);

            if (listener != null) {

                handleMediaContentChange(mContentUri);

            }

        }

    }



    public interface OnScreenShotListener {

        void onShot(@Nullable String data);

    }



}

总结： 

1.必须要有读取内存的权限； 

2.内容生成时间为毫秒，内容添加时间为秒，比较时需要注意换算； 

3.当内容生成时间等于内容添加时间时，应当取消之前的截屏监听操作（尤其是会遮挡页面视图的部分）；