# 第六十周ARTS总结

# Algorithm

Subsets (opens new window)

2ms | 19.42% Run time
39.9MB | 35.66% Memory

public List<List<Integer>> subsets(int[] nums) {
    // 首先里边的每个条目存的都是nums的索引值(利用索引值的目的是为了方便定位当前条目里的是nums中哪几个数)
    List<List<Integer>> finalAns = new ArrayList<>();

    // 存放个数为i个的子集集合
    List<List<Integer>> ans = new ArrayList<>();

    // 中间变量
    List<List<Integer>> temp = new ArrayList<>();

    // 找到容量为i个的所有子集
    for (int i = 1; i <= nums.length; i++) {
        temp.clear();

        // 找到容量为1的所有子集
        if (i == 1) {
            for (int k = 0; k < nums.length; k++) {
                List<Integer> item = new ArrayList<>();
                item.add(k);
                ans.add(item);
            }

            finalAns.addAll(ans);
        } else {
            // 找到容量大于1的所有子集
            for (int k = 0; k < ans.size(); k++) {
                List<Integer> item = ans.get(k);
                int startIndex = item.get(item.size() - 1) + 1;

                for (int j = startIndex; j < nums.length; j++) {
                    List<Integer> newItem = new ArrayList<>(item);
                    newItem.add(j);

                    temp.add(newItem);
                }
            }

            ans.clear();
            ans.addAll(temp);

            finalAns.addAll(ans);
        }
    }

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

    // 将finalAns里的所有索引值变为真实值
    for (List<Integer> item : finalAns) {
        itemTemp.clear();
        for (int index : item) {
            itemTemp.add(nums[index]);
        }

        item.clear();
        item.addAll(itemTemp);
    }

    // 加入空集
    finalAns.add(new ArrayList<>());

    return finalAns;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

# Review

Say no to BaseActivity and BaseFragment (opens new window)

# Tip

RxJava使用详解
- 观察者模式：被观察者、观察者、订阅。被观察者会有状态的变化，观察者会定义一系列事件。当被观察者订阅（持有）了观察者，然后当被观察者的状态变化了会告诉观察者，让观察者调用相应的事件
- 基本实现方式：
  1. 创建Observer
  2. 创建Observable
  3. 通过subscribe将Observer与Observable结合起来
- 线程控制：可通过Schedulers以及AndroidSchedulers来定义线程运行情况
- 变换：
  - map()：一对一的变换
  - flatMap()：一对多的变化，被转化为Observable对象
  - throttleFirst()：在事件触发的一定间隔内丢弃新的事件，常用于去抖动过滤（重复点击）
  - compose()：对Observable整体的变换
- 可以通过多次调用observeOn来不断的切换观察者所在的线程
- 默认情况下，doOnSubscribe()执行在subscribe()所在线程；而如果在doOnSubscribe()之后有subscribeOn()的话，它将执行在离它最近的subscribeOn()所指定线程
Observable的方法们
- create
- map
- zip
- concat
- flatMap：不保证顺序
- concatMap：保证顺序
- distinct：去重
- filter：过滤
- buffer
- timer
- interval
- doOnNext
- skip
- take
- just
- debounce：去除发送频率过快的事件
- defer
- last
- merge：注意与concat的区别
- reduce
- scan：注意与reduce的区别
- window
编译与解释的区别
- 编译：将源程序整段的翻译成源程序，然后执行
- 解释：将高级语言编写的源程序翻译成机器指令，翻译一条执行一条
Lifecycle的使用：
1. 定义一个类，并实现LifecycleObserver接口
2. 在该类中定义生命周期相关的方法，并用注解@OnLifecycleEvent(Lifecycle.Event.XXX)来确定运行在哪个生命周期
3. 在活动中注册该类（观察者）：getLifecycle().addObserver(new ALifecycleObserver());
可通过继承ReplacementSpan的方式来自定义SpannableStringBuilder的span

暂无内容

← 第五十九周ARTS总结第六十一周ARTS总结 →

# 第六十周ARTS总结

# Algorithm

# Review

# Tip

# Share