AZTEC把原始ECG数据处理成短的直线和斜线。AZTEC算法可以由水平线产生，斜线产生，用抛物线拟合的曲线平滑化几个部分组成。

压缩
1，初始化：
    一个阈值。  数据波动超过这个值得直线认为结束，进入斜线模式
    一个长度限制，  长度超过这个值的线，认为结束，重新计算
    一个最短判断限制，  长度小于这个值的最大值，最小值相差，大于阈值，认为是斜线
2，直线计算
    1，获取第一个点的高程，
    2，在往后加入的点的高程中计算出MAX 和MIN
    3，判断当前点的高程和MAX或者MIN的差是否大于阈值
    4，结束直线计算
    5，存储格式为，T，V   （T是一个正数，表示这段线有多长，V是一个值，表示这段线的高程是多少）
3，斜线计算
    1，获取第一个点的高程
    2，判断接下来小于 长度限制LEN的点的MAX和MIN相差是否大于阈值，
    3，大于阈值判断为斜线，不大于判断为直线
    4，判断当前点V0 的高程和前一个点的相差是否小于规定值，认为斜线结束
    ps，这样的好处是不用判断是正斜线，还是反斜线，
    5，存储格式为 -T ,V
    
解压缩
1，初始化当前高程是 0
2，读取一个点的数据，取得高程V
3，平均划分到每个点的值，即 V/T 是每个点的高程，余数加到最后一个点上
4，读取下一个点的数据，取得其高程V ， 
5，画每个点的公式是  h= ((V-V0)/T)*i    i == T -1 ? h + (V-V0)%T : h
6，i是当前点的下标，根据T 从0开始，V是当前点的高程，V0是前一个点的高程

public class DecodeFileUtil {
    private String fileName;

    public DecodeFileUtil(String fileName) {
        this.fileName = fileName;
    }

    public List<Float> read() {
        List<Float> decodePoints = new ArrayList<>();
        List<Map<Integer, Integer>> points = new ArrayList<>();

        List<Integer> first = new ArrayList<>();
        List<Integer> second = new ArrayList<>();
        File file = new File(fileName);
        try {
            FileReader reader = new FileReader(file);
            BufferedReader bReader = new BufferedReader(reader);
            String s;
            int i = 0;
            while ((s = bReader.readLine()) != null) {
                if (i % 2 == 0) {
                    first.add((int) Float.parseFloat(s));
                } else {
                    second.add((int) (Float.parseFloat(s)*1000));
                }
                i++;
            }
            for (int j = 0; j < first.size(); j++) {
                Map<Integer, Integer> map = new HashMap<>();
                map.put(first.get(j), second.get(j));
                points.add(map);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        for (Map<Integer, Integer> map : points) {
            int index = points.indexOf(map);
            Map<Integer, Integer> lastMap;
            int lastKey = 0;
            int lastValue = 0;
            if (index > 0) {
                lastMap = points.get(index - 1);
                lastKey = (int) lastMap.keySet().toArray()[0];
                lastValue = lastMap.get(lastKey);
            }
            int key = (int) map.keySet().toArray()[0];
            int value = map.get(key);
            if (key > 0) {
                for (int i = 0; i < key; i++) {
                    decodePoints.add(value / 1000f);
                }
            } else if (key < 0) {
                key=Math.abs(key);
                int average ;
                int remainder ;

                int result = value - lastValue;
                average = result / key;
                remainder = result % key;
                for (int i = 0; i < key; i++) {
                    if (i != key - 1) {
                        decodePoints.add((lastKey + (i + 1) * average) / 1000f);
                    } else {
                        decodePoints.add((lastKey + (i + 1) * average + remainder) / 1000f);
                    }
                }
            }
        }
        return decodePoints;
    }
}