提速法则一览

手段	全量构建	Java增量构建	资源增量构建
升级 android gradle tools 到3.0	-15s(-25%)	-10(-38%)	-2.5(-16%)
避免使用遗留的Multidex	-5.5s(-12%)	-8(53%)	same
debug 环境关闭multi-APK	-4.8s(-12%)	-0.5s(-6%)	-3s(-26%)
设置包含最少的资源	-6s(-17%)	-1.5s(-24%)	-2s(21%)
关闭 png crunching	-9s(-33%)	same	same
使用Instance Run	+7s(+37%)	-3s(-54%)	-3s(-42%)
避免不注意的改变	-	-	-
不要使用动态版本号	-	-	-
注意分配 gradle 内存	-	-	-
开启 Gradle Caching	-7s(-25%)	same	+0.5s(+12%)
使用implementation 或者 api 代替 compile	-	-	-

以上优化方案基于android gradle tools 3.0-alpha

关于Santa Tracker Project

• 9 个模块，包括Wear
• 500 多个Java文件
• 1700 个XML 文件，3500张PNG
• Multi-dex
• 没有 annotation processors
• APK大小接近60MB

这个项目可以在Google Github 帐号中找到

启动模式分为4种，分别为

1. Standrad
2. SingleTop
3. SingleTask
4. SingleIntance

Standrad

就是默认的模式，启动多少个就是多少个

SingleTop

SingleTop 需要这样理解，SingleOnTop,当栈顶是我的时候，就不再创建新的实例。
例如，ABCD，启动D，还是ABCD。如果是ABDC，启动D，最后就变成ABDCD。

SingleTask

SingleOnTask的意思，我在这个任务栈是唯一的。需要注意的是，这货启动是默认自带clearTop效果的，也就是会把在它之后的Activity都清楚掉。
例如，任务栈中有ABDC，启动D，将会变成ABD，C将会被自动推出。

SingleIntance

这个可以看做是SingleTask加强版，使用这个属性的Activity，将会被单独放在一个任务栈中，然后这个Activity在进程中都是唯一个的

Bitmap Config 解析

Bitmap.Config
ALPHA_8	每个像素存储为单透明（alpha）通道。其实就是保存透明度而已
ARGB_4444	已经废弃的格式,推荐使用ARGB_8888
ARGB_8888	每个像素存储在4个Byte上,其实就是ARGB分别占用8bit的意思
HARDWARE	特殊配置，当位图只存储在图形内存中。
RGBA_F16	每个像素存储在8个Byte上，这个我不太看得懂，就是RGBA 格式保存，每一个占用16bit,F并不知道是什么意思
RGBA_F16	每个像素存储在8个Byte上，这个我不太看得懂，就是RGBA 格式保存，每一个占用16bit,F并不知道是什么意思
RGB_565	每个像素存储在2个Byte上，只有RGB通道被编码：红色以5位精度（32个可能值）存储，绿色以6位精度存储（64个可能值），蓝色存储5位精确。

位图占用内存计算

例：
选择的是ARGB_8888 分辨率为 100*100 的位图。
占用的内存应该是

100 * 100 * 4 = 40000 Byte = 39kB

总结

只要记住符号上表示的是bit就很容易计算Bitmap在内存中占用的大小了

分为步骤

1. 选择系统为centos7
2. 更新kernel 为4.1 以上
3. 开启bbr
4. 安装docker-ce环境
5. 使用shadowsock-docker部署ss

系统选择

各大主机提供商不太一样，这段靠自己吧

更新kernel

执行以下bash

或者直接在命令行上敲

curl -o- -L https://gist.githubusercontent.com/hangox/a9b977a9c026629101c38d5e6a2b4e76/raw/d97e16123218c068c024a12019e1a403ef47981f/update-kernel-for-centos7.sh | bash 

执行完成脚本之后将会重启系统，耐心等候重启就好了

为什么使用Groovy写JUnit

Groovy 是动态语言，动态语言干测试其实非常好用。比如，我要创建一个多种类型的数组，只要这样写def array = [12,12,'1212'] 这样我就很简单的创建了多种类型的数组了。如果是用java代码的话，你可以尝试一下需要多少行。groovy的优点不只是这些，详情请看Groovy的特性

Android中的配置方法

在Android中需要使用Groovy需要使用这个开源项目,里面有详细的配置说明。但是我按那个配置，老是编译不过，改了一下就可以了，就写下自己的办法吧。

配置buildScript

buildscript {
    
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.0.0-beta7'
        //groovy插件依赖
        classpath 'org.codehaus.groovy:groovy-android-gradle-plugin:1.2.0'

    }
}

在需要使用的项目中，加入插件

apply plugin: 'groovyx.android'

添加groovy依赖

我这里只是使用Groovy 作为测试使用，所以我是用的是testImplementation,如果要在开发中使用Groovy,请改为implementation 就可以了

dependencies {
//使用官方推荐的反而不行
//    testImplementation 'org.codehaus.groovy:groovy:2.4.11:grooid'
//我该为了java使用的Groovy就可以了
    testImplementation 'org.codehaus.groovy:groovy-all:2.4.12'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation('com.android.support.test.espresso:espresso-core:3.0.1', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
}

开始开发

在test/groovy文件夹中建立你的Groovy 脚本，开始开发吧

示例项目

为什么要开发MetaWeblogApi for hexo

1. 讨厌每次都要敲命令行
2. 想在任何地方编写文章并可以提交
3. 喜欢编辑器沉浸式的编写体验

实现原理

participant 编辑器 as B
participant MetaWeblogApi as M
participant 博客Git地址 as A
participant 博客 as E

B->M: 发送Mardown格式的文本
note left of M: git pull 
M->B: 返回BlogId确认提交成功 
note right of M: 生成Hexo 的Markdown
M->A: 提交到
note right of M: 调用Hexo 生成
M->E: deploy 到博客地址
 

问题来源:two sum

问题描述

给定一个整数数组，返回两个数字的索引，使它们相加到一个特定的目标。 您可以假设每个输入都只有一个解决方案， 而您可能不会使用相同的元素两次。

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

解

正向思维解法

直接遍历所有的组合，求出问题的解

public int[] twoSum(int[] nums, int target) {
     for (int i = 0; i < nums.length; i++) {
           for (int j = i + 1; j < nums.length; j++) {
                    if (target == nums[j] + nums[i]) {
                        return new int[] { i, j };
                    }
         }
    }
    throw new IllegalArgumentException("No two sum solution");
}

分析:
这是最简单的解法。两个嵌套循环，时间复杂度为O(n^{2)。空间复杂度为O(1)}

逆向思维解法

用目标减去加数1，得到加数2，再在数组中寻找。

实现1

public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (target - nums[i] == nums[i]) {
                    return new int[] { i, j };
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

分析
没错，就是和第一解法时间空间复杂度都是一样的😂。没事，我们可以优化一下的。

实现2

在实现一中，我们的瓶颈主要是在如何根据值去找到索引的问题上，所以这里我们使用Map去优化根据值去寻找位置的瓶颈

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement) && map.get(complement) != i) {
            return new int[] { i, map.get(complement) };
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

分析:
我们使用一个循环把数据与位置建立索引，然后获取的时候直接从map中直接获取，这样就可以避免了两个嵌套的循环了，是的时间复杂度为O(n) ,空间复杂度为O(1).

note: 在算法中，我们不考虑map这些数据结构具体实现使用的时间

实现3

实现2中使用了两个循环，能不能把第一个循环也去掉呢？答案是可以的。一边循环，一边插入map，然后获取这个差值是否已经加入到map中。

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[] { map.get(complement), i };
        }
        map.put(nums[i], i);
    }
    throw new IllegalArgumentException("No two sum solution");
}

分析：
这个复杂度和实现2是一样的，时间为O(n),空间为O(n)，但细看还是有差别的，这个算法的实际上比实现2的快了1倍

翻译自谷歌博客

2017年8月9日，星期三

Android Studio 3.0 Beta 1现在可以在金丝雀和开发渠道中使用。

已知问题

如果您现有的Android Studio项目使用的是Android插件3.0.0的Alpha版本（如3.0.0-alpha9），则迁移到Android 3.0.0-beta1后sync your project将会遇到： Gradle project refresh failed。

解决此问题的办法就是从菜单栏中选择 Build> Clean Project - 您只需对每个项目执行一次此操作。然后，您可以通过从工具栏中单击“ Sync Project ” ，将其与Gradle对应。

此版本包含各种错误修复，包括以下内容：

修复了使用Kotlin插件崩溃的类加载问题。
修复了菜单栏不再显示的问题。（问题＃63743086）

首先直接修改根目录下的.gitmoudule 文件

[submodule "libraries/GaiaLibrary4BLE"]
    path = libraries/GaiaLibrary4BLE
    url = http://yousumodule_remote

然后同步设置

使用一下命令把设置同步到.git/config 文件中

git submodule synca

最后更新远端信息

使用以下命令更新远端信息

git submodule update --init --recursive --remote

其实就是从远端递归式的初始化的意思

什么是JobScheduler？

JobScheduler 是Android 5.0之后提供的后台执行操作的API。简单点描述就是可以根据一系列条件，目前包括，时间，是否在充电，ContentProvider 是否改变等条件触发工作。这是和AlarmManager最大的区别，AlarmManager 只能在一个时间启动，不能根据机子时间启动。

会在什么情况下使用呢？

• 用户拍了一张照片的时候需要触发相应的操作，这个时候就可以监听照片的ContentProvider ,发生改变就能触发我的操作。当然，这个同样适用于所有ContentProvider
• 固定时间唤醒进行响应的操作
• 需要设备空闲的时候进行图片的OCR识别保存信息
• 需要设备空闲而且在充电的时候并且连接着WIFI的时候才能图片上传到服务器