验证LinkedList<Integer>与网页表格主电话列的升序/降序状态

其实思路很直接：遍历列表，逐一对比相邻元素的大小关系，就能判断整体是升序、降序还是无序。我给你写了个实用的工具方法，还加了枚举来明确返回状态，用起来很方便：

import java.util.LinkedList;

public class SortValidation {
    public enum SortOrder { ASCENDING, DESCENDING, UNSORTED }

    public static SortOrder checkSortOrder(LinkedList<Integer> list) {
        if (list == null || list.size() <= 1) {
            // 空列表或单个元素的情况，你可以按需调整返回值——比如有些场景会认为单个元素也算升/降序，这里默认返回UNSORTED
            return SortOrder.UNSORTED;
        }

        boolean isAscending = true;
        boolean isDescending = true;

        for (int i = 0; i < list.size() - 1; i++) {
            int current = list.get(i);
            int next = list.get(i + 1);

            if (current > next) {
                isAscending = false;
            }
            if (current < next) {
                isDescending = false;
            }

            // 要是已经确定既不升也不降，直接提前跳出循环，省点性能
            if (!isAscending && !isDescending) {
                break;
            }
        }

        if (isAscending) {
            return SortOrder.ASCENDING;
        } else if (isDescending) {
            return SortOrder.DESCENDING;
        } else {
            return SortOrder.UNSORTED;
        }
    }

    // 测试用例，你可以直接跑来看效果
    public static void main(String[] args) {
        LinkedList<Integer> ascList = new LinkedList<>();
        ascList.add(1);
        ascList.add(3);
        ascList.add(5);
        System.out.println(checkSortOrder(ascList)); // 输出ASCENDING

        LinkedList<Integer> descList = new LinkedList<>();
        descList.add(10);
        descList.add(7);
        descList.add(2);
        System.out.println(checkSortOrder(descList)); // 输出DESCENDING

        LinkedList<Integer> unsortedList = new LinkedList<>();
        unsortedList.add(2);
        unsortedList.add(5);
        unsortedList.add(3);
        System.out.println(checkSortOrder(unsortedList)); // 输出UNSORTED
    }
}

你转Integer报错太正常了！这些电话号码里有一堆非数字字符——加号、括号、减号、空格、还有x，Java的Integer.valueOf()根本没法处理这些，不抛NumberFormatException才怪。解决这个问题得先明确你的排序需求：是按电话号码的数字数值大小排序，还是按字符串本身的字典序排序？我给你两种方案：

方案1：按纯数字数值验证排序 #

如果需求是看电话号码的实际数字大小是否有序，那得先把所有非数字字符去掉，再转成数值（注意：很多电话号码长度超过Integer的范围，比如你示例里的390655889900是12位，Integer最大才10位，所以得用Long）：

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

public class PhoneSortValidation {
    public enum SortOrder { ASCENDING, DESCENDING, UNSORTED }

    // 提取电话号码里的所有数字字符
    private static String extractDigits(String phone) {
        if (phone == null) {
            return "";
        }
        // 用正则把非数字的字符全替换掉
        return phone.replaceAll("[^0-9]", "");
    }

    public static SortOrder checkPhoneSortOrder(List<String> phoneList) {
        if (phoneList == null || phoneList.size() <= 1) {
            return SortOrder.UNSORTED;
        }

        List<Long> numericPhones = new ArrayList<>();
        for (String phone : phoneList) {
            String digits = extractDigits(phone);
            // 处理空字符串的情况（比如遇到无效的电话号码）
            numericPhones.add(digits.isEmpty() ? 0L : Long.parseLong(digits));
        }

        // 复用问题1的排序判断逻辑就行
        boolean isAscending = true;
        boolean isDescending = true;

        for (int i = 0; i < numericPhones.size() - 1; i++) {
            long current = numericPhones.get(i);
            long next = numericPhones.get(i + 1);

            if (current > next) {
                isAscending = false;
            }
            if (current < next) {
                isDescending = false;
            }

            if (!isAscending && !isDescending) {
                break;
            }
        }

        if (isAscending) {
            return SortOrder.ASCENDING;
        } else if (isDescending) {
            return SortOrder.DESCENDING;
        } else {
            return SortOrder.UNSORTED;
        }
    }

    // 用你的示例数据测试一下
    public static void main(String[] args) {
        List<String> phones = List.of(
            "+1 0107968641x551",
            "+1 (814) 775-5474",
            "+1 (308) 729-2823",
            "+1 5258739916x978",
            "390655889900",
            "+1 (100) 100-1001 x000",
            "+1 (111)22222"
        );

        System.out.println(checkPhoneSortOrder(phones)); // 你的示例数据本身是无序的，所以会返回UNSORTED
    }
}

方案2：按字符串字典序验证排序 #

如果需求是直接按电话号码显示的字符串顺序验证（比如只看字符的ASCII顺序，不管数值大小），那不用转数值，直接用String.compareTo()方法比较就行：

public static SortOrder checkPhoneStringSortOrder(List<String> phoneList) {
    if (phoneList == null || phoneList.size() <= 1) {
        return SortOrder.UNSORTED;
    }

    boolean isAscending = true;
    boolean isDescending = true;

    for (int i = 0; i < phoneList.size() - 1; i++) {
        String current = phoneList.get(i);
        String next = phoneList.get(i + 1);

        // compareTo返回正数表示current在字典序上比next大
        int compareResult = current.compareTo(next);
        if (compareResult > 0) {
            isAscending = false;
        }
        if (compareResult < 0) {
            isDescending = false;
        }

        if (!isAscending && !isDescending) {
            break;
        }
    }

    if (isAscending) {
        return SortOrder.ASCENDING;
    } else if (isDescending) {
        return SortOrder.DESCENDING;
    } else {
        return SortOrder.UNSORTED;
    }
}

这里要注意：字符串字典序的结果可能和你直觉里的数字排序不一样，比如"+1 (100)..."里的(ASCII码比空格小，所以会排在"+1 010..."前面，一定要和产品或者测试需求确认清楚规则哦！

内容的提问来源于stack exchange，提问作者Nandhis