Java方法重构：利用私有辅助方法提升代码复用性与可维护性

import java.util.Arrays;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.regex.Pattern;

// 假设 SeperatorEnum 和 numberPattern 已经定义
// enum SeperatorEnum { ... }
// Pattern numberPattern = Pattern.compile("\d+");

public class DataProcessor {
    private SeperatorEnum seperator;
    private final Pattern numberPattern = Pattern.compile("\d+"); // 示例模式

    public void findSeperator(String data) {
        Optional<String> optional = Arrays.stream(data.split(""))
                .filter(e -> !numberPattern.matcher(e).matches())
                .findFirst();
        // 假设 SeperatorEnum 有一个 getSeperator() 方法
        this.seperator = Arrays.stream(SeperatorEnum.values())
                .filter(e -> e.getSeperator().equals(optional.orElse(null)))
                .findFirst()
                .orElseThrow();
    }

    public OptionalInt maxInt(String data) {
        findSeperator(data); // 依赖 findSeperator 设置分隔符
        return Arrays.stream(data.split(seperator.getSeperator()))
                .filter(e -> numberPattern.matcher(e).matches()) // 冗余逻辑
                .mapToInt(Integer::parseInt)
                .max();
    }

    public OptionalInt minInt(String data) {
        // 这里的 findSeperator(data) 应该在调用前执行，或者在方法内部调用以确保 seperator 已设置
        // 为了演示方便，假设 maxInt 或其他方法已调用 findSeperator
        // 实际应用中，如果 minInt 独立调用，也需要确保 seperator 已初始化
        // findSeperator(data); 
        return Arrays.stream(data.split(seperator.getSeperator()))
                .filter(e -> numberPattern.matcher(e).matches()) // 冗余逻辑
                .mapToInt(Integer::parseInt)
                .min();
    }
}

// 示例 SeperatorEnum (实际应用中会有更多值)
enum SeperatorEnum {
    COMMA(","), DASH("-");

    private final String seperator;

    SeperatorEnum(String seperator) {
        this.seperator = seperator;
    }

    public String getSeperator() {
        return seperator;
    }
}

import java.util.Arrays;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.regex.Pattern;
import java.util.stream.Stream; // 引入 Stream

public class DataProcessorRefactored {
    private SeperatorEnum seperator;
    private final Pattern numberPattern = Pattern.compile("\d+");

    public void findSeperator(String data) {
        Optional<String> optional = Arrays.stream(data.split(""))
                .filter(e -> !numberPattern.matcher(e).matches())
                .findFirst();
        this.seperator = Arrays.stream(SeperatorEnum.values())
                .filter(e -> e.getSeperator().equals(optional.orElse(null)))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("Separator not found for: " + data));
    }

    public OptionalInt maxInt(String data) {
        findSeperator(data); // 确保分隔符已设置
        return basicFilter(Arrays.stream(data.split(seperator.getSeperator())))
                .mapToInt(Integer::parseInt)
                .max();
    }

    public OptionalInt minInt(String data) {
        // 如果 minInt 独立于 maxInt 调用，也需要确保 seperator 已初始化
        // 例如，可以在构造函数中初始化，或者在方法内部调用 findSeperator(data)
        // 为了保持与 maxInt 的对称性，这里假设 findSeperator 已经或将在外部调用
        return basicFilter(Arrays.stream(data.split(seperator.getSeperator())))
                .mapToInt(Integer::parseInt)
                .min();
    }

    /**
     * 私有辅助方法：对字符串流进行基本过滤，只保留符合数字模式的元素。
     * @param toFilter 待过滤的字符串流
     * @return 过滤后的字符串流
     */
    private Stream<String> basicFilter(Stream<String> toFilter) {
        return toFilter.filter(e -> numberPattern.matcher(e).matches());
    }
}

// 示例 SeperatorEnum (同上)
enum SeperatorEnum {
    COMMA(","), DASH("-");

    private final String seperator;

    SeperatorEnum(String seperator) {
        this.seperator = seperator;
    }

    public String getSeperator() {
        return seperator;
    }
}