求助：实现ArrayList与.txt文件的读写方法（fileOut()和fileIn()）

Hey Dylan, let's work through those fileOut() and fileIn() methods for your BankAccount ArrayList—this is a standard file I/O task, so let's break it down clearly with code examples and key considerations tailored to your use case.

This method will take your list of BankAccount objects and write their details to a text file in a structured, easy-to-read format. We'll use a delimiter (like a comma) to separate fields so reading is straightforward later.

Key Requirements & Code #

First, make sure your BankAccount class has getter methods for the fields you need to store (e.g., account number, holder name, balance). Here's a robust implementation with auto-managed resources (to avoid file leaks):

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

public class BankFileHandler {
    // Writes BankAccount list to specified file
    public void fileOut(ArrayList<BankAccount> accounts, String filePath) throws IOException {
        // Try-with-resources automatically closes the writer when done
        try (PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(filePath)))) {
            for (BankAccount account : accounts) {
                // Write each account as a single line, fields separated by commas
                // Trim to avoid accidental whitespace issues
                String line = String.format("%s,%s,%.2f",
                        account.getAccountNumber().trim(),
                        account.getAccountHolder().trim(),
                        account.getBalance());
                writer.println(line);
            }
        }
        // No need to manually close the writer—try-with-resources handles it
    }
}

Important Notes for fileOut() #

• Resource Management: The try-with-resources statement ensures the file stream is closed even if an exception occurs, preventing resource leaks.
• Format Consistency: Using a fixed delimiter (comma here) ensures your fileIn() method can reliably parse each line. If your fields might contain commas (e.g., a holder name like "Doe, John"), wrap fields in quotes and adjust parsing later (more on that below).
• Overwrite vs. Append: The code above overwrites the target file. To append to an existing file, use new FileWriter(filePath, true) instead.
• Exception Handling: We throw IOException so the caller can handle errors (e.g., file not accessible) according to your project's needs—you could also catch it internally and log a message if preferred.

This method reads the text file, parses each line into BankAccount fields, and uses the BankAccount constructor to rebuild your list of objects.

Key Requirements & Code #

Assuming your BankAccount has a constructor like BankAccount(String accountNumber, String accountHolder, double balance), here's the implementation:

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

public class BankFileHandler {
    // Reads BankAccount details from file and returns an ArrayList
    public ArrayList<BankAccount> fileIn(String filePath) throws IOException, IllegalArgumentException {
        ArrayList<BankAccount> accounts = new ArrayList<>();
        
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // Skip empty lines to avoid errors
                if (line.isBlank()) continue;
                
                // Split line into fields using comma delimiter
                String[] fields = line.split(",");
                
                // Validate we have the correct number of fields
                if (fields.length != 3) {
                    throw new IllegalArgumentException("Invalid line format: " + line);
                }
                
                // Parse and trim each field
                String accountNumber = fields[0].trim();
                String accountHolder = fields[1].trim();
                double balance;
                
                try {
                    balance = Double.parseDouble(fields[2].trim());
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("Invalid balance value in line: " + line, e);
                }
                
                // Create BankAccount object and add to list
                accounts.add(new BankAccount(accountNumber, accountHolder, balance));
            }
        }
        
        return accounts;
    }
}

Important Notes for fileIn() #

• Error Handling: We add checks for invalid line formats and non-numeric balance values, wrapping them in IllegalArgumentException to give clear feedback about bad data.
• Whitespace Handling: Using trim() ensures accidental spaces around fields don't break parsing (e.g., " 12345 , Jane Doe , 100.50 " becomes valid fields).
• Handling Quoted Fields: If your fileOut() writes fields wrapped in quotes (to handle commas in names), adjust the split logic to use a CSV parser or a regex like ",(?=(?:[^"]*"[^"]*")*[^"]*$)" to split only on commas outside quotes.
• Constructor Match: Double-check that the order and type of parsed fields match your BankAccount constructor—adjust if your constructor uses different parameters (e.g., adding an account creation date).

• If your project already has a method to add accounts to the main list (e.g., addAccount(BankAccount account)), you can call that from fileIn() instead of directly using accounts.add().
• For validation, you might want to reuse existing account validation logic (e.g., checking if an account number is already present) before adding parsed accounts to the list.

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