Linux使用sort命令进行文本排序的实操指南

更新时间：2026年03月01日 14:13:21 作者：Jinkxs

在 Linux 系统中,sort 命令是一个强大且灵活的文本处理工具,无论是日志分析、数据清洗、报表生成还是系统管理,掌握 sort 的用法都能极大提升工作效率,本文将从基础语法讲起,逐步深入到高级技巧,需要的朋友可以参考下

在 Linux 系统中，sort 命令是一个强大且灵活的文本处理工具。无论是日志分析、数据清洗、报表生成还是系统管理，掌握 sort 的用法都能极大提升工作效率。本文将从基础语法讲起，逐步深入到高级技巧，并结合 Java 代码示例帮助开发者理解如何在程序中模拟或调用 sort 功能。文章还会穿插实用的 mermaid 图表辅助理解，同时提供一些权威外部资源链接供延伸阅读。

一、初识 sort：基础语法与简单应用

sort 命令最基本的功能是对文本行进行字典序排序。默认情况下，它读取标准输入或指定文件，按每行内容的 ASCII 值升序输出。

# 对文件 file.txt 进行排序
sort file.txt

# 对标准输入排序（例如管道）
echo -e "banana\napple\ncherry" | sort

输出结果：

apple
banana
cherry

常见选项一览

选项	说明
`-r`	逆序排序
`-n`	按数值排序
`-k N`	指定第 N 列为排序键
`-t DELIM`	设置字段分隔符
`-u`	去重，仅输出唯一行
`-o FILE`	将结果输出到指定文件
`-f`	忽略大小写
`-b`	忽略前导空白

注意：sort 默认不会修改原文件，除非使用 -o 选项并指定原文件名。

二、Java 模拟基础排序功能

虽然 Java 本身不直接调用 Linux 命令，但我们可以编写程序来模拟 sort 的行为。下面是一个简单的 Java 类，实现对字符串列表的字典序排序：

import java.util.*;

public class SimpleSortSimulator {
    public static void main(String[] args) {
        List<String> lines = Arrays.asList(
            "zebra",
            "apple",
            "banana",
            "Cherry"
        );

        System.out.println("=== 原始顺序 ===");
        lines.forEach(System.out::println);

        System.out.println("\n=== 字典序排序（区分大小写）===");
        List<String> sorted = new ArrayList<>(lines);
        Collections.sort(sorted);
        sorted.forEach(System.out::println);

        System.out.println("\n=== 忽略大小写排序 ===");
        sorted.clear();
        sorted.addAll(lines);
        sorted.sort(String.CASE_INSENSITIVE_ORDER);
        sorted.forEach(System.out::println);

        System.out.println("\n=== 逆序排序 ===");
        sorted.sort(Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));
        sorted.forEach(System.out::println);
    }
}

输出结果：

=== 原始顺序 ===
zebra
apple
banana
Cherry

=== 字典序排序（区分大小写）===
Cherry
apple
banana
zebra

=== 忽略大小写排序 ===
apple
banana
Cherry
zebra

=== 逆序排序 ===
zebra
Cherry
banana
apple

这个例子展示了 Java 中如何通过 Collections.sort() 和比较器实现类似 sort -f 和 sort -r 的效果。

三、数值排序：-n 选项详解

当文本包含数字时，默认的字典序排序可能不符合预期：

echo -e "10\n2\n100\n1" | sort

输出：

这是因为字符 '2' 的 ASCII 值大于 '1'，所以 "2" 排在 "10" 后面。要按数值大小排序，必须使用 -n：

echo -e "10\n2\n100\n1" | sort -n

输出：

Java 数值排序模拟

import java.util.*;
import java.util.stream.Collectors;

public class NumericSortSimulator {
    public static void main(String[] args) {
        List<String> numberStrings = Arrays.asList("10", "2", "100", "1");

        System.out.println("=== 字符串排序 ===");
        List<String> lexSorted = new ArrayList<>(numberStrings);
        Collections.sort(lexSorted);
        lexSorted.forEach(System.out::println);

        System.out.println("\n=== 数值排序 ===");
        List<String> numSorted = numberStrings.stream()
            .sorted((a, b) -> Integer.compare(Integer.parseInt(a), Integer.parseInt(b)))
            .collect(Collectors.toList());
        numSorted.forEach(System.out::println);
    }
}

四、多列排序与字段分隔符：-k 与 -t

现实中的数据往往以结构化形式存在，比如 CSV 或制表符分隔的日志。sort 支持按列排序：

# 示例数据 scores.txt：
Alice 85 Math
Bob 92 Physics
Charlie 78 Chemistry
Diana 92 Math

# 按第二列（分数）数值排序
sort -k2 -n scores.txt

# 按第三列（科目）字典序排序，再按第二列数值排序
sort -k3,3 -k2,2n scores.txt

-k2,2n 表示“从第2列开始，到第2列结束，按数值排序”。若只写 -k2，则从第2列开始直到行尾都参与排序。

使用自定义分隔符

# 如果是逗号分隔
echo -e "Alice,85,Math\nBob,92,Physics" | sort -t',' -k2 -n

五、mermaid 图表：sort 处理流程示意

该流程图清晰地展示了 sort 命令内部处理逻辑，包括字段选择、类型判断、排序算法和去重步骤。

六、稳定排序与内存控制：-s 与 -S

默认情况下，GNU sort 使用的是不稳定排序——即相等元素的原始相对顺序可能被打乱。若需保持原始顺序，可加 -s：

echo -e "B 2\nA 2\nC 1" | sort -k2 -n -s

输出：

C 1
B 2
A 2   # B 在 A 前，保持了输入顺序

另外，大数据集排序可能占用大量内存。可通过 -S 指定最大内存用量：

sort -S 500M hugefile.txt

这在处理 GB 级日志文件时非常有用。

七、Java 实现多列排序与稳定排序

Java 的 Comparator 链可以轻松模拟多列排序：

import java.util.*;

class Student {
    String name;
    int score;
    String subject;

    public Student(String name, int score, String subject) {
        this.name = name;
        this.score = score;
        this.subject = subject;
    }

    @Override
    public String toString() {
        return String.format("%s %d %s", name, score, subject);
    }
}

public class MultiColumnSort {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("Alice", 85, "Math"),
            new Student("Bob", 92, "Physics"),
            new Student("Charlie", 78, "Chemistry"),
            new Student("Diana", 92, "Math")
        );

        System.out.println("=== 按科目排序，再按分数排序 ===");
        students.sort(Comparator
            .comparing((Student s) -> s.subject)
            .thenComparingInt(s -> s.score));

        students.forEach(System.out::println);
    }
}

对于稳定排序，Java 的 Collections.sort() 和 List.sort() 默认就是稳定的，无需额外参数。

八、去重与合并：-u 与 comm 命令

sort -u 可用于去除相邻重复行。注意：它只对已排序的数据有效，因为只比较相邻行。

echo -e "apple\nbanana\napple\ncherry" | sort -u

输出：

apple
banana
cherry

若想找出两个文件的交集、差集，可结合 comm 命令：

# 文件 a.txt: apple, banana, cherry
# 文件 b.txt: banana, date, elderberry

comm -12 <(sort a.txt) <(sort b.txt)  # 交集
comm -23 <(sort a.txt) <(sort b.txt)  # a 有而 b 无

九、国际化与区域设置：LC_COLLATE

sort 的排序行为受环境变量 LC_COLLATE 影响。不同语言环境下，字符排序规则可能不同：

# 查看当前设置
echo $LC_COLLATE

# 临时切换为 C 语言环境（ASCII 顺序）
LC_COLLATE=C sort file.txt

# 切换为 UTF-8 环境（支持多语言）
LC_COLLATE=en_US.UTF-8 sort file.txt

在中文环境下，你可能会看到汉字按拼音排序，这取决于系统的 locale 配置。

十、性能优化技巧：缓冲区、临时目录与并行

处理大文件时，合理配置能显著提升速度：

# 增大缓冲区
sort --buffer-size=1G bigfile.txt

# 指定临时目录（选高速磁盘）
sort --temporary-directory=/tmp bigfile.txt

# GNU sort 自动多线程（版本 >= 8.24）
# 无需额外参数，自动检测 CPU 核心数

如需手动控制线程数（较新版本支持）：

sort --parallel=4 huge.log

十一、Java 调用系统 sort 命令（进阶）

有时，直接调用系统命令比纯 Java 实现更高效（尤其对大文件）。以下示例展示如何在 Java 中执行 sort：

import java.io.*;
import java.nio.file.*;

public class SystemSortInvoker {
    public static void sortFile(String inputFile, String outputFile) throws IOException {
        String command = String.format("sort -n -o %s %s", outputFile, inputFile);
        
        ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
        pb.redirectErrorStream(true); // 合并错误流
        
        Process process = pb.start();
        
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
        
        int exitCode = process.waitFor();
        if (exitCode == 0) {
            System.out.println("✅ 排序完成，输出至: " + outputFile);
        } else {
            System.err.println("❌ 排序失败，退出码: " + exitCode);
        }
    }

    public static void main(String[] args) {
        try {
            sortFile("input.txt", "output_sorted.txt");
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

安全提示：生产环境中应避免拼接用户输入到命令字符串，以防命令注入攻击。建议使用 ProcessBuilder 的参数数组形式。

十二、实际应用场景举例

场景1：分析访问日志，找出高频IP

# access.log 格式：IP - - [时间] "请求" 状态码 ...
awk '{print $1}' access.log | sort | uniq -c | sort -nr | head -10

场景2：合并多个 CSV 并去重

cat *.csv | sort -t',' -k1,1 -u > merged_unique.csv

场景3：按文件大小排序

ls -l | tail -n +2 | sort -k5 -n

十三、常见陷阱与调试技巧

陷阱1：空格与制表符混用

# 错误：字段分隔符不一致
echo -e "A\t10\nB 20" | sort -t$'\t' -k2 -n  # 第二行无法正确分割

解决方法：统一使用相同分隔符，或预处理数据。

陷阱2：隐藏字符干扰

# 检查不可见字符
cat -A file.txt  # 显示 ^I(tab)、$ (换行) 等

陷阱3：locale 导致排序异常

# 强制使用 C locale 避免意外
LC_ALL=C sort file.txt

十四、与其他命令组合使用

sort 经常与 uniq, cut, awk, grep 等配合使用：

# 找出出现次数最多的单词
tr ' ' '\n' < document.txt | grep -v '^$' | sort | uniq -c | sort -nr | head

# 按域名统计邮箱数量
cut -d'@' -f2 emails.txt | sort | uniq -c | sort -nr

十五、mermaid 图表：sort 在数据管道中的位置

此图展示了 sort 在典型数据处理流水线中的核心地位——它通常位于中间环节，为后续聚合或筛选提供有序输入。

十六、扩展阅读与官方文档

GNU Coreutils 官方手册（含 sort）
https://www.gnu.org/software/coreutils/manual/

Linux 命令行与 Shell 脚本大全（在线版）
https://linuxcommand.org/lc3_man_pages/sort1.html

POSIX 标准中的 sort 规范
https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sort.html

这些资源提供了最权威、最完整的 sort 命令说明，适合深入研究底层实现和跨平台兼容性。

十七、Java 8+ 流式排序进阶

借助 Java Stream API，我们可以写出更函数式的排序代码：

import java.util.*;
import java.util.stream.Collectors;

public class StreamBasedSorter {
    public static void main(String[] args) {
        List<String> data = Arrays.asList(
            "user3,age:25,country:US",
            "user1,age:30,country:CN",
            "user2,age:25,country:JP"
        );

        // 解析并排序：先按年龄，再按国家
        List<String> sorted = data.stream()
            .map(line -> line.split(","))
            .sorted(Comparator
                .comparing(parts -> Integer.parseInt(parts[1].split(":")[1]))
                .thenComparing(parts -> parts[2].split(":")[1])
            )
            .map(parts -> String.join(",", parts))
            .collect(Collectors.toList());

        sorted.forEach(System.out::println);
    }
}

这种风格更贴近现代 Java 开发习惯，也更容易与过滤、映射等操作组合。

十八、自定义排序规则：从简单到复杂

有时默认规则不够用，比如版本号排序：

# 版本号：期望 1.10 > 1.2，但字典序下 1.2 > 1.10
echo -e "1.2\n1.10\n1.1" | sort -V  # 使用版本号感知排序

-V 是 GNU sort 特有的“自然版本排序”选项。

Java 实现版本号排序

import java.util.*;
import java.util.regex.Pattern;

public class VersionSorter {
    private static List<Integer> parseVersion(String v) {
        return Pattern.compile("\\.")
            .splitAsStream(v)
            .map(Integer::parseInt)
            .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<String> versions = Arrays.asList("1.2", "1.10", "1.1", "2.0");

        versions.sort(Comparator.comparing(VersionSorter::parseVersion));

        versions.forEach(System.out::println);
    }
}

十九、实战：构建一个日志分析工具

假设我们要分析 Nginx 日志，找出访问量最高的 URL：

# 假设日志格式：IP - - [时间] "GET /path HTTP/1.1" 状态码 大小 ...
awk '{print $7}' access.log \
  | grep -v '^\-$' \
  | sort \
  | uniq -c \
  | sort -nr \
  | head -20

用 Java 实现同样功能：

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class LogAnalyzer {
    public static void analyzeTopUrls(String logFile) throws IOException {
        Map<String, Long> urlCount = new HashMap<>();

        try (BufferedReader br = Files.newBufferedReader(Paths.get(logFile))) {
            br.lines()
              .map(line -> {
                  String[] parts = line.split(" ");
                  return parts.length > 6 ? parts[6] : "-";
              })
              .filter(url -> !"-".equals(url))
              .forEach(url -> urlCount.merge(url, 1L, Long::sum));
        }

        urlCount.entrySet().stream()
            .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
            .limit(20)
            .forEach(entry -> 
                System.out.printf("%5d %s%n", entry.getValue(), entry.getKey()));
    }

    public static void main(String[] args) throws IOException {
        analyzeTopUrls("access.log");
    }
}

二十、总结与最佳实践

经过前面近 8000 字的详细讲解，我们系统学习了 sort 命令的方方面面。以下是关键要点总结：

🔹 基础必会：sort file、sort -n、sort -r、sort -u
🔹 进阶技巧：-k 多列排序、-t 自定义分隔符、-s 稳定排序
🔹 性能优化：-S 控制内存、--parallel 并行处理、--temporary-directory 指定临时路径
🔹 避坑指南：注意 locale 影响、检查隐藏字符、确保分隔符一致
🔹 Java 对照：用 Comparator 链模拟多列排序，用 ProcessBuilder 调用系统命令
🔹 组合使用：与 uniq、awk、cut 等命令配合构建数据处理流水线

无论你是系统管理员、数据分析师还是 Java 开发者，掌握 sort 命令都能让你在文本处理任务中游刃有余。记住：“在 Unix 世界里，有序即是力量。”

以上就是Linux使用sort命令进行文本排序的实操指南的详细内容，更多关于Linux sort命令文本排序的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

Linux环境下安装JDK1.8
本文详细讲解了Linux环境下安装JDK1.8的方法，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-11-11
Linux下环境变量配置方法小结（.bash_profile和.bashrc的区别）
这篇文章主要介绍了Linux下环境变量配置方法小结（.bash_profile和.bashrc的区别）,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-04-04
Linux命令移动/复制文件/目录到指定目录下的实现
这篇文章主要介绍了Linux命令移动/复制文件/目录到指定目录下的实现方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-04-04
mac下配置和访问阿里云服务器（Ubuntu系统）的图文教程
这篇文章主要介绍了mac下配置和访问阿里云服务器（Ubuntu系统）的图文教程，非常不错，具有参考借鉴价值，需要的朋友参考下
2017-01-01
Linux下“/”和“~”的区别详解
这篇文章主要介绍了Linux下“/”和“~”的区别详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-09-09
Linux下Redis设置密码及开机自启动
这篇文章主要介绍了Linux下Redis设置密码及开机自启动的相关资料,需要的朋友可以参考下
2016-12-12
linux 搭建svn服务器的方法步骤
这篇文章主要介绍了linux 搭建svn服务器的方法步骤，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2019-01-01
Linux中的进程间通信之匿名管道解读
这篇文章主要介绍了Linux中的进程间通信之匿名管道解读,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2025-03-03
$Linux vi\vim编译器详解$
Linux vi\vim编译器详解
文章介绍了Vim作为vi的增强版,具备语法高亮、shell编辑等功能,详解其三种模式（命令、输入、底线命令）及常用操作,如保存、退出、撤销等,并简述Linux中root用户及su/sudo命令的使用方法
2025-07-07
vim配置显示行号和语法高亮即.vimrc文件的配置
本文主要介绍vim配置显示行号和语法高亮的功能，比较实用，需要的朋友可以参考一下。
2016-06-06