发表于 | 分类于

今日的 LeetCode 每日一题是 25. K 个一组翻转链表
看完题解之后关闭题解自己写的，算我通过了吧（算法这种东西重在积累经验，是不是自己写的问题不大）。
有时间我再整理吧。主要是突然想介绍一下我自己对 递归 的理解。

本篇所有代码语言都为 C++；

递归

其实递归说简单也挺简单的。很好理解，就是套娃，自己调用自己。
递归有几个部分组成：

  • 出口条件
  • 递
  • 归

这里 出口条件 是一定要有的，也是专业术语。否则递归将会陷入死循环。
而 递 和 归 是我自己加入的，不知道有没有这种专业术语。

具体如下：

1
2
3
4
5
6
7
8
9
10
11
void recursion(){
    if( /*出口条件*/ ){
        return; // 出口，如果有返回值就为出口值；
    }

    /* 递 操作*/

    recursion(); //出口条件之后到最后一个递归调用之间的操作都为 递 操作

    /* 归 操作*/
}

形象一点，想象成一条线向下穿过一个一个方块，达到 出口条件 后再旋转一下从下到上回到第一个，递 操作 就是向下时候要做的操作，归 操作 就是向上回去的时候要做的操作。

其中，按照 归 操作 的有无，递归可以分为 尾递归 和 非尾递归。

尾递归

尾递归就是这个方法最后一行调用自己，即没有 归 操作 。

这里以斐波那契数列举例子：

斐波那契数列具有以下特点：

  • 前两个数字为 1
  • 后面所有数字为前面两个数字之和

我们可以写一个方法来输出该数列的第 n 个数（ n 从 0 开始 ）；

1
2
3
4
5
6
7
8
9
/**
 * 斐波那契递归
 */ 
int fun(int n){
    if(n <= 1){
        return 1;
    }
    return fun(n-2) + fun(n-1);
}

这就是一个典型的尾递归，所有的尾递归都可以使用迭代来优化，比如对于以上方法使用迭代来实现就是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 斐波那契迭代
 */ 
int fun(int n){
    int dp[n];
    for(int i = 0 ; i < n ; i ++){
        if(i <= 1){
            dp[i] = 1;
        }else{
            dp[i] = dp[i-2] + dp[i-1];
        }
    }
    return dp[n];
}

开一个数组来保存之前的斐波那契数。
再多 BB 一点，如果你写 动态规划 的目标函数确定为一元的时候，经常也是这种迭代的形势，dp 也是 动态规划 的简称，约定俗成的一种写法。

假设法

对于 非尾递归 的话就要详细说一下了，我们在打题的时候，遇到的往往也是 非尾递归 。
关于 非尾递归，很多人都不清楚递归要如何入手，这里我以一道题为例子讲一下我写非尾递归时候的方法：

  • 题目： 206. 反转链表
  • 题目要求递归和迭代两种实现方式，这里我只介绍递归。

以下是我的思考过程：

  1. 明确要用递归。
  2. 明确递归方法的效果：将参数结点之后所有链表都反转并返回新的头节点。
  3. 明确递归方向，即递归方法中调用下一次递归时候传入的参数为当前链表的下一个。

一般明确这三点之后我们就可以开始写了：

方法模型：

1
2
3
ListNode* reverseList(ListNode* head) {
        
}

出口条件

出口条件也可以分为两个思考过程：

出口条件的思考主要要考虑之前我们明确的这个递归方法要实现的效果，即输入什么，输出什么。

  1. 外部调用时候的出口条件：比如打题的时候系统直接第一次就给你传入一个 null 。当然有些题目中 0 啊之类的，要具体分析。本题中这部分只需要考虑它直接给你 null ， 那么我们直接返回一个 null 给它。
  2. 递归过程的出口条件：这里已经假设它给的结点不可能为 null ，则本题中递归过程的出口条件也很容易想到，即结点该结点恰好就是最后一个，则根据之前讲的方法的效果，要返回这一个结点反转后的新头结点，即自己。
1
2
3
if(!head || !(head->next)){
    return head;
}

假设成立

我们可以先把递归调用写出来并用一个变量承接返回值。

1
auto *newHead = reverseList(head->next);

考虑一下这个 newHead 是什么，回到我们刚刚讲的明确这个方法的效果， reverseList(node) 方法的效果是将 node 及之后的整条链表反转然后返回新的表头。

虽然我们还没写好这个方法，但是在方法里面，我们可以假设我们已经写完了，它是正常工作的，所以这里的 newHead 是除了第一个结点外后面所有结点都反转好的头节点。

我们的目的是要反转整个链表，然后现在除了第一个之后都反转好了，那么我们接下来只需将第一个接到后面所有反转好的链表后面，然后把这一个下一个置空就可以了。

1
2
3
auto *newHead = reverseList(head->next);
head->next = nullptr; //将第一个结点后一个置空
last->next = head; //将第一个节点接在最后面

写到这里，我们发现 last 还是为止的。想一下我们要怎么拿到 last ，其实也不难想到，我们递归之后后面的所有链表都反转了，所以最初的第一个链表下一个反转后也就是最后一个，所以我们在 递操作 的时候就保存一下这个结点。

1
2
3
4
auto *last = head->next; //先保存递归反转的第一个即反转后最后一个
auto *newHead = reverseList(head->next);
head->next = nullptr; //将第一个结点后一个置空
last->next = head; //将第一个节点接在最后面

大功告成，最后返回反转后的结点头，即返回的 newHead

1
2
3
4
5
auto *last = head->next; //先保存递归反转的第一个即反转后最后一个
auto *newHead = reverseList(head->next);
head->next = nullptr; //将第一个结点后一个置空
last->next = head; //将第一个节点接在最后面
return newHead;

完整代码

1
2
3
4
5
6
7
8
9
10
ListNode* reverseList(ListNode* head) {
    if(!head || !(head->next)){
        return head;
    }
    auto *last = head->next; //先保存递归反转的第一个即反转后最后一个
    auto *newHead = reverseList(head->next);
    head->next = nullptr; //将第一个结点后一个置空
    last->next = head; //将第一个节点接在最后面
    return newHead;
}

大功告成。

动图说明：

总结

整个过程中，核心就是假设法，假设我们已经写好了这个方法并且可以起作用，然后再补充 递 操作 和 归 操作 。

有很多递归操作都是这样的，比如 归并排序 的写法，如果你能用假设法，那么你很快就能理解它为什么要怎么写，为什么能这样写。

其次，假设法的思想也可以用于 动态规划 ，只不过 动态规划 抽象出了了 递推公式 这种东西，比较接近解数学题把，但是假设法写递归更偏向于解决实际情景。

身为 一鸽子 ，动态规划 的 Part 2 有空再来更新。

发表于 | 分类于

今天的力扣每日一题，因为位运算是我的短板之一，这题我没解出来，最终看了题解，不得不说妙啊，记录一下。

题目描述

  • 136. 只出现一次的数字

  • 给定一个 非空 整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

  • 难度：简单

说明

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1

1
2
输入: [2,2,1]
输出: 1

示例 2

1
2
输入: [4,1,2,1,2]
输出: 4

题解

说实话，刚看这道题的时候，我就想到几种方法：

  • 两重循环，外层 $i = 0 到 n$ ，内层 $j = i 到 n$ 。循环 $(1+n)*n/2$ 次，时间复杂度为 $o(n^2)$ ，怎么说呢，显然不是线性复杂度。
  • 开多一个 List 来存每个数字出现的次数，好吧，不能使用额外空间

反正我是没想出来，看看官方的题解：

首先我们要用到位运算 异或 ，也就是 ⊕ ，它具有以下三个性质：

  1. 任何数与它本身异或结果为 0，即 $a \oplus a = 0$；
  2. 任何数与 0 异或结果为它本身，即 $0 \oplus a = a$；
  3. 异或运算满足交换律和结合律，即 $a \oplus b \oplus a = b \oplus a \oplus a = b \oplus (a \oplus a) = b \oplus 0 = b$;

假如我们对数组中所有数做异或运算，因为满足交换律，我们总可以把两两相同的数字交换到一起，并通过结合律运算为 0，最终只剩下 0 与那个唯一的数字做异或运算，剩下那个唯一的数。

woc 就这么简单，看来位运算还是学的不太好，有必要花点时间研究一下了。

  • 语言：C++
1
2
3
4
5
6
7
8
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ret = 0;
        for (auto e: nums) ret ^= e;
        return ret;
    }
};

结果

我感觉这个用时有点不正常，不过看了下更快速的提交代码，都是一样的啊，估计是电脑问题吧。

发表于 | 分类于

最近在肝工作室的最终考核，不过感觉可以趁机水好多篇博客？？
这次是通过自定义 View 来实现循环的 Banner 。
写之前在网上看过很多教程，大都是一个很大的 ViewPager ，我总是感觉那样不好，所以我就自己写了一个。

此外，带有 实战 标签的文章大都不涉及复杂的原理过程，重在贴代码。可以自行研究。

最终效果

图片加载器

首先把图片加载抽象出来，因为 Banner 里图片可以是从文件拿，可以是从网上拿，也可以在 Drawable 拿。为了适配，我把图片加载抽象了出来。

1
2
3
4
5
6
7
8
9
10
11
/**
 * Created by HeYanLe on 2020/5/7 0007.
 * https://github.com/heyanLE
 */
public interface ImageInfo {

    ImageInfo prepare();

    void covert(ImageView imageView);

}

这就是一个图片的加载接口，调用 prepare 加载图片，调用 covert(ImageView) 把图片渲染到 ImageView 里。

因为我图片是拿 Drawable 里面的，我就直接写上 Drawable 加载器的实现了，其他网络图片啥的可以参考。

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
/**
 * Created by HeYanLe on 2020/5/7 0007.
 * https://github.com/heyanLE
 */
public class DrawableInfo implements ImageInfo {

    private Drawable drawable;
    private int resId;
    private Context context;

    @Override
    public DrawableInfo prepare() {
        drawable = context.getDrawable(resId);
        return this;
    }

    @Override
    public void covert(ImageView imageView) {
        imageView.setImageDrawable(drawable);
    }

    public static DrawableInfo of(int resId , Context context){
        DrawableInfo info = new DrawableInfo();
        info.resId = resId;
        info.context = context;
        return info;
    }
}

of 是构造方法，参数为 Drawable 的 id ,其他的应该也很好理解。

图片加载器环

循环 Banner ，我们需要一个对象来装所有的图片加载器，并且这些图片加载器要形成一个环，其实也不难，主要是指针的处理，直接上示意图和代码把 （示意图以四个图片加载器为例）。

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
63
64
65
66
67
68
69
70
71
72
73
 /**
 * Created by HeYanLe on 2020/5/7 0007.
 * https://github.com/heyanLE
 */
public class ImageRing {

    private List<ImageInfo> images = new ArrayList<>();
    private int curImageIndex = 0;

    public int getImagesCount(){
        return images.size();
    }

    public void addImageInfo(ImageInfo info){
        images.add(info);
    }

    public void scrollNext(){
        if (images.isEmpty()){
            return ;
        }
        if (curImageIndex == images.size()-1){
            curImageIndex = 0;
        }else{
            curImageIndex++;
        }

    }

    public void scrollPre(){
        if (images.isEmpty()){
            return ;
        }
        if (curImageIndex == 0){
            curImageIndex = images.size()-1;
        }else{
            curImageIndex--;
        }

    }

    public ImageInfo getNextImage(){
        if (images.isEmpty()){
            return null;
        }
        if (curImageIndex == images.size()-1){
            return images.get(0);
        }
        return images.get(curImageIndex+1);
    }

    public ImageInfo getPreImage(){
        if (images.isEmpty()){
            return null;
        }
        if (curImageIndex == 0){
            return images.get(images.size()-1);
        }
        return images.get(curImageIndex-1);
    }

    public ImageInfo getCurImage(){
        return images.get(curImageIndex);
    }

    public int getCurImageIndex() {
        return curImageIndex;
    }

    public void setCurImage(int curImage) {
        this.curImageIndex = curImage;
    }
}

这里开始是核心，其实主要思路就是一个自定义个的 ViewGroup ，里面只有三个 ImageView，没错，只有三个。

嘛，不太会做动图，这里借用一下 小灰灰 的图，

平常时候，我们将中间一张设置为当前显示的图片，第一张和第三张分别是上一张和下一张（这里可以直接使用我上面的图片加载环里获取上一个和获取下一个）。

滑动时候，图片跟着用户手指左右拖动，因为 Banner 一般宽度是整个 View 的宽度，所以不可能会拖动出 View。

松手时候，根据现在的位置，先滑动到上一张或者是下一张，然后滑动到之后在一瞬间回到第二个 ImageView 然后渲染新的图片。

上代码

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
 /**
 * banner 轮播 View
 * 循环
 * Created by HeYanLe on 2020/5/7 0007.
 * https://github.com/heyanLE
 */
public class BannerView extends ViewGroup {

    private boolean isAnimator = false;

    private Handler handler;

    private ImageRing imageRing;
    private ImageView ivF;
    private ImageView ivS;
    private ImageView ivT;

    private DotLinear dotLinear;

    public BannerView(Context context) {
        super(context);
    }

    public BannerView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public BannerView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();

    }

    public void setImageRing(ImageRing imageRing){
        this.imageRing = imageRing;
        setVisibility(INVISIBLE);
        drawImage();
        scrollCur();
        setVisibility(VISIBLE);
        if (dotLinear != null)
            dotLinear.setDotCount(imageRing.getImagesCount());
    }

    public void bindDotLinear(DotLinear dotLinear) {
        this.dotLinear = dotLinear;
        if (imageRing != null){
            dotLinear.setDotCount(imageRing.getImagesCount());
            dotLinear.setCurDot(imageRing.getCurImageIndex());
        }
    }

    public void init(){

        handler = new Handler();

        ivF = new ImageView(getContext());
        ivS = new ImageView(getContext());
        ivT = new ImageView(getContext());

        addView(ivF);
        addView(ivS);
        addView(ivT);

        drawImage();
    }

    public void drawImage(){
        if (imageRing == null){
            return;
        }

        if (getChildCount() < 3){
            init();
        }

        imageRing.getPreImage().covert(ivF);
        imageRing.getCurImage().covert(ivS);
        imageRing.getNextImage().covert(ivT);
        scrollTo(ivF.getMeasuredWidth() ,0);
        if (dotLinear != null)
            dotLinear.setCurDot(imageRing.getCurImageIndex());
        //scrollCur();
    }

    public void scrollNext(){

        if (isAnimator){
            return;
        }

        ValueAnimator animator = ValueAnimator.ofInt(getScrollX() ,ivF.getMeasuredWidth() + ivS.getMeasuredWidth());
        animator.setDuration(200);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                Integer value = (Integer) animation.getAnimatedValue();
                scrollTo(value ,0);
            }
        });
        animator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
                isAnimator = true;
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                imageRing.scrollNext();
                drawImage();
                isAnimator = false;
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
        animator.start();

    }

    public  void scrollPre(){
        if (isAnimator){
            return;
        }

        ValueAnimator animator = ValueAnimator.ofInt(getScrollX() ,0);
        animator.setDuration(200);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                Integer value = (Integer) animation.getAnimatedValue();
                scrollTo(value ,0);
            }
        });
        animator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
                isAnimator = true;
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                imageRing.scrollPre();
                drawImage();
                isAnimator = false;
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
        animator.start();
    }

    public  void scrollCur(){
        if (isAnimator){
            return;
        }

        ValueAnimator animator = ValueAnimator.ofInt(getScrollX() ,ivF.getMeasuredWidth());
        animator.setDuration(200);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                Integer value = (Integer) animation.getAnimatedValue();
                scrollTo(value ,0);
            }
        });
        animator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {
                isAnimator = true;
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                drawImage();
                isAnimator = false;
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
        animator.start();
    }

    final Runnable runnable = new Runnable() {
        @Override
        public void run() {
            scrollNext();
            handler.postDelayed(runnable ,4000);
        }
    };

    public void startPoll(){
        handler.post(runnable);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int cWidth = 0;
        int cHeight = 0;

        cWidth = getMeasuredWidth();
        cHeight = getMeasuredHeight();

        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            getChildAt(i).layout(-cWidth, 0, 0, 0);
        }

        if (imageRing != null) {
            if (ivF != null) {
                int cl1 = 0, ct1 = 0, cr1 = 0, cb1 = 0;
                cr1 = cWidth;
                cb1 = cHeight;
                ivF.layout(cl1, ct1, cr1, cb1);
            }
            if(ivS != null){
                ivS.layout(cWidth, 0, 2*cWidth, cHeight);
            }
            if(ivT != null){
                ivT.layout(2*cWidth, 0, 3*cWidth, cHeight);
            }
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        /*
         * 获得此ViewGroup上级容器为其推荐的宽和高，以及计算模式
         */

        int sizeWidth = MeasureSpec.getSize(widthMeasureSpec);
        int sizeHeight = MeasureSpec.getSize(heightMeasureSpec);

        // 计算出所有的childView的宽和高
        measureChildren(MeasureSpec.makeMeasureSpec(sizeWidth, MeasureSpec.AT_MOST),
                MeasureSpec.makeMeasureSpec(sizeHeight, MeasureSpec.AT_MOST));

        /*
         * 直接设置为父容器计算的值
         */
        setMeasuredDimension(sizeWidth, sizeHeight);
    }


    private float downX;
    private float offset;
    private boolean isMove = false;

    @SuppressLint("ClickableViewAccessibility")
    @Override
    public boolean onTouchEvent(MotionEvent event) {

        int x = (int) event.getX();

        if (isAnimator) {
            return true;
        }

        switch (event.getAction()) {

            case MotionEvent.ACTION_DOWN:
                downX = event.getX();
                break;
            case MotionEvent.ACTION_MOVE:
                isMove = true;
                offset = downX - event.getX();
                scrollTo((int) (ivF.getMeasuredWidth() + offset),0);
                break;

            case MotionEvent.ACTION_UP:
                if (isMove){
                    if (offset >= 400){
                        scrollNext();
                    }else if(offset <= -400){
                        scrollPre();
                    }else{
                        scrollCur();
                    }
                }
                isMove = false;

                break;

            default:
                break;
        }

        return true;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        // 将事件拦截掉
        return true;
    }

}

主要就是在 onLayout() 方法中计算出三个子 ImageView 的位置，然后上一页下一页的动画效果，还有滑动事件监听。

原点指示器

原点指示器就更加简单了，直接自定义一个，上面 BannerView 的 bindDotLinear 方法就是用于绑定原点指示器的。

原点指示器直接继承一个 View ，根据原点数量，当前选中原点，原点间距来用画笔画几个圆和一个圆角矩形而已。

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
public class DotLinear extends View {

    private Paint backPaint;
    private Paint dotPaint;
    private Paint curDotPaint;

    private int dotCount = 3;
    private int dotSize = 40;
    private int padding = 20;

    private int curDot = 0;

    public void initPoint(){
        backPaint = new Paint();
        backPaint.setColor(Color.BLACK);
        backPaint.setAlpha((int)(255*0.3));
        backPaint.setStyle(Paint.Style.FILL);

        dotPaint = new Paint();
        dotPaint.setColor(Color.WHITE);
        dotPaint.setAlpha((int)(255*0.3));
        dotPaint.setStyle(Paint.Style.FILL);

        curDotPaint = new Paint();
        curDotPaint.setColor(Color.WHITE);
        curDotPaint.setStyle(Paint.Style.FILL);
    }

    public void setCurDot(int curDot) {
        this.curDot = curDot;
        invalidate();
    }

    public void setDotCount(int dotCount) {
        this.dotCount = dotCount;
        invalidate();
    }

    public DotLinear(Context context) {
        super(context);
        initPoint();
    }

    public DotLinear(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        initPoint();
    }

    public DotLinear(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        initPoint();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(dotSize*dotCount+(dotCount+1)*padding ,dotSize+2*padding);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        canvas.drawRoundRect(0,0,getMeasuredWidth() ,getMeasuredHeight() ,getMeasuredHeight()/3f,getMeasuredHeight()/3f ,backPaint);

        float x = padding+dotSize/2f;
        for(int i = 0 ; i < dotCount ; i ++){

            if (i == curDot){
                canvas.drawCircle(x ,getMeasuredHeight()/2f ,dotSize/2f ,curDotPaint);
            }else{
                canvas.drawCircle(x ,getMeasuredHeight()/2f ,dotSize/2f ,dotPaint);
            }
            x += dotSize + padding;

        }

    }
}

滑动冲突

我的父布局用的是 NestedScrollView 监听上下滑动，而我们的 Banner 监听左右滑动，直接写会出现滑动冲突。
这里直接自定义个一个 NestedScrollView 来解决冲突问题。

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
/**
 * Created by HeYanLe on 2020/5/8 0008.
 * https://github.com/heyanLE
 */
public class BannerScrollView extends NestedScrollView {

    private boolean isScroll = true;
    private float xDistance, yDistance, xLast, yLast;

    public BannerScrollView(@NonNull Context context) {
        super(context);
    }

    public BannerScrollView(@NonNull Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public BannerScrollView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }


    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                isScroll = false;
                xDistance = yDistance = 0f;
                xLast = ev.getX();
                yLast = ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                if (isScroll){
                    return false;
                }
                final float curX = ev.getX();
                final float curY = ev.getY();
                xDistance += Math.abs(curX - xLast);
                yDistance += Math.abs(curY - yLast);
                xLast = curX;
                yLast = curY;
                if (xDistance > yDistance) {
                    isScroll = true;
                    return false;
                }
                return true;
            case MotionEvent.ACTION_UP:
                isScroll = false;

        }
        return super.onInterceptTouchEvent(ev);
    }
}

使用

一切准备就绪后，开箱即用。

1
2
3
4
5
6
7
8
9
ImageRing ring = new ImageRing();
ring.addImageInfo(DrawableInfo.of(R.drawable.f ,this).prepare());
ring.addImageInfo(DrawableInfo.of(R.drawable.s ,this).prepare());
ring.addImageInfo(DrawableInfo.of(R.drawable.t ,this).prepare());
bannerView.setImageRing(ring);


bannerView.bindDotLinear(dotLinear);
bannerView.startPoll();

省去了部分代码。

发表于 | 分类于

这是我在其他博客上看到的一个关于动态规划的小故事，觉得很形象地解释了动态规划是如何工作的，觉得有必要分享一下。

这篇文章只是通过一个小故事，让你对 动态规划 这个算法有一点更感性的认识，当然如果这提起了你学习的兴致，那再好不过了。直接上故事把。

原帖地址

转载有删减，如侵删。

背景

有一个国家，全部的国民都很老实憨厚，某天他们在自己的国家发现了十座金矿，而且这十座金矿在地图上排成一条直线，国王知道这个消息后很高兴，他希望可以把这些金子都挖出来造福国民，首先他把这些金矿依照在地图上的位置从西至东进行编号，依次为0、1、2、3、4、5、6、7、8、9，然后他命令他的手下去对每一座金矿进行勘測，以便知道挖取每一座金矿须要多少人力以及每座金矿可以挖出多少金子，然后动员国民都来挖金子。

规则

开采金矿具有以下规则：

  1. 挖每一座金矿须要的人数是 固定 的，多一个人少一个人都不行。国王知道每一个金矿各须要多少人手，金矿 i 需要的人数为 people(i) 。
  2. 每一座金矿所挖出来的金子数是固定的，如果 金矿 i 有 people(i) 人去挖，就一定能恰好挖出 gold(i) 个金子
  3. 国王在全国范围内仅招募到了10000 名愿意为了国家去挖金子的人，因此这些人可能不够把所有的金子都挖出来，但是国王希望挖到的金子越多越好。
  4. 国王只想要知道最多可以挖出多少金子，而不关心哪些金矿挖哪些金矿不挖。

故事 Part 1

那么国王是如何思考这个问题的呢？他来到了 金矿 9，他的臣子告诉他，如果要挖 金矿 9 的话就需要 1500 个人，然后可以挖出 8888 个金子，即 people(9) = 1500 ， gold(9) = 8888。

听到这里国王哈哈大笑起来，国王已经知道总共最多能挖出多少金子了，国王是如何在不了解其它金矿的情况下知道最多能挖出多少金子的呢？

他的臣子们也不知道这个谜，因此他的臣子们就问他了：『 最聪明的国王陛下，我们都没有告诉您其它金矿的情况，您是如何知道最终答案的呢？ 』

得意的国王笑了笑，然后把他最得意的左右手叫到跟前，说到：『我并不需要考虑最终要挖哪些金矿才能得到最多的金子，我只需要考虑我面前的这座金矿就可以了，对于我面前的这座金矿不外乎仅有两种选择，要么挖，要么不挖，对吧？』

『 当然，当然 』大臣们回答到。

国王继续说道：『 如果我挖取 金矿 9 的话那么我现在就能获得 8888 个金子，而我将用去 1500 个人，那么我还剩下 8500个人。我亲爱的左部下，如果你告诉我当我把所有剩下的 8500个人和所有剩下的其它金矿都交给你去开采你最多能给我挖出多少金子的话，那么我不就知道了在 金矿 9 一定开采的情况下所能得到的最大金币数吗？』

国王的左部下听后回答道：『国王陛下，您的意思是如果我能用 8500 个人在其它金矿最多开采出 x 个金币的话，那您一共就能够获得 x + 8888 个金子，对吗？』

『 是啊，是啊，如果第9座金矿一定开采的话。』大臣们点头说到。

国王笑着继续对着他的右部下说到：『 亲爱的右部下，也许我并不打算开采这 金矿 9，那么我依然拥有 10000 个人，如果我把这 10000 个人和剩下的金矿都给你的话，你最多能给我挖出多少个金子呢？』

国王的右部下聪明地说道：『 尊敬的国王陛下，我明白您的意思了，如果我回答最多能购开采出 y 个金币的话，那您就可以在 y 和 x+8888 之间选择一个较大者，而这个较大者就是最终我们能获得的最大金币数，您看我这样理解对吗？』

国王笑得更灿烂了，问他的左部下：『 那么亲爱的左部下，我给你 8500 个人和其余金矿的话你能告诉我最多能挖出多少金子吗？』

『 请您放心，这个问题难不倒我. 』左部下向国王打包票说到。

国王高兴地继续问他的右部下：『 那右部下你呢，如果我给你 10000 个人和其余金矿的话你能告诉我最多能挖出多少金子吗？』

『 当然能了！交给我吧！』右部下同左部下一样自信地回答道。

『 那就拜托给你们两位了，现在我要回到我那舒适的王宫里去享受了，我期待着你们的答复。』国王说完就开始动身回去等消息了。

他是多么地相信他的两个大臣能够给他一个准确的答复，因为国王其实知道他的两位大臣要比他聪明得多。

故事发展到这里，相信你很快就能想到接下来左右部下要怎么做了。

第二天，左右部下来到了 金矿 8 ，得知 金矿 8 需要 2000 人，并最终可以挖出 13000 个金币。此时，左右部下的心中已经知道各自的答案了。

对于左部下来说，国王给了它 8500 人和剩下九座金矿，他需要知道最多能挖出多少金子。

左部下叫来两个人，对其中一个人说：『 如果我给你 6500 人和剩下的八座金矿，你最多能给我挖出多少金子？』

对另一个人说：『 如果我给你 8500 人和剩下的八座金矿，你最多能给我挖出多少金子？』

『 交给我们。』两个人马上就去执行他们的任务。

『 如果他们两个都能回答我的问题，那么国王给我的问题不就解决了吗？』左部下如是想到。

此时，右部下也喊来两个人，问着一模一样只有数字不同的问题。

安排好后，两位部下相视一笑，『 我们的国王真是太聪明了 』

……

递推公式

故事听到这里先放一段落，让我们来好好感受一下国王的聪明之处，这也是动态规划的核心思想。

对于国王来说，它不需要思考十座金矿，它只需要等到左右部下的答案，然后简单的加减比较就能得出结果。

对于左右部下呢？他们也分别在等待两个人的结果，而最终这四个人会来到 金矿 7，继续分发他们的任务 ……

现在我们来构造一个函数：

$profit = p(i ,p)$：

  • 自变量 $i$ 表示前 $i+1$ 座金矿，如果 $i=9$ 则表示所有的十座金矿，如果 $i=8$ 则表示左右部下要思考的九座金矿。
  • 自变量 $p$ 表示你拥有的人数，比如对于国王来说，有 $10000$ 个人，则 $p=10000$ 。
  • 因变量 $profit$ 表示有 $i+1$ 座金矿和 $p$ 人的状况下最多能挖出多少金子。

对于国王来说，国王拥有十座金矿和 $10000$ 人，而令左右护法的给出的答案为 $x$ 和 $y$。

则有 ：

对于左部下来说，他拥有九座金矿和 $8500$ 人，假设左部下命令的两个人给出的答案分别为 $a$ 和 $b$ 。

则

同理

将 $x$ ，$y$带回国王的算式中：

有

然后，我们可以写出 $a$，$b$，$c$，$d$ 的表达式，带回到左右部下的表达式中，并以此类推，我们可以整理出关于这个函数的一般情况：

这就是这个函数的一个递推公式，国王的问题，可以一分为二，最终二分为四 ……

边界条件

从国王开始，一个人去找两个人，然后继续找，继续找，那么是否存在有的人可以直接给出答案不用找别人的呢？

答案肯定是有的，要不这个过程就没完没了了。其实也很容易想到，当被问到给你 $z$ 人和第一座金矿—— 金矿 0 ，你能给我多少金币的时候，我可以直接给出答案，我们可以写出这一种情况的表达式：

可以理解为，这是这个函数中几个特殊的自变量取得值，它不需要再次调用自己，直接就可以给出答案，这在动态规划里称为边界条件，在代码中也经常作为 递归 的 出口条件 和 迭代 的 停止条件 。

目标函数

将递推公式和边界条件合为一体，形成的一个函数，称为目标函数。在边界条件和递推公式的共同作用下，这个函数所有自变量的取值我们都能求出来。

后记

至此，这个故事 Part 1 就分析完毕了，关于更加详细的动态规划的内容，别担心，将在 Part 2 为你们分享 动态规划 这个算法的具体内容包括代码实现。

发表于 | 分类于

这是昨天刷到的一道题，觉得很有意思，觉得有必要记录一下。

题目描述

  • 面试题 64. 求1+2+…+n

  • 求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

  • 难度：中等

示例 1

1
2
输入: n = 3
输出: 6

示例 2

1
2
输入: n = 9
输出: 45

限制

  • 1 <= n <= 10000

解题

这个题，难度为中等，初看这个题目，第一眼想到的就是递归。但是递归的问题在于如何设置出口条件。直接看解法吧。

前排提醒，第一种方法为正解，后两种纯粹是为了好玩。

利用 短路与 结束递归

  • 语言：C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public:
    int sumNums(int n) {
        int r = 0;
        ss(n ,&r);
        return r;
    }

    int ss(int n ,int* r){
        (*r) += n;
        n>1&& ss(n-1 ,r); //利用短路出口递归
        return 1;
    }
};

代码中，sumNums 方法为开始方法，ss 为递归方法。
求和递归简单啊，递归的出口关键在于 n>1 && ss(n-1 ,r) 。

  • 当 n > 1 的时候，&& 左边为 true ，那么为了判断，右边的语句得以执行，此时进入递归。
  • 当 n <= 1 的时候, && 左边为 false ，作为与逻辑判断，直接短路，右边的语句没有执行，递归结束。

ss 函数的返回值其实是多少都无所谓，只是在 && 两边的语句需要而已。

结果

利用空间和回调模拟 if 效果

这是我的一个朋友提醒我的，他的原话是 自己实现一个 if ？，不得不说，这种思路还挺好玩的，不过时间空间上就不要想了。

  • 语言：JAVA
    主要还是为了方便吧，JAVA 的回调方法比较好写。
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
class Solution {
    List<Boolean> booleans = new ArrayList<>();
    public int sumNums(int n) {
        booleans.add(false);
        booleans.add(true);

        r = 0;
        num(n);
        return r;
    }

    int r = 0;
    public void num(int n){
        Runnable[] runnables = new Runnable[2];
        runnables[0] = new Runnable() {
            @Override
            public void run() {
                r += n;
                num( n-1);
            }
        };
        runnables[1] = new Runnable() {
            @Override
            public void run() {
                
            }
        };
        runnables[booleans.index((n<=0))].run();
    }
}

代码中，sumNums 方法为开始方法，num 为递归方法。

其实思路的话看过代码应该就能理解。

不让用 if，我们就自己实现一个。

把本来要写进 if 以及 else 里面的代码包装成要给 Runnable。放到一个数组里面，其中 0 对应着 false，1 对应着 true。

当然 JAVA 是不允许把 boolean 强转成 int 的，我们可以用一个 List 来建立 boolean 到 int 的对应关系。

结果

异常

我的另一个朋友突发奇想，可以使用异常。行吧，这个就是纯粹为了玩了。

  • 语言：JAVA 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    int r;
    public int sumNums(int n) {
        r = 0;
        int[] s = new int[n];
        try {
            num(n ,s);
        }catch (Exception e){
            e.printStackTrace();
        }
        return r;
    }

    

    public void num(int n ,int[] s){
        s[n-1] = 0; // 当 n-1 < 0 时候抛出异常
        r += n;
        num(n-1 ,s);
    }
}

代码中，sumNums 方法为开始方法，num 为递归方法。

主要是 s[n-1] = 0 这一行代码，当 n-1 < 0 时候会抛出异常，当然递归也就中止了，然后在外面捕获一下异常防止崩溃，不得不说，太骚了。

结果

发表于 | 分类于

之前写过一篇博客实现整体字体自定义，不过那种方法有缺陷，最近我发现了一个全新的方法，赶紧又写了下来。

FontHelper

这个类改变不大，只是加了一个全新的方法 fontByReflex :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 通过反射修改全部字体
 */
public boolean fontByReflex(){
    try{
        Field field = Typeface.class.getDeclaredField("SANS_SERIF");
        field.setAccessible(true);
        field.set(null, mTypeFace);
    }catch (Exception e){
        e.printStackTrace();
        return false;
    }
    return true;

}

这个方法的作用为，将系统默认的名叫 SANS_SERIF 的 TypeFace 改为我们自己的 TypeFace ，也就是上一章讲到我们获取的 TypeFace 对象。
需要在 Application 中 init 后就调用。

style.xml

然后在 style.xml 文件里将默认的 style 的 android:typeface 修改为 sans :

1
2
3
<style name="BaseTheme" parent="Theme.MaterialComponents.Light.NoActionBar">
    <item name="android:typeface">sans</item>
</style>

多核心处理

至此，反射调用已经完成了，但我总觉得有些不妥，于是我加入了多核心处理。
其实也不是很麻烦，就是在 FontHelper 中新建了一个标识用于标记当前反射是否成功，如果上述发射方法没有异常抛出，则为 true 。
然后在之前的 font(Activity a) ，font(View v) 等方法中判断标识，如果为 false 才起作用。
对于一些通过这个反射无法变换的 View ，我加入了一个 fontViewForever(View v) 方法，可以采用上一章递归的方式设置字体。

侧滑烂 NavigationView

我用了此方法后，侧滑栏的字体就是不变，我觉得很神奇。后来我们老大解决了，具体代码等我再来慢慢研究，先直接贴上：

在 MainActivity 中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if (FontHelper.getInstance().getTypeFace()!=null){
    for (int i = 0; i < navigationViewMenu.size(); i++) {
        MenuItem mi = navigationViewMenu.getItem(i);

        //for aapplying a font to subMenu ...
        SubMenu subMenu = mi.getSubMenu();
        if (subMenu != null && subMenu.size() > 0) {
            for (int j = 0; j < subMenu.size(); j++) {
                MenuItem subMenuItem = subMenu.getItem(j);
                CustomTypefaceSpan.applyFontToMenuItem(subMenuItem);
            }
        }
                //the method we have create in activity
        CustomTypefaceSpan.applyFontToMenuItem(mi);
    }
}

其中 CustomTypefaceSpan 类如下：

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
public class CustomTypefaceSpan extends TypefaceSpan {

    private final Typeface newType;

    public CustomTypefaceSpan(String family, Typeface type) {
        super(family);
        newType = type;
    }

    @Override
    public void updateDrawState(TextPaint ds) {
        applyCustomTypeFace(ds, newType);
    }

    @Override
    public void updateMeasureState(TextPaint paint) {
        applyCustomTypeFace(paint, newType);
    }

    private static void applyCustomTypeFace(Paint paint, Typeface tf) {
        int oldStyle;
        Typeface old = paint.getTypeface();
        if (old == null) {
            oldStyle = 0;
        } else {
            oldStyle = old.getStyle();
        }

        int fake = oldStyle & ~tf.getStyle();
        if ((fake & Typeface.BOLD) != 0) {
            paint.setFakeBoldText(true);
        }

        if ((fake & Typeface.ITALIC) != 0) {
            paint.setTextSkewX(-0.25f);
        }

        paint.setTypeface(tf);
    }



    public static void applyFontToMenuItem(MenuItem mi) {
        SpannableString mNewTitle = new SpannableString(mi.getTitle());
        mNewTitle.setSpan(new CustomTypefaceSpan("" , FontHelper.getInstance().getTypeFace()), 0 , mNewTitle.length(),  Spannable.SPAN_INCLUSIVE_INCLUSIVE);
        mi.setTitle(mNewTitle);
    }
}

发表于 | 分类于

最近写了一个新的项目『记密码』，以下是我需要实现的功能：

  • 数据库储存
  • 数据库加密
  • 密码安全
  • 指纹解锁授权

其中，数据库储存和数据库加密是基本功能，其中 SQLite 原生就支持加密，具体在 Android 上的实现我将会在下一篇文章中谈到。这篇文章将具体讲到『记密码』关于 密码安全 和 指纹解锁授权 方面的解决方案。

加密方式

加密方式有很多种，在『记密码』的整个安全策略中主要使用这两种加密方式。

摘要加密

这种方式会破坏明文所包含的信息，这就导致了这种方式 无法逆推 。简单地说：

1
2
3
明文 A 通过摘要加密得到 密文 B
密文 B 无法通过任何常规手段反推出 明文 A
此时 B 也可以称为 A 的摘要

这种加密方式被广泛用于密码的储存，如果直接将用户设置的密码储存在服务器或者本地，那么会被一些不法分子利用。而此时我们可以通过储存 摘要 来解决这个问题。

以下是摘要在密码储存的一个应用示意图：

对称加密

对称加密 就比较符合我们对加密的认知，它可以包括加密操作和解密操作，简单点说：

1
2
3
事先设置或随机生成一个密钥 C
明文 A 使用密钥 C 进行对称加密得到密文 B
密文 B 使用密钥 C 进行对称解密得到明文 A

了解完两种加密方式后，我们进入正题。

密码安全

密码安全就是说你密码的储存，正确与否的判断是要安全的。

『记密码』在第一次启动后，将会让用户设置一个 4 位的 安全密码 ，这个密码将是整个 App 的基础，因为这将决定数据库的加密密码，决定方式因为一些原因我就不展开，大家需要知道的是只有知道这个 安全密码 ，才能打开数据库查看里面的数据，当然对于 密码提示 等无关紧要的信息，直接明文储存即可。

而关于 安全密码 的储存和判断，具体方式和上面讲到的 摘要加密 的实例很像，这里直接上图。

这种方式在理论上是安全的，只要一个前提就是我选取的这种摘要加密方式能够保证摘要无法反推出密码，因为一些原因我不能提供我所用的摘要加密方式的任何信息，所以大家只要知道这种方式是安全的即可。

指纹解锁授权

一开始想到要支持指纹解锁时候，还以为非常简单，但实则不然。

难题

因为写到这里，我的安全密码的存储方案已经确定了下来。一开始我尝试直接将指纹解锁加进去。

因为安卓系统的问题，我们程序无法获取指纹信息，只能调用系统的相关接口，而系统也只会返回你正确或者错误。

当 App 收到系统返回的指纹正确信息时，本来应该启动 App 读取数据库了，但是我们的数据库使用 安全密码 进行了加密，而我们本地存储的，只有 安全密码 的摘要，所以程序无法获取正确的 安全密码 来打开数据库。

具体可以参考以下图例

解决方案

使用对称加密

要想解决这个问题，要认识到问题的本质在于程序无法获得 安全密码，而要想要让程序获得 安全密码 ，必须将密码信息保存在本地。首先肯定不能明文保存，这样没有任何意义。于是就需要使用 对称加密 的方案。

授权机制

确立了方向要使用 对称加密 那么问题就转化为， 如何确定密钥？
其实指纹的加入只是为了让用户方便地解锁，其本身并不能作为加密的主要方式，所以， 指纹解锁不能永久有效，需要有一定的过期时间 。

所以我想到了一种授权机制，而确立了授权机制之后，可以通过过期的时间来确立 对称加密 的密钥。

具体来说，就是在用户输入密码解锁后，获取一个月后的时间作为过期时间，使用这个时间确立密钥，然后对 安全密码 使用密钥进行 对称加密 ，并将密文和过期时间同时存储在本地，这样就完成了一次指纹授权。

还是直接上图例

安全性

分析这个授权机制，会发现这个机制会降低整体的安全性。因为它让不法分子有机可乘。如果你想干坏事你需要：

  1. 获取 安全密码 的密文 B
  2. 获取存储的过期时间并确定密钥 C
  3. 使用密钥 C 对 密文 B 进行对称解密就能得到 安全密码

当然，其中还是有很多难点的。不法分子将在以下地方受到阻碍：

  • 获取 App 本地存储的数据（ Android 在这方面有一定的限制）
  • 获取过期时间来确立密钥 C 的方式
  • 获取密文 B 的 对称加密 方式

这三点也就是我认为指纹授权是安全的最重要的两点，想要知道这两点信息，需要在软件代码中寻找。虽然我的软件没有加固，但是依然设立了代码混淆。这也是这方面的最后防线。
当然，如果你不相信这方面，那么你可以选择关闭指纹解锁。

发表于 | 分类于

最近项目有一个需求，需要让 App 支持自定义字体，并且要支持用户自己指定的 ttf 文件，经过不懈努力，终于实现了，赶紧写一篇博客记录下来。

Typeface

Typeface 是一个字体的实体类，可以通过调用 TextView 的 setTypeface 方法来设置一个 TextView 的字体。而大部分的和字体有关的 View 都继承于 TextView ，所以我们可以写一个字体管理类，维护一个 Typeface 变量，而每一个 View 在渲染后，都将自己的字体设置为字体管理类的字体。

Typeface 创建

查阅了一下 Api 文档，发现有两种方式可以创建 Typeface :

1
2
Typeface.createFromAsset(context.getAssets(), path);
Typeface.createFromFile(path);

其中第一种为项目 Assets 文件夹里的字体文件，第二种为手机储存上的字体文件。

FontHelper

FontHelper 是一个静态类或单例类，它具有以下功能：

  • 根据要求创建相应的 Typeface 对象并储存
  • 修改一个 View 及其所有子 View 的字体

Typeface 对象创建和维护

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
private Typeface mTypeFace = null;

/**
* 使用 Assets 文件夹下的字体文件创建 Typeface 对象
* @param context    上下文
* @param path       字体文件路径
*/
public void initFromAssets(Context context ,String path){
    try {
        mTypeFace = Typeface.createFromAsset(context.getAssets(), path);
    }catch (Exception e){
        e.printStackTrace();
    }

}

/**
* 使用手机储存中的字体文件创建 Typeface 对象
* @param path       字体文件路径
*/
public void initFromSD(String path){
    try {
        mTypeFace = Typeface.createFromFile(path);
    }catch (Exception e){
        mTypeFace = Typeface.DEFAULT;
    }

}

递归设置 View

通过递归，设置一个 View 及其所有子 View 的字体。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void font(View view) {
    if (mTypeFace == null){
        return;
    }
    if (view == null ) {
        return;
    }
    if (view instanceof TextView) {
        TextView textView = (TextView)view;
        textView.setTypeface(mTypeFace);
    } else if (view instanceof ViewGroup) {
        ViewGroup viewGroup = (ViewGroup) view;
        for (int i = 0; i < viewGroup.getChildCount(); ++i) {
            font(viewGroup.getChildAt(i));
        }
    }
}

设置 Paint 的字体（ 适用于自定义 View ）

1
2
3
4
5
6
7
8
9
public void font(Paint paint){
    if (mTypeFace == null){
        return;
    }
    if(paint == null){
        return;
    }
    paint.setTypeface(mTypeFace);
}

设置 Activity 的字体

1
2
3
4
5
6
7
8
9
10
public void font(Activity activity){
    if( mTypeface == null ){
        return;
    }
    if(activity == null){
        return;
    }
    View rootView = ((ViewGroup)activity.findViewById(android.R.id.content)).getChildAt(0);
    font(rootView);
}

在相关 Context 中调用

Activity

1
2
3
4
5
6
public class baseActivity  extends AppCompatActivity{
    @Override
    protected void onStart(Bundle savedInstanceState) {
        FontHelper.getInstance().font(this);
    }
}

Fragment

1
2
3
4
5
6
7
public class baseFragment  extends Fragment{
    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        FontHelper.getInstance().font(view);
    }

}

缺陷

这种方式设置自定义字体，相比于反射已经非常优雅和稳定了，但是它依然有部分缺陷，例如使用官方模板的 Dialog （如果是自定义 Dialog 可以将 View 设置字体）和 PopupWindow 等。暂时还没想到解决方案。