Java嵌套while循环失效求助：读取文本文件并对比数据

Hey there! Let's tackle your two main issues one by one—getting that inner while loop working, and ditching the try-catch for NullPointerException in favor of better practices.

1. Fixing the Inner While Loop (Count Stuck at 0) #

The most likely reasons your inner loop isn’t running (and count stays 0) are related to how you’re handling your file readers. Here are the common pitfalls and fixes:

Common Causes: #

• Reusing the same BufferedReader instance: If you’re using the same reader for both files, the first read would have already moved the pointer to the end of the first file—so when you try to read the second file, it immediately hits null.
• Incorrect file path or empty second file: Double-check that your second file exists at the path you’re using, and that it actually has content (not just a blank file).
• Not closing streams properly: If you don’t close the first reader before opening the second, you might run into unexpected behavior with resource locks.

Fixed File Reading Code: #

Use separate BufferedReader instances for each file, and leverage try-with-resources (it automatically closes streams for you, no need for manual close() calls):

// Store data for each file in separate ArrayLists
List<String> file1Content = new ArrayList<>();
List<String> file2Content = new ArrayList<>();

// Read first file
try (BufferedReader br1 = new BufferedReader(new FileReader("firstFile.txt"))) {
    String line;
    while ((line = br1.readLine()) != null) {
        file1Content.add(line);
    }
} catch (IOException e) {
    System.err.println("Failed to read first file:");
    e.printStackTrace();
}

// Read second file (separate reader = no pointer overlap)
try (BufferedReader br2 = new BufferedReader(new FileReader("secondFile.txt"))) {
    String line;
    int count = 0;
    while ((line = br2.readLine()) != null) {
        file2Content.add(line);
        count++;
    }
    System.out.println("Second file line count: " + count); // This should now show the correct number!
} catch (IOException e) {
    System.err.println("Failed to read second file:");
    e.printStackTrace();
}

2. Replacing Try-Catch for NullPointerException #

Catching NullPointerException is almost always a band-aid—it hides logic errors where you’re using uninitialized objects. Instead, prevent NPEs before they happen with these checks:

Key Prevention Steps: #

• Validate file paths first: Make sure your file path string isn’t null or empty before trying to open the file:

  String filePath = "yourFile.txt";
  if (filePath == null || filePath.isBlank()) {
      System.err.println("File path can't be null or empty!");
      return;
  }
  

• Initialize your ArrayList array properly: If you’re using an array of ArrayLists, don’t just declare it—initialize each element:

  // Wrong: Leaves array elements as null
  // List<String>[] dataArrays = new List[2];
  
  // Right: Initializes each ArrayList in the array
  List<String>[] dataArrays = new List[2];
  dataArrays[0] = new ArrayList<>();
  dataArrays[1] = new ArrayList<>();
  

• Check method parameters: If you pass lists/objects to helper methods, validate they aren’t null at the start of the method:

  private static void processFileData(List<String> dataList) {
      if (dataList == null) {
          System.err.println("Data list can't be null!");
          return;
      }
      // Rest of your logic...
  }
  

Full Working Example #

Here’s a complete, clean version of your code that handles both issues:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class WarehouseComparison {
    public static void main(String[] args) {
        // Initialize array of ArrayLists (no null elements!)
        List<String>[] fileData = new List[2];
        fileData[0] = new ArrayList<>();
        fileData[1] = new ArrayList<>();

        // Read both files
        readFile("warehouse1.txt", fileData[0]);
        readFile("warehouse2.txt", fileData[1]);

        // Compare the two datasets
        compareFiles(fileData[0], fileData[1]);
    }

    private static void readFile(String filePath, List<String> dataList) {
        // Prevent NPEs with pre-checks
        if (filePath == null || filePath.isBlank()) {
            System.err.println("Invalid file path provided!");
            return;
        }
        if (dataList == null) {
            System.err.println("Data list cannot be null!");
            return;
        }

        // Try-with-resources handles stream cleanup
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            int lineCount = 0;
            while ((line = br.readLine()) != null) {
                dataList.add(line);
                lineCount++;
            }
            System.out.println("Successfully read " + lineCount + " lines from " + filePath);
        } catch (IOException e) {
            System.err.println("Error reading file: " + filePath);
            e.printStackTrace();
        }
    }

    private static void compareFiles(List<String> list1, List<String> list2) {
        // Pre-check for null lists
        if (list1 == null || list2 == null) {
            System.err.println("One or both data lists are null!");
            return;
        }

        System.out.println("\n--- Comparison Results ---");
        // Find lines only in first file
        List<String> onlyInFirst = new ArrayList<>(list1);
        onlyInFirst.removeAll(list2);
        System.out.println("Lines only in first warehouse: " + onlyInFirst);

        // Find lines only in second file
        List<String> onlyInSecond = new ArrayList<>(list2);
        onlyInSecond.removeAll(list1);
        System.out.println("Lines only in second warehouse: " + onlyInSecond);

        // Find common lines
        List<String> commonLines = new ArrayList<>(list1);
        commonLines.retainAll(list2);
        System.out.println("Common lines in both warehouses: " + commonLines);
    }
}

This code will correctly read both files, count lines properly, and avoid NPEs without needing to catch them.

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