开发插件原由

近期项目组考虑到编写代码的时候有个繁琐的工作

• class -> className
• for -> htmlFor
• style

就是遇到类似上面这些字符的时候得转换成相应的字符

开发插件的步骤

1、Step 新建插件项目

开发工具是 IDEA

选择 File->New->Project 选择 IntelliJ Platform Plugin

选好 JDK 就可以了

2、Step

编写 plugin.xml

1
2
3
4
5
6
7
8
9
10
11

<actions>
  <group id="StringConversion.Generate" text="StringConversion" description="对 JS 文件中的特需字符转换">
    <action id="StringConversion.StringAction"
            class="com.caituo.plugin.StringConversion"
            text="StringConversion" description="StringConversion">
      <add-to-group group-id="EditMenu" anchor="first"/>
      <add-to-group group-id="EditorPopupMenu" anchor="first"/>
      <keyboard-shortcut keymap="$default" first-keystroke="shift ctrl P"/>
    </action>
  </group>
</actions>

actions节点理解成 Android Studio XML 文件里的application

group id节点理解成 Android Studio XML 文件里的activity

add-to-group group-id 导航栏设置
keyboard-shortcut 快捷键设置

3、Step

编写类继承com.intellij.openapi.actionSystem.AnAction

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

/**
 * 执行插件的入口，相当于java中的main方法
 *
 * @param anActionEvent
 */
@Override
public void actionPerformed(AnActionEvent anActionEvent) {
    if (!isFastClick(1000)) {
        Logger.init(getClass().getSimpleName(), Logger.DEBUG);
    }
    Editor editor = anActionEvent.getData(PlatformDataKeys.EDITOR);
    if (editor == null) {
        return;
    }
    SelectionModel model = editor.getSelectionModel();
    String text = model.getSelectedText();
    if (TextUtils.isEmpty(text)) {
        return;
    }
    Logger.debug(text);
    //下面这句话也可以使用 lambda 语法写：Runnable runnable = () -> editor.getDocument().replaceString(selectionModel.getSelectionStart(), selectionModel.getSelectionEnd(), TransitionUtils.spacingText(selectedText));
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            //先对空格、制表符进行换掉，然后再重新进行分隔处理。其中分行不处理，因为在写文章的时候复制的一些内容分行是有意义的。
            editor.getDocument().replaceString(model.getSelectionStart(),
                    model.getSelectionEnd(),
                    TransitionUtils.spacingText(RegexExpressionUtils.replace(text, "\\f|\\r|\\t", "")));
        }
    };
    WriteCommandAction.runWriteCommandAction(anActionEvent.getData(PlatformDataKeys.PROJECT), runnable);
}

4、Step

打包生成 .jar 文件

GitHub 地址：Conversion

APK 打包流程

Android Studio 开发过程中、经常会 Run APP，APK 就会自动的安装到我们的手机上，这里来聊聊其中经历了那些过程。

典型 Android 应用模块的构建流程

官方给出的构建图：

• 编译器将您的源代码转换成 DEX（Dalvik Executable) 文件（其中包括运行在 Android 设备上的字节码），将所有其他内容转换成已编译资源。
• APK 打包器将 DEX 文件和已编译资源合并成单个 APK。不过，必须先签署 APK，才能将应用安装并部署到 Android 设备上。
• APK 打包器使用调试或发布密钥库签署您的 APK：
  • 如果您构建的是调试版本的应用（即专用于测试和分析的应用），打包器会使用调试密钥库签署您的应用。Android Studio 自动使用调试密钥库配置新项目。
  • 如果您构建的是打算向外发布的发布版本应用，打包器会使用发布密钥库签署您的应用。要创建发布密钥库，请阅读在 Android Studio 中签署您的应用。
• 在生成最终 APK 之前，打包器会使用 zipalign 工具对应用进行优化，减少其在设备上运行时的内存占用。

构建流程结束时，您将获得可用来进行部署、测试的调试 APK，或者可用来发布给外部用户的发布 APK。

参考：构建流程

再来看一张稍微详细一点（来自老版官网）

从上面的流程图，我们可以看出apk打包流程可以分为以下七步:

• 通过aapt打包res资源文件，生成R.java、resources.arsc和res文件（二进制 & 非二进制如res/raw和pic保持原样）
• 处理.aidl文件，生成对应的Java接口文件
• 通过Java Compiler编译R.java、Java接口文件、Java源文件，生成.class文件
• 通过dex命令，将.class文件和第三方库中的.class文件处理生成classes.dex
• 通过apkbuilder工具，将aapt生成的resources.arsc和res文件、assets文件和classes.dex一起打包生成 apk
• 通过Jarsigner工具，对上面的apk进行debug或release签名
• 通过zipalign工具，将签名后的apk进行对齐处理

最后看张更详细的

1

apk打包好了会输出在项目的/app/build/outputs/apk目录下，在Android Studio中我们可以双击apk文件查看当前apk的目录结构，包括各个文件的大小，dex中包含了哪些方法及方法数等，非常方便

文章参考处 loody

生活书

• 菜根谭
• 人性的弱点
• 鬼谷子全集
• 资治通鉴
• 曾国潘全集
• 穆斯林的葬礼
• 贾平凹长篇散文精选
• 父亲的雪山，母亲的草地
• 西方哲学史
• 周国平著作
• 瓦尔登湖

MAC 常用操作

对应键盘

Command    ⌘
Option    ⌥
Control    ⌃
Shift    ⌂

命令

显示隐藏文件    defaults write com.apple.finder AppleShowAllFiles -bool true
关闭显示隐藏文件 defaults write com.apple.finder AppleShowAllFiles -bool false
禁止.DS_store生成 defaults write com.apple.desktopservices DSDontWriteNetworkStores -bool TRUE    
恢复.DS_store生成 defaults delete com.apple.desktopservices DSDontWriteNetworkStores    

环境配置

1
2
3
4
5
6

1. 启动Terminal终端工具
2. 输入cd ~/ 进入当前用户的 home 目录
3. 创建：touch .bash_profile
4. 打开并编辑：open .bash_profile
5. 在文件中写入以下内容：export PATH=${PATH}:/Users/boomhe/Library/Android/sdk/platform-tools
6. 执行如下命令：source .bash_profile

数组使用

数组合并

ES5的写法

1
2
3
4
5

let arr1=[0,1,2];
let arr2=[3,4,5];
Array.prototype.push.apply(arr1,arr2);

ES6的写法

1
2
3
4
5
6

let arr3=['a','b','c'];
let arr4=[3,4,5];
arr3.push(...arr4);

几个属性的理解

• Object.keys(obj) :返回对象自身的所有可枚举的属性的键名

1
2
3
4

let arr1keys = Object.keys(arr1);  // ["0", "1", "2", "3", "4", "5"] 
let arr3keys = Object.keys(arr3);   // ["0", "1", "2", "3", "4", "5"]

• Object.getOwnPropertyNames(obj):返回一个数组，包含对象自身的所有属性

1
2

let temp1 = Object.getOwnPropertyNames(arr1);// ["0", "1", "2", "3", "4", "5", "length"]

• Object.getOwnPropertySymbols(obj):返回一个数组，包含对象自身的所有Symbol属性

1
2

let temp2 = Object.getOwnPropertySymbols(arr2);// []

for…of 、for…in 和 forEach

• for of是遍历键值

1
2
3
4
5
6

for( let i of arr3 ){
console.log(i);// a b c 3 4 5
}

• for…in循环：只遍历对象自身的和继承的可枚举的属性、for in是遍历键名

1
2
3
4
5
6

for( let i in arr3 ){
console.log(i);// 0 1 2 3 4 5
}

• forEach循环

1
2
3
4
5
6
7
8

arr3.forEach(function(item,index){
console.log(item);// a b c 3 4 5
console.log(index);// 0 1 2 3 4 5
});

数组过滤

• 扩展数组prototype属性过滤数组

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

let arrayAll = [{'id':'111','name':'aaa'},
            {'id':'222','name':'bbb'},
            {'id':'333','name':'ccc'}];
            
let arrayDel = [{'id':'111','name':'aaa'}];
            
Array.prototype.indexOf = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (val.id == this[i].id) return i;
    }
    return -1;
};
Array.prototype.remove = function(val) {
    var index = this.indexOf(val);
    if (index > -1) {
        this.splice(index, 1);
    }
};
for (let i of arrayDel.length) {
    let obj = arrayDel[i];
    array.remove(obj);
}
console.dir(array);

• lodash 库 differenceBy 方法

1
2

let newArray = differenceBy(array,[{'id':'111','name':'aaa'}],'id');
console.dir(newArray);

ES 6 常用 API

常用快捷键

Android Studio 快捷键

Chrome 插件推荐

Android Studio 插件

库依赖

项目库

库依赖

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment

java.util.ConcurrentModificationException

异常描述：该异常表示并发修改异常.迭代器迭代过程中，迭代的对象发生了改变，如数据项增加或删除.

解决思路：由于迭代对象不是线程安全，在迭代的过程中，会检查 modCount 是否和初始 modCount 即 expectedModCount 一致，如果不一致，则认为数据有变化，迭代终止并抛出异常。常出现的场景是，两个线程同时对集合进行操作，线程 1 对集合进行遍历，而线程 2 对集合进行增加、删除操作，此时将会发生 ConcurrentModificationException 异常。

解决方法：多线程访问时要增加同步锁，或者建议使用线程安全的集合：

1. 使用 ConcurrentHashMap 替换 HashMap，CopyOnWriteArrayList 替换 ArrayList。
2. 或者使用使用 Vector 替换 ArrayList，Vector 是线程安全的。Vector 的缺点：大量数据操作时，由于线程安全，性能比 ArrayList低。

java.lang.ArrayIndexOutOfBoundsException

异常描述：该异常表示数组越界.

解决思路：这种情况一般要在数组循环前做好 length 判断，index 超出 length 上限和下限时都会报错。举例如下：一个数组 int test[N]，一共有 N 个元素分别是test[0]~test[N-1]，如果调用 test[N]，将会报错。建议读取时，不要超过数组的长度（array.length）。
Android 中一种常见情形就是上拉刷新中 header 也会作为 listview 的第 0 个位置，如果判断失误很容易造成越界。

异常情况：TextView 中 ellipsize 使用引发 Crash，该问题为 Android 系统 bug，存在于 Android 5.0 及以下设备，问题描述参考

解决方法：使用 android:singleLine=”true” 代替 android:lines=”1” 和 android:maxLines=”1”

java.lang.IllegalStateException

异常描述：状态异常

解决思路 错误类型大致为以下几种:

• java.lang.IllegalStateException：Cannot forward a response that is already committed(无法转发已经提交的响应)
• IllegalStateException：response already commited(响应已经提交)
• IllegalStateException：getOutputStream() has already been called for this request(已经为此请求调用了getOutputStream )
  ……………

例1：IllegalStateException: Can not perform this action after onSaveInstanceState(在onSaveInstanceState之后无法执行此操作)

错误原因：
该异常表示，当前对客户端的响应已经结束，不能在响应已经结束（或说消亡）后再向客户端（实际上是缓冲区）输出任何内容。Object is no longer valid to operate on. Was it deleted by another thread? 该异常表示，realmObject 对象在其他线程已被删除，在这个线程中使用的时候抛出的异常。

解决方法：
onSaveInstanceState 方法是在该 Activity 即将被销毁前调用，来保存 Activity 数据的，如果在保存玩状态后再给它添加 Fragment 就会出错。解决办法就是把 commit（）方法替换成 commitAllowingStateLoss()

具体分析：
首先解释下flush()，我们知道在使用读写流的时候数据先被读入内存这个缓冲区中， 然后再写入文件，但是当数据读完时不代表数据已经写入文件完毕，因为可能还有一部分仍未写入文件而留在内存中，这时调用 flush() 方法就会把缓冲区的数据强行清空输出，因此 flush() 的作用就是保证缓存清空输出。response 是服务端对客户端请求的一个响应，其中封装了响应头、状态码、内容等，服务端在把 response 提交到客户端之前，会向缓冲区内写入响应头和状态码，然后将所有内容 flush。这就标志着该次响应已经 committed。对于当前页面中已经 committed 的 response，就不能再使用这个 response 向缓冲区写任何东西（注：同一个页面中的 response.XXX()是同一个 response 的不同方法，只要其中一个已经导致了 committed，那么其它类似方式的调用都会导致 IllegalStateException 异常）。
参考1、参考2

例2: java.lang.IllegalStateException
Can’t change tag of fragment d{e183845 #0 d{e183845}}: was d{e183845} now d{e183845 #0 d{e183845}}

错误原因：
经查，我在显示 fragment 的代码中使用了 fragment.show(getSupportFragmentManager, fragment.toString())
而这里是因为两次 toString()结果不同，导致不同的 tag 指向的是同一个 fragment。

解决方法：
获取 fragment 的 tag 的正确方法应该是使用其提供的 fragment.getTag()方法。

java.lang.NullPointerException

异常描述：空指针

解决思路：使用了一个空对象引用，建议您检查引用的对象是否为空

解决方法：这种异常通常是调用一个对象的方法抛出的，凡是调用一个对象的方法之前，一定要进行判空或者进行try-catch，这样基本可以规避大部分空指针异常。

java.lang.IllegalArgumentException

异常描述：参数不匹配异常，通常由于传递了不正确的参数导致。

解决思路：检测传入的参数

解决方法：常见于：

• Activity、Service 状态异常
• 非法URL
• UI线程操作
• Fragment中嵌套了子 Fragment，Fragment 被销毁，而内部 Fragment 未被销毁，所以导致再次加载时重复，在 onDestroyView() 中将内部 Fragment 销毁即可
• 在请求网络的回调中使用了glide.into(view),view 已经被销毁会导致该错误

android.os.DeadObjectException

异常描述：死机异常

解决思路：建议在服务终止或对象回收后把相应的引用置空，并且在所有可能用到这个对象的地方进行判空操作。该异常表示对应的服务或对象已经停止，但是却仍有对其发起调用。

解决方法：

• 数据库，蓝牙等用已调用过 close()的对象来 connect()，将会报错。
• 引用被系统回收的对象，也会报这个错误。

java.util.concurrent.TimeoutException

异常描述：该异常表示调用超时。

解决思路：一般是系统在 gc 时，调用对象的 finalize 超时导致，

解决方法：

• 检查分析 finalize 的实现为什么耗时较高，修复它。
• 检查日志查看 GC 是否过于频繁，导致超时，减少内容开销，防止内存泄露。

java.lang.ClassNotFoundException

异常描述：该异常表示在路径下，找不到指定类，通常是因为构建路径问题导致的。

解决思路：

解决方法：类名是以字符串形式标识的，可信度比较低，在调用Class.forName(“”),Class.findSystemClass(“”),Class.loadClass(“”)等方法时，找不到类名时将会报错。如果找不到的 Class 是系统 Class，那么可能是系统版本兼容，厂家 Rom 兼容的问题，找到对应的设备尝试重现，解决方法可以考虑更换Api，或用自己实现的 Class替代。如果找不到的 Class 是应用自由 Class（含第三方SDK的 Class），可以通过反编译工具查看对应 apk 中是否真的缺少该 Class，再进行定位，这种往往发生在：

• 要找的 Class 被混淆了，存在但名字变了。
• 要找的 Class 未被打入 Dex，确实不存在，可能是因为自己的疏忽，或编译环境的冲突。
• 要找的 Class 确实存在，但你的 Classlorder 找不到这个 Class，往往因为这个 Classloder 是你自实现的（插件化应用中常见）。

java.lang.SecurityException

异常描述：权限异常

解决思路：检查权限

解决方法：权限异常或者称为安全异常，由安全管理器抛出，用于指示违反安全情况的异常，通常由于没有获取对应的权限。

• android 6.0 以下需要在 manifest 中声明相应的权限。
• android 6.0 及以上，在使用时需要动态申请权限。

java.lang.OutOfMemoryError

异常描述：该异常表示未能成功分配字节内存，通常是因为内存不足导致的内存溢出。

解决思路：

解决方法：OOM 就是内存溢出，即 Out of Memory。也就是说内存占有量超过了 VM 所分配的最大。怎么解决 OOM，通常 OOM 都发生在需要用到大量内存的情况下（创建或解析 Bitmap，分配特大的数组等），这里列举常见避免 OOM 的几个注意点：

• 适当调整图像大小。
• 采用合适的缓存策略。
• 采用低内存占用量的编码方式，比如 Bitmap.Config.ARGB_4444 比 Bitmap.Config.ARGB_8888 更省内存。
• 及时回收 Bitmap。
• 不要在循环中创建过多的本地变量。
• 自定义对内存分配大小。
• 特殊情况可在 mainfests 的 Application 中增加 android:largeHeap=”true” 属性，比如临时创建多个小图片(地图 marker )

android.os.FileUriExposedException

异常描述：文件 Uri 暴露异常

解决思路：

• 首先我们对 Android N及以上做判断.
• 然后添加 flags，表明我们要被授予什么样的临时权限.
• BuildConfig.APPLICATION_ID 直接获取的是应用的包名.

解决方法：对于面向 Android N (7.x) 的应用，Android 框架执行的 StrictMode API 政策禁止向您的应用外公开 file://URI。 如果一项包含文件 URI 的 Intent 离开您的应用，应用失败，并出现 FileUriExposedException 异常。若要在应用间共享文件，您应发送一项 content://URI，并授予 URI 临时访问权限。 进行此授权的最简单方式是使用 FileProvider 类。参考

算法排序

java 实现冒泡排序，选择排序，插入排序，快速排序（简洁版）及性能测试

冒泡排序是排序里面最简单的了，但性能也最差，数量小的时候还可以，数量一多，是非常慢的它的时间复杂度是O（n*n），空间复杂度是O（1）

// 冒泡排序:
public void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        // 找出最小要 arr.length - 1 - i 次
        for (int j = arr.length - 1; j > i; j--) {
            if (arr[j - 1] > arr[j]) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

选择排序的时间复杂度还有空间复杂度跟冒泡是一样的。

 // 选择排序：
public void chooseSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

插入排序的时间复杂度也是O(n*n)，空间复杂度也是O(1)

 // 插入排序：
public void insertSort(int[] arr) {
    for (int j = 1; j < arr.length; j++) {
        for (int i = 0; i < j; i++) {
            if (arr[i] > arr[j]) {
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

快速排序通常情况下是最快的，名不虚传啊~平均时间复杂度是 O(Nlog2N)，最差也是O(N*N)，空间复杂度O(Nlog2N)

 // 快速排序
public void quickSort(int[] arr, int head, int tail) {
    int i = head;
    int j = tail;
    if (i > j) {
        return;
    }
    int key = arr[i];
    while (i < j) {
        while (i < j && key <= arr[j]) {
            j--;
        }
        if (i < j) {
            arr[i++] = arr[j];
        }
        while (i < j && key >= arr[i]) {
            i++;
        }
        if (i < j) {
            arr[j--] = arr[i];
        }
    }
    arr[j] = key;
    quickSort(arr, head, j - 1);
    quickSort(arr, j + 1, tail);
} 

测试

@Test
public void TestSort() {
    int[] arr1 = new int[6000];
    for (int i = 0; i < arr1.length; i++) {
        arr1[i] = new Random().nextInt(6000) + 1;
    }
    int[] arr2 = new int[6000];
    for (int i = 0; i < arr2.length; i++) {
        arr2[i] = new Random().nextInt(6000) + 1;
    }
    int[] arr3 = new int[6000];
    for (int i = 0; i < arr3.length; i++) {
        arr3[i] = new Random().nextInt(6000) + 1;
    }
    int[] arr4 = new int[6000];
    for (int i = 0; i < arr4.length; i++) {
        arr4[i] = new Random().nextInt(6000) + 1;
    }
    long m = System.currentTimeMillis();
    bubbleSort(arr1);
    long n = System.currentTimeMillis();
    System.out.println("冒泡排序耗时：" + (n - m) + "ms");

    long p = System.currentTimeMillis();
    int[] arr6 = {77,43,56,78};
    chooseSort(arr2);
    long q = System.currentTimeMillis();
    System.out.println("选择排序耗时：" + (q - p) + "ms");

    long e = System.currentTimeMillis();
    insertSort(arr3);
    long d = System.currentTimeMillis();
    System.out.println("插入排序耗时：" + (d - e) + "ms");

    long a = System.currentTimeMillis();
    quickSort(arr4, 0, arr4.length - 1);
    long b = System.currentTimeMillis();
    System.out.println("快速排序耗时：" + (b - a) + "ms");
}

冒泡排序耗时：106ms
选择排序耗时：107ms
插入排序耗时：47ms
快速排序耗时：2ms