java程序雨流计数法代码

下面是一个使用Java编写的雨流计数法程序示例：

import java.util.ArrayList;
import java.util.List;

public class RainflowCounting {

    public static void main(String[] args) {
        double[] loadHistory = {1, 2, 3, 4, 3, 2, 1, 0, -1, -2, -3, -4, -3, -2, -1, 0, 1, 2, 3, 4};
        List<LoadCycle> cycles = rainflowCounting(loadHistory);
        for (LoadCycle cycle : cycles) {
            System.out.println(cycle);
        }
    }

    public static List<LoadCycle> rainflowCounting(double[] loadHistory) {
        List<LoadCycle> cycles = new ArrayList<>();
        int i = 0;
        int j = 0;
        int n = loadHistory.length;
        double range;
        double mean;
        double upCrossing;
        double downCrossing;
        double upCrossingValue = loadHistory[0];
        double downCrossingValue = loadHistory[0];

        while (j < n - 1) {
            j++;
            if (loadHistory[j] > upCrossingValue) {
                upCrossingValue = loadHistory[j];
            }
            if (loadHistory[j] < downCrossingValue) {
                downCrossingValue = loadHistory[j];
            }
            if (j == n - 1) {
                range = upCrossingValue - downCrossingValue;
                mean = (upCrossingValue + downCrossingValue) / 2;
                cycles.add(new LoadCycle(range, mean));
            } else if (loadHistory[j] >= loadHistory[j - 1]) {
                continue;
            } else {
                range = upCrossingValue - downCrossingValue;
                mean = (upCrossingValue + downCrossingValue) / 2;
                cycles.add(new LoadCycle(range, mean));
                upCrossing = loadHistory[j - 1];
                downCrossing = loadHistory[j];
                i = j;
                upCrossingValue = loadHistory[j - 1];
                downCrossingValue = loadHistory[j];
                while (i > 0) {
                    i--;
                    if (loadHistory[i] > upCrossing) {
                        upCrossing = loadHistory[i];
                    }
                    if (loadHistory[i] < downCrossing) {
                        downCrossing = loadHistory[i];
                    }
                    if (i == 0 || loadHistory[i] <= loadHistory[i - 1]) {
                        range = upCrossing - downCrossing;
                        mean = (upCrossing + downCrossing) / 2;
                        cycles.add(new LoadCycle(range, mean));
                        upCrossingValue = upCrossing;
                        downCrossingValue = downCrossing;
                        break;
                    }
                }
            }
        }
        return cycles;
    }

    static class LoadCycle {
        double range;
        double mean;

        public LoadCycle(double range, double mean) {
            this.range = range;
            this.mean = mean;
        }

        @Override
        public String toString() {
            return "LoadCycle{" +
                    "range=" + range +
                    ", mean=" + mean +
                    '}';
        }
    }
}

该程序使用一个`rainflowCounting`方法来执行雨流计数法计算载荷，并返回一个`LoadCycle`对象列表，其中每个对象包含一个峰-谷对的振幅和平均值。在`main`方法中，我们定义了一个载荷历程数组，并将其传递给`rainflowCounting`方法，然后输出计算结果。

注意，该示例程序仅供参考，实际应用中需要根据具体的需求进行修改和扩展。