之前集成OpenCV是通过NDK的方式，需要自己编译出so库，这是一种很低效的集成方式，很多时候需要自己写JNI的代码，不是一个很好的选择，而通过open CV官方的jar就可以引入很多种常用的API，下面来说说这种方式

首先需要先下载一个OpenCV的Android开发SDK：
![mark](https://img.zouchanglin.cn///20200202/nozycNcpzEbp.png)



![mark](https://img.zouchanglin.cn///20200202/sdEd51m63tQ5.png)



新建一个空项目，然后Android Studio菜单-->File-->New-->Import Module

1、选择刚刚的sdk文件夹下的java文件夹；  
2、Module name: Android studio会自动填充这项为openCVLibrary340 ，不用管它；  
3、点击下一步，会出现三个复选框，都选上，点击Finish。

如果在集成过程中出现
```
ERROR: Failed to install the following Android SDK packages as some licences have not been accepted.
   build-tools;28.0.3 Android SDK Build-Tools 28.0.3
   platforms;android-14 Android SDK Platform 14
To build this project, accept the SDK license agreements and install the missing components using the Android Studio SDK Manager.
Alternatively, to transfer the license agreements from one workstation to another, see http://d.android.com/r/studio-ui/export-licenses.html

Using Android SDK: D:\develop\AndroidSDK
Install missing SDK package(s)
```
直接点击Install missing SDK package(s)下载即可

![mark](https://img.zouchanglin.cn///20200202/N4Mc2G7o4xcB.png)

接着，需要把Module的几个编译参数改成和工程一致即可：
![mark](https://img.zouchanglin.cn///20200202/Hux8hQ699hRB.png)

此时需要在app/src/main下新建文件夹jniLibs，把下载的OpenCV-android-sdk的sdk/native/libs下的所有文件拷贝到jniLibs下

Android快速集成OpenCV

## 一、什么是HashMap
HashMap肯定是一个Java开发者经常用到的一个容器，不妨吧HashMap看成是Hash + Map

Hash：散列讲一个任意的长度通过某种算法（哈希算法）转换为一个固定值
Map：这个Map被翻译过来是地图，地图是一种很明显的K-V模型，地图上的每一个点对应真实存在的某一个地方，所以我认为是一种K-V模型

好了两个概念合二为一即是：把一个东西通过哈希算法找到对应的位置，并把它存储到这个位置！



## 二、HashMap源码分析

下面的部分是转载自[IT小猛男](https://www.cnblogs.com/little-fly/p/7344285.html)


在JDK1.6，JDK1.7中，HashMap采用位桶+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。

而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值 8 时，将链表转换为红黑树，这样大大减少了查找时间。

**HashMap的实现原理**
首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率

HashMap的原理图是：
![mark](https://img.zouchanglin.cn///20200202/NH0RAAlCr7se.png)

### 1、JDK1.8中的涉及到的数据结构
①、位桶数组
```java
transient Node<k,v>[] table;//存储（位桶）的数组</k,v>
```
②、数组元素Node<K,V>实现了Entry接口
```java
//Node是单向链表，它实现了Map.Entry接口  
static class Node<k,v> implements Map.Entry<k,v> {  
    final int hash;  
    final K key;  
    V value;  
    Node<k,v> next;  
    //构造函数Hash值 键 值 下一个节点  
    Node(int hash, K key, V value, Node<k,v> next) {  
        this.hash = hash;  
        this.key = key;  
        this.value = value;  
        this.next = next;  
    }  
   
    public final K getKey()        { return key; }  
    public final V getValue()      { return value; }  
    public final String toString() { return key + = + value; }  
   
    public final int hashCode() {  
        return Objects.hashCode(key) ^ Objects.hashCode(value);  
    }  
   
    public final V setValue(V newValue) {  
        V oldValue = value;  
        value = newValue;  
        return oldValue;  
    }  
    //判断两个node是否相等,若key和value都相等，返回true。可以与自身比较为true  
    public final boolean equals(Object o) {  
        if (o == this)  
            return true;  
        if (o instanceof Map.Entry) {  
            Map.Entry e = (Map.Entry)o;  
            if (Objects.equals(key, e.getKey()) &&  
                Objects.equals(value, e.getValue()))  
                return true;  
        }  
        return false;  
    }
```
③、红黑树
```java
//红黑树  
static final class TreeNode<k,v> extends LinkedHashMap.Entry<k,v> {  
    TreeNode<k,v> parent;  // 父节点  
    TreeNode<k,v> left; //左子树  
    TreeNode<k,v> right;//右子树  
    TreeNode<k,v> prev;//needed to unlink next upon deletion  
    boolean red;    //颜色属性  
    TreeNode(int hash, K key, V val, Node<k,v> next) {  
        super(hash, key, val, next);  
    }  
   
    //返回当前节点的根节点  
    final TreeNode<k,v> root() {  
        for (TreeNode<k,v> r = this, p;;) {  
            if ((p = r.parent) == null)  
                return r;  
            r = p;  
        }  
    }
```
### 2、源码中的数据域
**加载因子（默认0.75）：为什么需要使用加载因子，为什么需要扩容呢**？**因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率**

HashMap本来是以空间换时间，所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存，填充比可以稍大，如果主要关注查找性能，填充比可以稍小。
```java
public class HashMap<k,v> extends AbstractMap<k,v> implements Map<k,v>, Cloneable, Serializable {  
    private static final long serialVersionUID = 362498820763181265L;  
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16  
    static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量  
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//填充比  
    //当add一个元素到某个位桶，其链表长度达到8时将链表转换为红黑树  
    static final int TREEIFY_THRESHOLD = 8;  
    static final int UNTREEIFY_THRESHOLD = 6;  
    static final int MIN_TREEIFY_CAPACITY = 64;  
    transient Node<k,v>[] table;//存储元素的数组  
    transient Set<map.entry<k,v>> entrySet;  
    transient int size;//存放元素的个数  
    transient int modCount;//被修改的次数fast-fail机制  
    int threshold;//临界值 当实际大小(容量*填充比)超过临界值时，会进行扩容   
    final float loadFactor;//填充比（......后面略）  
}
```
### 3、HashMap的构造函数
HashMap的构造方法有4种，主要涉及到的参数有，指定初始容量，指定填充比和用来初始化的Map

```java
//构造函数1  
public HashMap(int initialCapacity, float loadFactor) {  
    //指定的初始容量非负  
    if (initialCapacity < 0)  
        throw new IllegalArgumentException(Illegal initial capacity:  +  
                                           initialCapacity);  
    //如果指定的初始容量大于最大容量,置为最大容量  
    if (initialCapacity > MAXIMUM_CAPACITY)  
        initialCapacity = MAXIMUM_CAPACITY;  
    //填充比为正  
    if (loadFactor <= 0 || Float.isNaN(loadFactor))  
        throw new IllegalArgumentException(Illegal load factor:  +  
                                           loadFactor);  
    this.loadFactor = loadFactor;  
    this.threshold = tableSizeFor(initialCapacity);//新的扩容临界值  
}  
   
//构造函数2  
public HashMap(int initialCapacity) {  
    this(initialCapacity, DEFAULT_LOAD_FACTOR);  
}  
   
//构造函数3  
public HashMap() {  
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted  
}  
   
//构造函数4用m的元素初始化散列映射  
public HashMap(Map m) {  
    this.loadFactor = DEFAULT_LOAD_FACTOR;  
    putMapEntries(m, false);  
}
```
### 4、HashMap的存取机制
①、HashMap如何getValue值，看源码
```java
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab;//Entry对象数组
    Node<K,V> first,e; //在tab数组中经过散列的第一个位置
    int n;
    K k;
    //找到插入的第一个Node，方法是hash值和n-1相与，tab[(n - 1) & hash]
    //也就是说在一条链上的hash值相同的
    if ((tab = table) != null && (n = tab.length) > 0
            &&(first = tab[(n - 1) & hash]) != null) {
        //检查第一个Node是不是要找的Node
        if (first.hash == hash &&
            ((k = first.key) == key || (key != null && key.equals(k))))
            //判断条件是hash值要相同，key值要相同
            return first;
        //检查first后面的node
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            //遍历后面的链表，找到key值和hash值都相同的Node
            do {
                if (e.hash == hash && 
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}
```
get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等，不等就遍历后面的链表找到相同的key值返回对应的Value值即可

**②、HashMap如何put(key，value);看源码**
```java
public V put(K key, V value) {
    return putVal(hash(key), key, 
            value, false, true);
}

final V putVal(int hash, K key, V value, 
               boolean onlyIfAbsent, boolean evict) {
    //很显然 tab是节点数组 p是节点临时变量 n是数组长度
    HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
    //初始化表
    if ((tab = table) == null || (n = tab.length) == 0) 
        n = (tab = resize()).length;
    //(n - 1) & hash 确保最大值为15，从而不会越界，
    //同样数组大小设定为2的n次幂就是为了这个n-1
    //2的n次幂-1，二进制都是1，这样进行与操作的时候可以保证最大散列度，
    //否则二进制中会含有0会降低散列程度
    if ((p = tab[i = (n - 1) & hash]) == null)
        //如果table的在（n-1）&hash的值是空，就新建一个节点插入在该位置
        tab[i] = newNode(hash, key, value, null);
        //表示有冲突,开始处理冲突
    else {
        Node<K,V> e;
        K k;
        //检查第一个Node，p是不是要找的值
        if (p.hash == hash &&((k = p.key) == key 
                || (key != null && key.equals(k)))) 
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                //指针为空就挂在后面
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //如果冲突的节点数已经达到8个，看是否需要改变冲突节点的存储结构，　　　　　　　　　　　　　  
                    //treeifyBin首先判断当前hashMap的长度，如果不足64，只进行  
                    //resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树  
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st  
                        treeifyBin(tab, hash);
                    break;
                }
                //如果有相同的key值就结束遍历
                if (e.hash == hash &&((k = e.key) == key 
                        || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //就是链表上有相同的key值
        if (e != null) { // existing mapping for key，就是key的Value存在  
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;//返回存在的Value值  
        }
    }
    ++modCount;
    //如果当前大小大于门限，门限原本是初始容量*0.75
    if (++size > threshold)
        resize();//扩容两倍  
    afterNodeInsertion(evict);
    return null;
}
```
下面简单说下添加键值对put(key,value)的过程：  
1、判断键值对数组tab[]是否为空或为null，否则以默认大小resize()；  
2、根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加，否则转入3  
3、判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理

### 5、HasMap的扩容机制resize()
**构造hash表时，如果不指明初始大小，默认大小为16（即Node数组大小16），如果Node[]数组中的元素达到（填充比*Node.length）重新调整HashMap大小 变为原来2倍大小,**扩容很耗时。

```java
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;

    //如果旧表的长度不是空
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //把新表的长度设置为旧表长度的两倍，newCap=2*oldCap
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
            //把新表的门限设置为旧表门限的两倍，newThr=oldThr*2
            newThr = oldThr << 1; // double threshold  
    }
    //如果旧表的长度的是0，就是说第一次初始化表
    else if (oldThr > 0) 
        // initial capacity was placed in threshold  
        newCap = oldThr;
    else {               
        // zero initial threshold signifies using defaults  
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }

    if (newThr == 0) {
        //新表长度乘以加载因子
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    //下面开始构造新表，初始化表中的数据
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    //把新表赋值给table
    table = newTab;
    //原表不是空要把原表中数据移动到新表中
    if (oldTab != null) {      
        //遍历原来的旧表
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    //说明这个node没有链表直接放在新表的e.hash & (newCap - 1)位置
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //如果e后边有链表,到这里表示e后面带着个单链表，需要遍历单链表，将每个结点重
                else { 
                    // preserve order保证顺序
                    //新计算在新表的位置，并进行搬运  
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;

                    do {
                        next = e.next;//记录下一个结点  
                        //新表是旧表的两倍容量，实例上就把单链表拆分为两队，  
                        //e.hash&oldCap为偶数一队，e.hash&oldCap为奇数一对  
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);

                    //lo队不为null，放在新表原位置
                    if (loTail != null) {  
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    //hi队不为null，放在新表j+oldCap位置
                    if (hiTail != null) {  
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}
```
### 6、JDK1.8使用红黑树的改进
在[Java ](http://lib.csdn.net/base/java)jdk8中对HashMap的源码进行了优化，在jdk7中，HashMap处理“碰撞”的时候，都是采用链表来存储，当碰撞的结点很多时，查询时间是O（n）。  
在jdk8中，**HashMap处理“碰撞”增加了红黑树这种数据结构，当碰撞结点较少时，采用链表存储，当较大时（>8个），采用红黑树（特点是查询时间是O（logn））存储（有一个阀值控制，大于阀值(8个)，将链表存储转换成红黑树存储）**
![mark](https://img.zouchanglin.cn///20200202/LCbl484zwENj.png)

### 7、问题分析

你可能还知道哈希碰撞会对hashMap的性能带来灾难性的影响。如果多个hashCode()的值落到同一个桶内的时候，这些值是存储到一个链表中的。最坏的情况下，所有的key都映射到同一个桶中，这样hashmap就退化成了一个链表——查找时间从O(1)到O(n)。

随着HashMap的大小的增长，get()方法的开销也越来越大。由于所有的记录都在同一个桶里的超长链表内，平均查询一条记录就需要遍历一半的列表。

**JDK1.8HashMap的红黑树是这样解决的**：

 **如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。**

 它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，**使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入**。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。

哈希函数
高16位与低16位做异或运算
```java
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
```

深入理解HashMap

**K**nuth-**M**orris-**P**ratt 字符串查找算法，简称为 **KMP算法**，KMP是我们经常听到的一种字符串匹配算法。KMP算法听起来很难，但是如果真正明白它的匹配过程其实不难，接下来看看KMP究竟是如何匹配字符串的？

假设现在有如图所示两个字符串， 图表所列的是匹配串的所有子串，这个不难理解
![mark](https://img.zouchanglin.cn///20200202/2kqJpJf5FvHj.png)



两个概念：前缀和后缀
**前缀** 指除了最后一个字符以外，一个字符串的全部头部组合；
**后缀** 指除了第一个字符以外，一个字符串的全部尾部组合。


比如对于第三行和第五行
![mark](https://img.zouchanglin.cn///20200202/x5X3JWA4NECH.png)

求出每一个子串中前缀和后缀相等的部分的最大长度，比如第5行求出来最大长度为2
![mark](https://img.zouchanglin.cn///20200202/XprVBEQILQuY.png)
求得原匹配串的所有子串对应的各个前缀后缀的公共元素的最大长度表：
![mark](https://img.zouchanglin.cn///20200202/CfKt0m7XEPsN.png)

接下来需要一个next数组相当于`最大长度值`数组整体向右移动一位，然后把0号位置赋为`-1`，多出来的一位已经用不着了，直接划掉。
![mark](https://img.zouchanglin.cn///20200202/W14IM8X7W1Ra.png)

接下来开始匹配
![mark](https://img.zouchanglin.cn///20200202/bUTr1Kaq7nbV.png)

![mark](https://img.zouchanglin.cn///20200202/sVwBHBtJciDh.png)
如果字母匹配直接都朝着右边走，如果不匹配就需要把子串索引为0的元素移动到不匹配的位置，其他的元素移动同样的距离，如下图所示：
![mark](https://img.zouchanglin.cn///20200202/XmbnHHlbVe48.png)

现在不匹配的位置是next=-1，所以需要把匹配串中索引为-1的元素移动至不匹配的位置，其他元素移动同样的长度
![mark](https://img.zouchanglin.cn///20200202/25fWWD5JVNM6.png)
现在匹配到5号位置如图所示发生了对应字母不一致，此时next数组对应值为2，所以匹配串中的索引为2的应该移动至发生对比不一致的地方：
![mark](https://img.zouchanglin.cn///20200202/oRTuMzLGcuMx.png)

这样便可以一直对比下去，由此可见KMP的高效匹配原来是这样完成的！
![mark](https://img.zouchanglin.cn///20200202/BnsYJrRTQyFK.png)

所以对KMP算法总结如下几点：
1、先求出匹配串所有子串
2、求每一个子串中前缀和后缀相等的部分的最大长度
3、这样便求出了next数组，以-1开头的next数组是更容易理解的方式
4、有了next数组剩下的就是匹配了，匹配时注意遇到不一样的字母时先看next数组对应值，此值就是匹配串索引处应该向不匹配位置挪动的字母索引，简单说就是：匹配串中的那个字母应该挪动到不匹配处由next数组决定

KMP其实也没那么难

说实话，我的写作平台换过好几次。最开始我的写作平台是CSDN，后台由于CSDN的种种行为，随便列几条大家感受感受，足以令人感觉这是个散发着恶臭的垃圾堆，又时看到一些早期的大佬在CSDN上发表的文章，真的非常精彩（有种在垃圾堆里捡黄金的感觉），不过我还是尽量订阅RSS的方式去访问他们自己的站点。



1、广告总是在显眼位置出现，左边栏、右边栏全都是，节假日顶部都是广告；

2、评论区摸鱼党、流量党、反正就是刷积分呗；

3、图床崩溃，CSDN上的博客图片和样式绝对不敢保证一直存在，反正我经历过几次图片被删除；

4、相互抄袭，一篇文章总能在CSDN找到几个不同的出处，竟然还都是原创，NB；

5、下载区恶心，下载区都是些什么垃圾内容，恐怕只有大学生抄作业才去买积分下载那些东西了；

6、烦人的审核机制，改个文章中的代码居然审核不通过？我除了写技术博客别的都没写，居然审核失败，NB；

总体上感觉CSDN就是一个烂平台，对，烂的不能再烂那种。

后来陆续使用过一些博客园、简书、掘金等平台，感觉多多少少都令人不太满意。

后来接触到了Hexo、Hogo、Wordpress、VuePress等写作平台，最终选择了Hexo一直沿用至今，主题几乎很少变动，因为我添加了一些自定义的内容，对主题做了部分修改。

Hexo那些对应的主题界面整洁，代码样式也好看，而且运维费用几乎没有（除非你要用CDN加速之类的），所以这种写作方式我还是一直在用！

之前由于没有好用的评论系统，所以我写一个自己站点的评论系统，但是需要后端服务器支撑，最后还是换成了 Gitalk ，数据记录在Github的issues里面。

关于本站

![mark](https://img.zouchanglin.cn///20200223/jO5uuWJR4wTG.png)

> 目前此操作方法不支持Ubuntu18.04



第一步：添加源

```bash
# 下面这个Docker的源
deb https://apt.dockerproject.org/repo ubuntu-xenial main

deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
```

版本对应关系如下：

![mark](https://img.zouchanglin.cn///20200223/0qSj8Sp7n3C4.png)

所以在写的时候这样写就好了 

Precise 12.04 (LTS)  deb https://apt.dockerproject.org/repo ubuntu-precise main

Trusty 14.04 (LTS)  deb https://apt.dockerproject.org/repo ubuntu-trusty main

Wily 15.10  deb https://apt.dockerproject.org/repo ubuntu-wily main

Xenial 16.04 (LTS)  deb https://apt.dockerproject.org/repo ubuntu-xenial main



第二步：添加秘钥   

```bash
apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
```

第三步：apt更新

```bash
apt-get update
```

第四步：查看可选的Docker版本   

```bash
apt-cache policy docker-engine
```

![mark](https://img.zouchanglin.cn///20200223/6kjEPbT3dE8K.png)

第五步：安装想要的版本的Docker   

```bash
apt install docker-engine=1.11.2-0~xenial
```

在这个网站查看支持的版本https://apt.dockerproject.org/repo/dists/