Java实现：从文本文件降序输出单词并对比遍历效率

嘿，我来帮你搞定这个问题！咱们一步步拆解需求，给出完整的解决方案：

首先，咱们先搞定降序输出的核心问题：你原来的升序应该是用了默认的Collections.sort(list)，自然升序逻辑没问题。要实现降序，咱们可以直接用反向比较器排序，比先升序再反转更高效；然后是遍历耗时对比，LinkedList的get(index)和迭代器遍历性能差异很大，咱们用纳秒级计时来直观展示差距。

下面是修正后的完整代码，每一步都加了详细注释：

import java.util.*;
import java.io.*;

public class Task1 {
    public static void main(String[] args) {
        LinkedList<String> wordList = new LinkedList<>();
        
        // 1. 从文本文件读取单词到LinkedList（支持每行多单词，按空格分割）
        try (BufferedReader br = new BufferedReader(new FileReader("words.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                // 按任意空白字符分割单词，过滤空字符串
                String[] words = line.split("\\s+");
                for (String word : words) {
                    if (!word.isEmpty()) {
                        wordList.add(word);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        
        // 2. 升序排序并按每行4个制表符分隔输出
        System.out.println("=== 升序输出 ===");
        Collections.sort(wordList);
        printWordsInRows(wordList, 4);
        
        // 3. 降序排序并输出（直接用反向比较器，高效实现）
        System.out.println("\n=== 降序输出 ===");
        Collections.sort(wordList, Collections.reverseOrder());
        printWordsInRows(wordList, 4);
        
        // 4. 对比迭代器与get(index)遍历的耗时
        System.out.println("\n=== 遍历耗时对比 ===");
        compareTraversalPerformance(wordList);
    }
    
    // 辅助方法：统一处理按行输出逻辑，每行指定数量单词，制表符分隔
    private static void printWordsInRows(LinkedList<String> list, int wordsPerRow) {
        int count = 0;
        for (String word : list) {
            System.out.print(word + "\t");
            count++;
            // 每到指定数量就换行
            if (count % wordsPerRow == 0) {
                System.out.println();
            }
        }
        // 处理最后一行不足指定数量的情况，补换行
        if (count % wordsPerRow != 0) {
            System.out.println();
        }
    }
    
    // 对比两种遍历方式的性能，用纳秒级计时保证精度
    private static void compareTraversalPerformance(LinkedList<String> list) {
        int size = list.size();
        long startTime, endTime;
        
        // 方式1：迭代器遍历（LinkedList最优遍历方式）
        startTime = System.nanoTime();
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            // 模拟实际业务操作，这里仅做遍历
            String word = iterator.next();
        }
        endTime = System.nanoTime();
        System.out.printf("迭代器遍历耗时：%,d 纳秒\n", (endTime - startTime));
        
        // 方式2：get(index)遍历（LinkedList低效遍历方式）
        startTime = System.nanoTime();
        for (int i = 0; i < size; i++) {
            String word = list.get(i);
        }
        endTime = System.nanoTime();
        System.out.printf("get(index)遍历耗时：%,d 纳秒\n", (endTime - startTime));
    }
}

关键细节说明： #

• 降序实现：用Collections.sort(wordList, Collections.reverseOrder())直接按降序排序，比先升序再反转少一次全链表遍历，效率更高。如果你的原代码尝试过手动反转但失败，大概率是没重新排序就直接输出，或者反转逻辑写错了。
• 统一输出逻辑：把每行4个单词的输出封装成printWordsInRows方法，避免升序降序代码重复，更易维护。
• 性能对比：用System.nanoTime()计时是因为它的精度远高于毫秒级的currentTimeMillis()，能清晰体现两者的差异——LinkedList是双向链表，get(index)每次都要从表头/表尾遍历到目标位置（时间复杂度O(n)），而迭代器是沿着节点指针逐个移动（时间复杂度O(1)），数据量越大，差距越明显。

内容的提问来源于stack exchange，提问作者Proximus Seraphim Dimitri Davi