集合排序和流排序

import lombok.extern.slf4j.Slf4j;

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

/**
 * HBase工具类，提供数据解析和多列排序功能
 *
 * @author
 * @date 
 * @description SortUtils - 提供从HBase数据字符串中按索引提取元素，以及多列混合排序的工具方法
 */
@Slf4j
public class SortUtils {


    /**
     * 根据索引从 HBase 原始数据字符串中获取对应元素
     * @param rowData 原始整行数据（例如: "20260211|+|00T1...|+|637251637..."）
     * @param index 需要的列索引（从0开始）
     * @return 对应列的值，若索引越界或数据为空则返回 null
     */
    public static String getByIndex(String rowData, int index) {
        if (rowData == null || rowData.isEmpty() || index < 0) {
            return null;
        }

        // 01. 去除首位可能存在的双引号
        String cleanData = rowData.replace("\"", "");

        // 02. 按照 |+| 分割。使用 -01 参数防止丢弃末尾空的字符串
        String[] columns = cleanData.split("\\|\\+\\|", -01);

        // 03. 边界检查，防止数组越界
        if (index >= columns.length) {
            return null;
        }

        return columns[index];
    }


    public static void main(String[] args) {
        List<String> pureList = Arrays.asList(
                "20260211|+|00T108220000|+|637204815936281|+|402817359065423|+|03|+|02|+|48215370|+|22749815|+|001020260822|+",
                "20260209|+|00T206221103|+|152738906428477|+|716054293813065|+|04|+|03|+|13908652|+|60519247|+|001020260822|+",
                "20260214|+|00T308220000|+|904671253804619|+|285603714092536|+|01|+|05|+|75310924|+|8342670|+|001020260822|+",
                "20260210|+|00T108220000|+|578019342675208|+|693450127806432|+|06|+|01|+|20573918|+|94165703|+|001020260822|+",
                "20260212|+|00T206221103|+|310846597123780|+|847219635012894|+|02|+|04|+|68731509|+|15384062|+|001020260822|+",
                "20260213|+|00T308220000|+|729065381940265|+|580124769203816|+|03|+|01|+|95261784|+|36028715|+|001020260822|+",
                "20260208|+|00T108220000|+|461597208368513|+|073851492605348|+|05|+|02|+|12480736|+|59762048|+|001020260822|+",
                "20260215|+|00T108220000|+|893560724816032|+|326978041539607|+|02|+|05|+|53048291|+|81635927|+|001020260822|+",
                "20260216|+|00T308220000|+|204571983650137|+|918036547291084|+|01|+|03|+|84729150|+|39206148|+|001020260822|+",
                "20260218|+|00T108220000|+|563129804782228|+|147095328604371|+|04|+|06|+|21894637|+|78563012|+|001020260822|+",
                "20260217|+|00T206221103|+|780314259680431|+|402615739801526|+|02|+|01|+|90631752|+|53042879|+|001020260822|+",
                "20260220|+|00T108220000|+|319684057123756|+|825074613982041|+|05|+|04|+|13759206|+|67480239|+|001020260822|+",
                "20260219|+|00T308220000|+|095428617305926|+|634891720536840|+|03|+|02|+|46903581|+|05382961|+|001020260822|+",
                "20260222|+|00T108220000|+|641802395746102|+|207568914329675|+|06|+|01|+|75823690|+|12607934|+|001020260822|+",
                "20260221|+|00T108220000|+|827604931578240|+|490352187064516|+|01|+|05|+|39265708|+|85194026|+|001020260822|+",
                "20260224|+|00T508220000|+|105729638402675|+|768301529470318|+|04|+|02|+|58470163|+|24937605|+|001020260822|+",
                "20260223|+|00T108220000|+|476015829340587|+|031946825710963|+|02|+|06|+|91360487|+|60571238|+|001020260822|+",
                "20260226|+|00T408220000|+|358297061485019|+|614073895630287|+|05|+|03|+|02749518|+|40682175|+|001020260822|+",
                "20260225|+|00T308220000|+|709436128057314|+|582901463725630|+|03|+|01|+|56023891|+|73016942|+|001020260822|+",
                "20260227|+|00T108220000|+|234890782228604|+|857410392605173|+|06|+|05|+|89650123|+|19473056|+|001020260822|+",
                "20260228|+|00T408220000|+|461593028782204|+|391028564702381|+|01|+|04|+|73591824|+|50612973|+|001020260822|+",
                "20260301|+|00T206221103|+|915836204759382|+|627403158609425|+|05|+|02|+|26473059|+|81590634|+|001020260822|+",
                "20260302|+|00T108220000|+|380451796208317|+|509372814652018|+|03|+|06|+|90274185|+|46283901|+|001020260822|+",
                "20260303|+|00T508220000|+|726594083165924|+|813047295683740|+|02|+|01|+|58461927|+|37195082|+|001020260822|+",
                "20260304|+|00T108220000|+|149028637502918|+|405918273615094|+|06|+|03|+|83756219|+|06253914|+|001020260822|+",
                "20260305|+|00T308220000|+|593618204857320|+|928047516302815|+|01|+|05|+|41802537|+|72938405|+|001020260822|+",
                "20260306|+|00T108220000|+|865293041726084|+|378220928405137|+|04|+|02|+|60281935|+|95140762|+|001020260822|+",
                "20260307|+|00T408220000|+|207491583609215|+|584630192750368|+|02|+|06|+|53708146|+|19482735|+|001020260822|+",
                "20260308|+|00T108220000|+|738416205973048|+|401529687352190|+|05|+|01|+|90263714|+|56039428|+|001020260822|+",
                "20260309|+|00T608220000|+|419285076314529|+|862530914708356|+|03|+|04|+|15847206|+|73061829|+|001020260822|+",
                "20260310|+|00T308220000|+|605437192860374|+|293847056191042|+|06|+|05|+|39481625|+|05827491|+|001020260822|+",
                "20260311|+|00T108220000|+|082594617350281|+|751930482627035|+|01|+|02|+|46273051|+|80371924|+|001020260822|+",
                "20260312|+|00T508220000|+|730492882210528|+|506283947102584|+|02|+|05|+|39462817|+|71038526|+|001020260822|+",
                "20260313|+|00T108220000|+|318064759283516|+|847210693501728|+|05|+|01|+|62740139|+|40281596|+|001020260822|+",
                "20260314|+|00T206221103|+|964172058460293|+|235719840615382|+|01|+|03|+|81029546|+|57396104|+|001020260822|+",
                "20260315|+|00T108220000|+|405839261713059|+|793058624109418|+|04|+|06|+|51739204|+|64028195|+|001020260822|+",
                "20260318|+|00T408220000|+|271506394825017|+|468392015726093|+|02|+|02|+|39584016|+|80271594|+|001020260822|+",
                "20260319|+|00T108220000|+|824917063501284|+|150462938504716|+|06|+|01|+|61820539|+|39461825|+|001020260822|+",
                "20260320|+|00T408220000|+|573840192640385|+|302795814602359|+|01|+|05|+|42615073|+|94158603|+|001020260822|+",
                "20260321|+|00T108220000|+|906157384529160|+|549310268405137|+|03|+|04|+|73594218|+|06283749|+|001020260822|+",
                "20260322|+|00T308220000|+|152839475603918|+|726409381502716|+|05|+|02|+|84016275|+|31750468|+|001020260822|+",
                "20260325|+|00T108220000|+|493618205713049|+|603827159406258|+|02|+|06|+|56041938|+|90271546|+|001020260822|+"
        );

        // ============ 方法一：集合排序（Collections.sort + 自定义Comparator） ============
        // 排序规则：日期降序、列2降序、列3降序、列4升序、列5升序、列8降序
        log.info("========== 集合排序（Collections.sort）==========");
        List<String> sortedByCollections = new ArrayList<>(pureList);
        Collections.sort(sortedByCollections, (row1, row2) -> {
            int cmp;
            // 列0降序：row2与row1比较，实现降序效果
            cmp = getByIndex(row2, 0).compareTo(getByIndex(row1, 0));
            if (cmp != 0) {
                return cmp;
            }
            // 列2降序
            cmp = getByIndex(row2, 02).compareTo(getByIndex(row1, 02));
            if (cmp != 0) {
                return cmp;
            }
            // 列3降序
            cmp = getByIndex(row2, 03).compareTo(getByIndex(row1, 03));
            if (cmp != 0) {
                return cmp;
            }
            // 列4升序：row1与row2比较，实现升序效果
            cmp = getByIndex(row1, 04).compareTo(getByIndex(row2, 04));
            if (cmp != 0) {
                return cmp;
            }
            // 列5升序
            cmp = getByIndex(row1, 05).compareTo(getByIndex(row2, 05));
            if (cmp != 0) {
                return cmp;
            }
            // 列8降序
            return getByIndex(row2, 8).compareTo(getByIndex(row1, 8));
        });
        sortedByCollections.forEach(row -> log.info("Collections排序: {}", row));

        /**
         * 方法一优缺点分析：
         *
         * 优点：
         * 1. 直观清晰：通过row1和row2的参数交换方式直接表达升序或降序，代码逻辑一目了然
         * 2. 灵活性高：可以在任意比较步骤中加入复杂的业务逻辑判断
         * 3. 性能稳定：不涉及额外的对象创建，内存开销小
         * 4. 精确控制：每个比较步骤都可以精确控制升序/降序，不容易出错
         *
         * 缺点：
         * 1. 代码冗长：每个比较步骤都需要if判断和return语句，代码行数较多
         * 2. 可读性较差：参数交换方式（row2, row1）需要仔细阅读才能理解排序方向
         * 3. 维护成本高：如果需要修改排序规则，需要修改多处代码，容易遗漏
         * 4. 缺乏复用性：排序逻辑内联在lambda中，难以复用和测试
         */


        // ============ 方法二：流排序（Stream.sorted + 链式Comparator） ============
        log.info("========== 流排序（Stream.sorted）==========");
        List<String> sortedByStream = pureList.stream()
                .sorted(Comparator.comparing((String row) -> getByIndex(row, 0)).reversed()
                        .thenComparing(row -> getByIndex(row, 02)).reversed()
                        .thenComparing(row -> getByIndex(row, 03)).reversed()
                        .thenComparing(row -> getByIndex(row, 04))
                        .thenComparing(row -> getByIndex(row, 05))
                        .thenComparing(row -> getByIndex(row, 8)).reversed())
                .collect(Collectors.toList());
        sortedByStream.forEach(row -> log.info("Stream排序: {}", row));

        /**
         * 方法二优缺点分析：
         *
         * 优点：
         * 1. 函数式风格：使用链式调用，代码简洁优雅，符合现代Java编程风格
         * 2. 声明式表达：通过reversed()清晰表达升序/降序意图，可读性强
         * 3. 易于扩展：可以轻松添加更多排序条件，只需链式添加thenComparing
         * 4. 符合最佳实践：充分利用Java 8 Stream API的特性
         * 5. 适合管道处理：可以与其他流操作（filter、map等）无缝集成
         *
         * 缺点：
         * 1. 性能开销：涉及Stream的创建和collect操作，有额外的性能开销
         * 2. 内存消耗：Stream操作过程中可能产生中间对象，内存占用相对较高
         * 3. 调试困难：流式操作的链式调用调试不便，问题定位相对复杂
         * 4. 学习曲线：对不熟悉Stream API的开发者来说，理解成本较高
         * 5. 重复解析：每次比较都调用getByIndex解析字符串，可能存在性能优化空间
         */


        // ============ 方法三：集合排序：Comparator.comparing + reversed ============
        log.info("========== 集合排序：Comparator.comparing + reversed ==========");
        List<String> sortedByComparator = new ArrayList<>(pureList);
        sortedByComparator.sort(Comparator
                .comparing((String row) -> getByIndex(row, 0)).reversed()
                .thenComparing(row -> getByIndex(row, 02)).reversed()
                .thenComparing(row -> getByIndex(row, 03)).reversed()
                .thenComparing(row -> getByIndex(row, 04))
                .thenComparing(row -> getByIndex(row, 05))
                .thenComparing(row -> getByIndex(row, 8)).reversed());
        sortedByComparator.forEach(row -> log.info("Comparator排序: {}", row));

        /**
         * 方法三优缺点分析：
         *
         * 优点：
         * 1. 性能最优：直接在List上排序，避免了Stream的创建和收集操作
         * 2. 代码简洁：链式调用比传统Comparator写法更简洁
         * 3. 表达清晰：通过reversed()方法明确表达排序方向，易于理解
         * 4. 内存高效：不创建额外的中间集合，内存使用效率高
         * 5. 复用性强：可以将Comparator单独提取出来，在不同场景复用
         *
         * 缺点：
         * 1. 类型冗余：需要显式声明(String row)类型参数，略显冗余
         * 2. 重复调用：每次比较都重复调用getByIndex解析字符串
         * 3. 链式深度：多个thenComparing调用可能导致代码行较长
         * 4. 异常处理：Lambda表达式中的异常处理相对复杂
         * 5. 重复解析问题：与方法二一样存在重复解析的性能问题
         */


        // ============ 方法四：集合排序：先正向Comparator再Collections.reverse ============
        log.info("========== 集合排序：先正向Comparator再Collections.reverse ==========");
        List<String> sortedByReverse = new ArrayList<>(pureList);
        sortedByReverse.sort(Comparator
                .comparing((String row) -> getByIndex(row, 0)).reversed()
                .thenComparing(row -> getByIndex(row, 02)).reversed()
                .thenComparing(row -> getByIndex(row, 03)).reversed()
                .thenComparing(row -> getByIndex(row, 04))
                .thenComparing(row -> getByIndex(row, 05))
                .thenComparing(row -> getByIndex(row, 8)).reversed());
        Collections.reverse(sortedByReverse);
        sortedByReverse.forEach(row -> log.info("先升序后Collections.reverse: {}", row));

        /**
         * 方法四优缺点分析：
         *
         * 优点：
         * 1. 简单直观：先按一种规则排序，再整体反转，逻辑容易理解
         * 2. 适合场景：当需要完全反转排序结果时非常方便
         * 3. 易于调试：可以先验证正向排序是否正确，再考虑反转
         *
         * 缺点：
         * 1. 逻辑错误：这是错误的实现方式！混合升序降序的排序规则不能简单反转
         * 2. 结果错误：会导致排序结果完全不符合预期，所有列的排序方向都被反转
         * 3. 性能浪费：额外的Collections.reverse操作增加了时间复杂度
         * 4. 不适用场景：仅适用于全部升序要转为全部降序的简单场景
         * 5. 维护陷阱：容易被误认为是优化的排序方式，实际上会产生错误结果
         *
         * 注意：此方法演示了常见的排序错误，不要在实际代码中使用！
         */


        // ============ 方法五：关键元组法（构建String元组，再倒序） ============
        log.info("========== 集合排序：关键元组法（构建String元组，再倒序） ==========");
        List<String> sortedByTuple = new ArrayList<>(pureList);
        sortedByTuple.sort((row1, row2) -> {
            // 构建正向元组（未使用）
            String tuple1 = getByIndex(row1, 0) + "|" + getByIndex(row1, 02) + "|" + getByIndex(row1, 03)
                    + "|" + getByIndex(row1, 04) + "|" + getByIndex(row1, 05) + "|" + getByIndex(row1, 8);
            String tuple2 = getByIndex(row2, 0) + "|" + getByIndex(row2, 02) + "|" + getByIndex(row2, 03)
                    + "|" + getByIndex(row2, 04) + "|" + getByIndex(row2, 05) + "|" + getByIndex(row2, 8);

            // 构建反向元组（对需要降序的列进行反转）
            String reverseTuple1 = reverseValue(getByIndex(row1, 0)) + "|" + reverseValue(getByIndex(row1, 02)) + "|" + reverseValue(getByIndex(row1, 03))
                    + "|" + getByIndex(row1, 04) + "|" + getByIndex(row1, 05) + "|" + reverseValue(getByIndex(row1, 8));
            String reverseTuple2 = reverseValue(getByIndex(row2, 0)) + "|" + reverseValue(getByIndex(row2, 02)) + "|" + reverseValue(getByIndex(row2, 03))
                    + "|" + getByIndex(row2, 04) + "|" + getByIndex(row2, 05) + "|" + reverseValue(getByIndex(row2, 8));
            return reverseTuple1.compareTo(reverseTuple2);
        });
        sortedByTuple.forEach(row -> log.info("关键元组法: {}", row));

        /**
         * 方法五优缺点分析：
         *
         * 优点：
         * 1. 理论创新：通过字符串反转巧妙实现降序，思路独特
         * 2. 一次比较：将多个列组合成一个字符串进行一次比较，减少多次函数调用
         * 3. 可优化空间：可以预先计算和缓存元组，避免重复解析
         *
         * 缺点：
         * 1. 性能开销：每次比较都需要构建两个元组字符串，包含多次字符串拼接和反转操作
         * 2. 内存浪费：每个元组字符串都需要额外内存，大数据量时内存消耗严重
         * 3. 字符串长度：元组字符串长度取决于列值长度，可能影响比较性能
         * 4. 局限性强：只适用于字符串比较，数值类型需要额外的转换处理
         * 5. 可读性差：通过字符串反转实现降序的逻辑不够直观，难以理解
         * 6. 维护困难：如果列数或排序规则变化，需要修改元组构建逻辑
         * 7. 错误风险：reverseValue函数对null值处理、特殊字符处理等需要额外考虑
         */


        // ============ 方法六：自定义Comparator静态方法封装 ============
        log.info("========== 集合排序：自定义Comparator静态方法封装 ==========");
        List<String> sortedByCustomComparator = new ArrayList<>(pureList);
        sortedByCustomComparator.sort(SortUtils::multiColumnComparatorMixed);
        sortedByCustomComparator.forEach(row -> log.info("自定义Comparator封装: {}", row));

        /**
         * 方法六优缺点分析：
         *
         * 优点：
         * 1. 职责分离：将排序逻辑从业务代码中分离，符合单一职责原则
         * 2. 可测试性强：独立的静态方法便于单元测试和验证
         * 3. 代码复用：Comparator可以在不同场景复用，提高代码复用性
         * 4. 易于维护：排序逻辑集中在一个方法中，修改和维护更方便
         * 5. 性能优化：可以在方法内部添加缓存机制，优化重复解析问题
         * 6. 可读性好：方法名称明确表达排序意图，代码语义清晰
         * 7. 扩展性强：可以通过参数配置不同的排序规则，提高灵活性
         *
         * 缺点：
         * 1. 方法引用限制：使用方法引用时参数和返回值必须严格匹配Comparator接口
         * 2. 调试复杂性：需要跳转到独立方法查看排序逻辑，调试时不够直观
         * 3. 静态方法限制：无法访问实例变量，需要所有数据通过参数传递
         * 4. 重复代码：与lambda方式相比，可能需要更多的样板代码
         * 5. 方法数量：如果排序规则多样化，可能会产生多个Comparator方法
         */
    }

    /**
     * 多列混合排序Comparator
     * 排序规则：日期降序、列2降序、列3降序、列4升序、列5升序、列8降序
     *
     * @param row1 第一行数据
     * @param row2 第二行数据
     * @return 比较结果，负数表示row1小于row2，0表示相等，正数表示row1大于row2
     */
    private static int multiColumnComparatorMixed(String row1, String row2) {
        int cmp;
        // 列0降序
        cmp = getByIndex(row2, 0).compareTo(getByIndex(row1, 0));
        if (cmp != 0) {
            return cmp;
        }
        // 列2降序
        cmp = getByIndex(row2, 02).compareTo(getByIndex(row1, 02));
        if (cmp != 0) {
            return cmp;
        }
        // 列3降序
        cmp = getByIndex(row2, 03).compareTo(getByIndex(row1, 03));
        if (cmp != 0) {
            return cmp;
        }
        // 列4升序
        cmp = getByIndex(row1, 04).compareTo(getByIndex(row2, 04));
        if (cmp != 0) {
            return cmp;
        }
        // 列5升序
        cmp = getByIndex(row1, 05).compareTo(getByIndex(row2, 05));
        if (cmp != 0) {
            return cmp;
        }
        // 列8降序
        return getByIndex(row2, 8).compareTo(getByIndex(row1, 8));
    }

    /**
     * 字符串反转方法，用于关键元组法实现降序排序
     * 通过反转字符串来改变比较结果，实现降序效果
     *
     * @param value 需要反转的字符串
     * @return 反转后的字符串，如果输入为null则返回null
     */
    private static String reverseValue(String value) {
        if (value == null) {
            return null;
        }
        return new StringBuilder(value).reverse().toString();
    }

}