通达信zig方法的java实现

package util;

import com.alibaba.fastjson.JSONObject;
import main.original.YGFutureTechIndexKline;
import main.talib.YGFutureTechIndexTaLibSMA;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class YGFutureMaiToJava {
   /*
        首先从您第一根K线算起，看每根K线的最高价，和第一根K线的最高价相比是不是涨幅超过10%
    （这里假设第一根K线的最高价位置比较低，位置高的画线原理是一样的），把第一次涨幅超过10%
    的这个点成为上拐点，然后K线继续往后走，出现了一个最高点，然后开始下跌了，这个最高点我们记为A，
    然后K线往后走的跌幅是否超过10%，把第一次跌幅超过10%的K线记为下拐点，如果这个下拐点成立了，
    那么之前的A的这个位置就发生一次转向，就是我们看到的折线，如下图，最低点位置开始，上面一条横线就是上拐点位置，
    然后出现了最高点，再往下走，出现了下拐点，那么证明最高点处应该转折，之后都是按照这个原理画的。
    zig函数产生的连线是连接的最大值和最小值
    */
    //参数1周期长度，参数2百分比
    public static List<Double> getZigZag(List<Double> numbers, Double percentage){
        //     循环前的变量初始化
        //     端点 候选点 扫描点 端点列表 拐点线列表 趋势状态
        int ZIG_STATE_START = 0;
        int ZIG_STATE_RISE = 1;
        int ZIG_STATE_FALL = 2;
        int peer_i = 0;
        Integer candidate_i = 0;
        int scan_i = 0;
        List<Integer> peers = new ArrayList<>();
        List<Double> ziglst = new ArrayList<>();
        int state = ZIG_STATE_START;
        percentage = percentage/100;
        
        if(numbers.size()<2){
            return null;
        }
        while (true) {
            scan_i += 1;
            if (scan_i == numbers.size() - 1) {
                // 扫描到尾部
                if (candidate_i == null) {
                    peer_i = scan_i;
                    peers.add(peer_i);
                } else {
                    if (state == ZIG_STATE_RISE) {
                        if (numbers.get(scan_i) >= numbers.get(candidate_i)) {
                            peer_i = scan_i;
                            peers.add(peer_i);
                        } else {
                            peer_i = candidate_i;
                            peers.add(peer_i);
                            peer_i = scan_i;
                            peers.add(peer_i);
                        }
                    } else if (state == ZIG_STATE_FALL) {
                        if (numbers.get(scan_i) <= numbers.get(candidate_i)) {
                            peer_i = scan_i;
                            peers.add(peer_i);
                        } else {
                            peer_i = candidate_i;
                            peers.add(peer_i);
                            peer_i = scan_i;
                            peers.add(peer_i);
                        }
                    }
                }
                break;
            }

            ///
            if (state == ZIG_STATE_START) {
                if (numbers.get(scan_i) >= numbers.get(peer_i) * (1 + percentage)) {
                    candidate_i = scan_i;
                    state = ZIG_STATE_RISE;
                } else if (numbers.get(scan_i) <= numbers.get(peer_i) * (1 - percentage)) {
                    candidate_i = scan_i;
                    state = ZIG_STATE_FALL;
                }
                peers.add(peer_i);
            } else if (state == ZIG_STATE_RISE) {
                if (numbers.get(scan_i) >= numbers.get(candidate_i)) {
                    candidate_i = scan_i;
                } else if (numbers.get(scan_i) <= numbers.get(candidate_i) * (1 - percentage)) {
                    peer_i = candidate_i;
                    peers.add(peer_i);
                    state = ZIG_STATE_FALL;
                    candidate_i = scan_i;
                }
            } else if (state == ZIG_STATE_FALL) {
                if (numbers.get(scan_i) <= numbers.get(candidate_i)) {
                    candidate_i = scan_i;
                } else if (numbers.get(scan_i) >= numbers.get(candidate_i) * (1 + percentage)) {
                    peer_i = candidate_i;
                    peers.add(peer_i);
                    state = ZIG_STATE_RISE;
                    candidate_i = scan_i;
                }
            }
        }

        //线性插值， 计算出zig的值
        for(int i=1;i<peers.size();i++){

            int  peer_start_i = peers.get(i-1);
            int peer_end_i = peers.get(i);
            Double start_value = numbers.get(peer_start_i);
            Double end_value = numbers.get(peer_end_i);
            Double a = (end_value - start_value)/(peer_end_i - peer_start_i);// 斜率

            if(peer_start_i == 0){
                for(int j=0;j<(peer_end_i - peer_start_i +1);j++){
                    ziglst.add(start_value + a*j);
                }
            }else {
                for(int j=1;j<(peer_end_i - peer_start_i +1);j++){
                    ziglst.add(start_value + a*j);
                }
            }
        }
        return ziglst;
    }

    //本方法中troughPositionlst存储所有波谷的位置，peakPositionlst存储所有波峰的位置
    public static  List<Integer> getTROUGHBARS(List<Double> numbers, Double percentage) {
        int ZIG_STATE_START = 0;
        int ZIG_STATE_RISE = 1;
        int ZIG_STATE_FALL = 2;
        int state = ZIG_STATE_START;
        List<Double> troughBarslst = getZigZag(numbers, percentage);
        List<Integer> troughPositionlst = new ArrayList<>();
        List<Integer> peakPositionlst = new ArrayList<>();

        if (troughBarslst != null && troughBarslst.size() > 0) {
            for (int i = 1; i < troughBarslst.size(); i++) {
                if (i == troughBarslst.size() - 1) {
                    // 扫描到尾部
                    if (state == ZIG_STATE_RISE) {
                        if (troughBarslst.get(i) <= troughBarslst.get(i - 1)) {
                            troughPositionlst.add(i);
                            peakPositionlst.add(i - 1);
                        }
                    }
                     else if (state == ZIG_STATE_FALL) {
                            if (troughBarslst.get(i) >= troughBarslst.get(i - 1)) {
                                troughPositionlst.add(i - 1);
                                peakPositionlst.add(i);
                            }
                     }


                    break;
                }
   ///
                    if (state == ZIG_STATE_START) {
                        if (troughBarslst.get(i) >= troughBarslst.get(i - 1)) {
                            state = ZIG_STATE_RISE;
                            troughPositionlst.add(i - 1);
                        } else if (troughBarslst.get(i) <= troughBarslst.get(i - 1)) {
                            state = ZIG_STATE_FALL;
                            peakPositionlst.add(i - 1);
                        }
                    } else if (state == ZIG_STATE_RISE) {
                        if (troughBarslst.get(i) <= troughBarslst.get(i - 1)) {
                            state = ZIG_STATE_FALL;
                            peakPositionlst.add(i - 1);
                        }
                    } else if (state == ZIG_STATE_FALL) {
                        if (troughBarslst.get(i) >= troughBarslst.get(i - 1)) {
                            state = ZIG_STATE_RISE;
                            troughPositionlst.add(i - 1);
                        }
                    }
                }
            }
        else {
                return null;
        }
        return troughPositionlst;

    }
}