Java中如何将String[] arr = new String[6]设置为永久有效？

Hey there! Let's figure out how to make your String[] arr persist permanently in Java. Since you're just starting out, I'll walk you through a few practical, common approaches with full code examples to get you going.

Java has a built-in way to serialize objects (including arrays, since String[] implements the Serializable interface) and write them to a file. You can later read this file to restore your array.

Save the Array #

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class ArrayPersistence {
    public static void saveArray(String[] arr, String filePath) {
        // Try-with-resources ensures streams are closed automatically
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) {
            oos.writeObject(arr);
            System.out.println("Array saved successfully to " + filePath);
        } catch (Exception e) {
            // Handle exceptions (you might want to add more specific error handling here)
            e.printStackTrace();
        }
    }
}

Load the Array #

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ArrayPersistence {
    // Include the saveArray method above here
    
    public static String[] loadArray(String filePath) {
        String[] loadedArr = null;
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath))) {
            loadedArr = (String[]) ois.readObject();
            System.out.println("Array loaded successfully from " + filePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return loadedArr;
    }
}

How to Use It #

public class Main {
    public static void main(String[] args) {
        String[] arr = new String[6];
        arr[0] = "First item";
        arr[1] = "Second item";
        // Fill in the rest of your array elements as needed
        
        // Save the array to a binary file
        String savePath = "my_array.ser";
        ArrayPersistence.saveArray(arr, savePath);
        
        // Later (even after restarting the program), load it back
        String[] restoredArr = ArrayPersistence.loadArray(savePath);
        // Now you can use restoredArr just like your original array
    }
}

Note: The .ser file is binary, so you won't be able to read its content easily. This is great for simple persistence but not if you need to edit the data manually.

If you want to be able to view or edit the saved data directly, writing the array to a plain text file is a good option. Each element gets its own line.

Save the Array #

import java.io.BufferedWriter;
import java.io.FileWriter;

public class ArrayPersistence {
    public static void saveArrayToText(String[] arr, String filePath) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            for (String element : arr) {
                // Write empty string if element is null, so we don't skip lines
                writer.write(element != null ? element : "");
                writer.newLine();
            }
            System.out.println("Array saved to text file: " + filePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Load the Array #

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

public class ArrayPersistence {
    // Include the saveArrayToText method above here
    
    public static String[] loadArrayFromText(String filePath) {
        List<String> elementList = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // Convert empty lines back to null (matches our save logic)
                elementList.add(line.isEmpty() ? null : line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        // Convert list back to a fixed-size 6-element array
        String[] loadedArr = new String[6];
        for (int i = 0; i < 6; i++) {
            loadedArr[i] = i < elementList.size() ? elementList.get(i) : null;
        }
        return loadedArr;
    }
}

JSON is a widely used format that's both human-readable and compatible with almost all programming languages. To use this, you'll need a JSON library like Gson (from Google) or Jackson. Let's use Gson as an example.

First, add the Gson dependency (if using Maven, add this to your pom.xml):

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

Save the Array #

import com.google.gson.Gson;
import java.io.FileWriter;

public class ArrayPersistence {
    public static void saveArrayToJson(String[] arr, String filePath) {
        Gson gson = new Gson();
        String jsonString = gson.toJson(arr);
        
        try (FileWriter writer = new FileWriter(filePath)) {
            writer.write(jsonString);
            System.out.println("Array saved as JSON: " + filePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Load the Array #

import com.google.gson.Gson;
import java.io.FileReader;

public class ArrayPersistence {
    // Include the saveArrayToJson method above here
    
    public static String[] loadArrayFromJson(String filePath) {
        Gson gson = new Gson();
        String[] loadedArr = null;
        
        try (FileReader reader = new FileReader(filePath)) {
            loadedArr = gson.fromJson(reader, String[].class);
            
            // Ensure we have a 6-element array even if the JSON has fewer elements
            if (loadedArr.length < 6) {
                String[] fixedArr = new String[6];
                System.arraycopy(loadedArr, 0, fixedArr, 0, loadedArr.length);
                loadedArr = fixedArr;
            }
            System.out.println("Array loaded from JSON: " + filePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return loadedArr;
    }
}

Which One Should You Choose? #

• Serialization: Best for quick, built-in persistence without external libraries.
• Text File: Great if you need to manually edit the saved data.
• JSON: Ideal if you need compatibility with other systems or want a standard, readable format.

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