Administrator
7 days ago 084bb8457b44f765b32365cb09f613ea871634dc
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/**
 * 指标计算工具类
 * 封装MACD策略中常用的通用功能,如高低点查找等
 */
package com.xcong.excoin.modules.okxNewPrice.indicator.macdAndMatrategy;
 
import java.math.BigDecimal;
import java.util.List;
 
/**
 * 指标计算工具类,提供MACD策略中常用的通用功能
 */
public class IndicatorUtils {
 
    /**
     * 找到最近的价格高点索引
     *
     * @param prices 价格列表
     * @param startIdx 起始索引
     * @return 最近的价格高点索引
     */
    public static int findRecentHighIndex(List<BigDecimal> prices, int startIdx) {
        if (prices == null || startIdx < 0 || startIdx >= prices.size()) {
            return -1;
        }
        
        int highIdx = startIdx;
        BigDecimal highPrice = prices.get(startIdx);
        
        for (int i = startIdx + 1; i < prices.size(); i++) {
            BigDecimal currentPrice = prices.get(i);
            if (currentPrice.compareTo(highPrice) > 0) {
                highPrice = currentPrice;
                highIdx = i;
            }
        }
        
        return highIdx;
    }
 
    /**
     * 找到最近的价格低点索引
     *
     * @param prices 价格列表
     * @param startIdx 起始索引
     * @return 最近的价格低点索引
     */
    public static int findRecentLowIndex(List<BigDecimal> prices, int startIdx) {
        if (prices == null || startIdx < 0 || startIdx >= prices.size()) {
            return -1;
        }
        
        int lowIdx = startIdx;
        BigDecimal lowPrice = prices.get(startIdx);
        
        for (int i = startIdx + 1; i < prices.size(); i++) {
            BigDecimal currentPrice = prices.get(i);
            if (currentPrice.compareTo(lowPrice) < 0) {
                lowPrice = currentPrice;
                lowIdx = i;
            }
        }
        
        return lowIdx;
    }
 
    /**
     * 找到最近价格高点之前的价格高点索引
     *
     * @param prices 价格列表
     * @param startIdx 起始索引
     * @param recentHighIdx 最近的价格高点索引
     * @return 之前的价格高点索引
     */
    public static int findPreviousHighIndex(List<BigDecimal> prices, int startIdx, int recentHighIdx) {
        if (prices == null || startIdx < 0 || recentHighIdx <= startIdx || recentHighIdx >= prices.size()) {
            return -1;
        }
        
        int highIdx = startIdx;
        BigDecimal highPrice = prices.get(startIdx);
        
        for (int i = startIdx + 1; i < recentHighIdx; i++) {
            BigDecimal currentPrice = prices.get(i);
            if (currentPrice.compareTo(highPrice) > 0) {
                highPrice = currentPrice;
                highIdx = i;
            }
        }
        
        return highIdx;
    }
 
    /**
     * 找到最近价格低点之前的价格低点索引
     *
     * @param prices 价格列表
     * @param startIdx 起始索引
     * @param recentLowIdx 最近的价格低点索引
     * @return 之前的价格低点索引
     */
    public static int findPreviousLowIndex(List<BigDecimal> prices, int startIdx, int recentLowIdx) {
        if (prices == null || startIdx < 0 || recentLowIdx <= startIdx || recentLowIdx >= prices.size()) {
            return -1;
        }
        
        int lowIdx = startIdx;
        BigDecimal lowPrice = prices.get(startIdx);
        
        for (int i = startIdx + 1; i < recentLowIdx; i++) {
            BigDecimal currentPrice = prices.get(i);
            if (currentPrice.compareTo(lowPrice) < 0) {
                lowPrice = currentPrice;
                lowIdx = i;
            }
        }
        
        return lowIdx;
    }
 
    /**
     * 寻找最近的价格高点(带有回调确认)
     *
     * @param prices 价格列表
     * @param startIndex 起始索引
     * @param endIndex 结束索引
     * @return 符合条件的价格高点索引,未找到则返回-1
     */
    public static int findRecentHighWithRetrace(List<BigDecimal> prices, int startIndex, int endIndex) {
        if (prices == null || startIndex < 0 || endIndex >= prices.size() || startIndex >= endIndex) {
            return -1;
        }
 
        int highIndex = -1;
        BigDecimal highPrice = BigDecimal.ZERO;
 
        // 从右向左搜索,找到第一个有效高点
        for (int i = endIndex; i >= startIndex; i--) {
            if (prices.get(i).compareTo(highPrice) > 0) {
                highPrice = prices.get(i);
                highIndex = i;
            }
 
            // 检查高点后是否有回调
            if (highIndex != -1 && i < endIndex) {
                if (prices.get(i + 1).compareTo(highPrice) < 0) {
                    return highIndex; // 找到确认回调的高点
                }
            }
        }
 
        return highIndex;
    }
}