Java中List of Lists按指定列排序与查找教程

"Test0" "ABC" "123" "A1"
"Test3" "JKL" "901" "A4"
"Test1" "DEF" "345" "A2"
"Test4" "MNO" "234" "A5"
"Test2" "GHI" "678" "A3"

private static int findPivotPoint(List<List<String>> grid, String key) {
    for (List<String> row : grid) {
        // 使用IntStream查找key在当前行中的索引
        OptionalInt indexOpt = IntStream.range(0, row.size())
                                .filter(i -> key.equals(row.get(i)))
                                .findFirst();
        if (indexOpt.isPresent()) {
            return indexOpt.getAsInt(); // 返回找到的第一个匹配的列索引
        }
    }
    return -1; // 如果所有行都没有找到匹配的key，则返回-1
}

// 在主方法或其他适当位置定义
int pivotPoint = findPivotPoint(grid, key); // 假设已经找到了pivotPoint

Comparator<List<String>> rowComparator = new Comparator<List<String>>() {
    @Override
    public int compare(List<String> o1, List<String> o2) {
        // 确保pivotPoint有效，避免索引越界
        if (pivotPoint < 0 || pivotPoint >= o1.size() || pivotPoint >= o2.size()) {
            // 如果pivotPoint无效，可以根据业务逻辑选择抛出异常、返回0（相等）或处理
            // 这里我们假设pivotPoint是有效的，或者在调用前已检查
            return 0; // 示例中简单返回0，表示无法比较或认为相等
        }
        String s1 = o1.get(pivotPoint);
        String s2 = o2.get(pivotPoint);
        return s1.compareTo(s2); // 使用String的compareTo方法进行比较
    }
};

if (pivotPoint >= 0) { // 只有当找到有效的pivotPoint时才进行排序
    Collections.sort(grid, rowComparator);
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.OptionalInt;
import java.util.stream.IntStream;

public class GridSorter {

    public static void main(String[] args) {
        // 初始化数据，注意这里使用ArrayList作为外部列表以支持排序，
        // 内部列表可以使用List.of()创建，但如果需要修改内部列表，则需使用ArrayList。
        // 在本例中，我们只对外部列表的顺序进行修改，内部列表内容不变。
        List<List<String>> grid = new ArrayList<>();
        grid.add(List.of("Test0", "ABC", "123", "A1"));
        grid.add(List.of("Test3", "JKL", "901", "A4"));
        grid.add(List.of("Test1", "DEF", "345", "A2"));
        grid.add(List.of("Test4", "MNO", "234", "A5"));
        grid.add(List.of("Test2", "GHI", "678", "A3"));

        String searchKey = "345"; // 要查找的键
        int pivotPoint = findPivotPoint(grid, searchKey); // 查找键所在的列索引

        System.out.println("原始数据：");
        grid.forEach(System.out::println);
        System.out.println("--------------------");

        if (pivotPoint >= 0) {
            // 定义自定义比较器，根据pivotPoint处的字符串进行比较
            Comparator<List<String>> rowComparator = new Comparator<List<String>>() {
                @Override
                public int compare(List<String> o1, List<String> o2) {
                    String s1 = o1.get(pivotPoint);
                    String s2 = o2.get(pivotPoint);
                    return s1.compareTo(s2);
                }
            };

            // 执行排序
            Collections.sort(grid, rowComparator);
            System.out.println("按列 " + pivotPoint + " 排序后的数据：");
            grid.forEach(System.out::println);

            // 查找包含searchKey的行（在排序后，可以简单遍历或考虑二分查找）
            System.out.println("--------------------");
            System.out.println("查找包含 '" + searchKey + "' 的行：");
            grid.stream()
                .filter(row -> row.contains(searchKey))
                .forEach(System.out::println);

        } else {
            System.out.println("未找到键 '" + searchKey + "'，不执行排序。");
        }

        // 示例：如果查找一个不存在的键
        System.out.println("\n--- 查找不存在的键 ---");
        String nonExistentKey = "foo";
        int pivotPointNonExistent = findPivotPoint(grid, nonExistentKey);
        if (pivotPointNonExistent == -1) {
            System.out.println("未找到键 '" + nonExistentKey + "'，原始列表保持不变。");
            grid.forEach(System.out::println); // 打印当前grid（已按345排序）
        }
    }

    /**
     * 在List<List<String>>中查找给定key首次出现的列索引。
     * @param grid 数据网格
     * @param key 要查找的字符串
     * @return 首次出现key的列索引，如果未找到则返回-1。
     */
    private static int findPivotPoint(List<List<String>> grid, String key) {
        for (List<String> row : grid) {
            OptionalInt indexOpt = IntStream.range(0, row.size())
                                    .filter(i -> key.equals(row.get(i)))
                                    .findFirst();
            if (indexOpt.isPresent()) {
                return indexOpt.getAsInt();
            }
        }
        return -1;
    }
}

原始数据：
[Test0, ABC, 123, A1]
[Test3, JKL, 901, A4]
[Test1, DEF, 345, A2]
[Test4, MNO, 234, A5]
[Test2, GHI, 678, A3]
--------------------
按列 2 排序后的数据：
[Test0, ABC, 123, A1]
[Test4, MNO, 234, A5]
[Test1, DEF, 345, A2]
[Test2, GHI, 678, A3]
[Test3, JKL, 901, A4]
--------------------
查找包含 '345' 的行：
[Test1, DEF, 345, A2]

--- 查找不存在的键 ---
未找到键 'foo'，原始列表保持不变。
[Test0, ABC, 123, A1]
[Test4, MNO, 234, A5]
[Test1, DEF, 345, A2]
[Test2, GHI, 678, A3]
[Test3, JKL, 901, A4]