Change the last digit in a file

Question

So I want to write ten digits to a .txt file and when I run it, I want to place myself at the last digit so I can manually change the final digit. This is what I got so far:

public static void main(String[] args) throws IOException 
{
    int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    File file = new File("text.txt");

    if (!file.exists())
    {
        file.createNewFile();
    }

    FileWriter fw = new FileWriter(file.getAbsoluteFile());
    BufferedWriter bw = new BufferedWriter(fw);

    bw.write(" " + Arrays.toString(a));
    bw.close();

    System.out.println("Done!");

What this basically does is write ten digits in the form of an int array to a .txt file. Now how would I go about allowing myself to change the last digit, in this case: 10 through user input?

Answer 1

You have two separate problems. The first is how to get your "input". The data you want the user to add. To do that the simplest way would be to take a command line paramater in the arguments and use that as the final character.

so after doing the bw.write but before bw.close do

for (String str: args) {
    bw.write(str);
}

If you need to really wait for input but stay on the command line (rather than through a GUI) then you need to read from System.in()

The second problem is how to actually write to the correct point in the file. That can be done as per Chris' answer by reading the whole existing file and then writing back appending or it could be done by opening the file, seeking to the correct point, and then making the change. There is a Random Access Files system in Java that would help with this:

http://docs.oracle.com/javase/tutorial/essential/io/rafs.html

Answer 2

Step 1

Read everything into memory from the file.

StringBuilder contents = new StringBuilder();

File file = new File("test.txt");

BufferedReader br = new BufferedReader(new FileReader(file));

String line;
while ((line = br.readLine()) != null) {
   contents.append(line);
}

Step 2

Adjust the data in memory.

// Let's assume each day is split by a space
String[] numbers = contents.toString().split(" ");

numbers[numbers.length - 1] = String.valueOf(Integer.parseInt(numbers[numbers.length - 1]) - 1);

Step 3

Write everything back.

FileOutputStream fos = new FileOutputStream(file);
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(fos));

for(String number : numbers)
{
    out.write(number);
}

out.close();

Answer 3

Chris's answer is probably the most straight forward. However another possible way is using a RandomAccessFile. This would be a good option if the file you are maintaining is very large.

 public class RAFExample {
   public static void main(String[] args){
    int[] values = {1,2,3,4,5,6,123};
    File file = new File("text.txt");
    System.out.println("File located at:  " + file.getAbsolutePath());
    RAFExample re = new RAFExample();

    try {
        re.saveArray(file,values);
        System.out.println("Current File Contents:  " + re.getFileContents(file));
        re.updateFile(file,9);
        System.out.println("Current File Contents:  " + re.getFileContents(file));
        re.updateFile(file,2342352);
        System.out.println("Current File Contents:  " + re.getFileContents(file));
        re.updateFile(file,-1);
        System.out.println("Current File Contents:  " + re.getFileContents(file));
    } catch (IOException e) {
        e.printStackTrace();  
    }
}

public void saveArray(File file, int[] values) throws IOException {
    BufferedWriter bw = new BufferedWriter(new FileWriter(file.getAbsoluteFile()));
    try{
        String toFile  = Arrays.toString(values);
        System.out.println("Writing the following string to the file: " + toFile);
        bw.write(toFile);
    }finally{
        bw.close();
    }
}

public void updateFile(File f, int value) throws IOException{
    RandomAccessFile raf = new RandomAccessFile(f,"rw");
    // Find the last space in the file
    final byte space = ' ';
    try{
        String s;
        if(raf.length() == 0){
            s = "[" + value + "]";
            raf.write(s.getBytes());
        }else{
            raf.seek(raf.length());
            int b = raf.read();
            while(raf.getFilePointer() - 2 > 0 && b != space){
                raf.seek(raf.getFilePointer() - 2);
                b = raf.read();
            }
            // now we are at the position to write the new value
            if(raf.getFilePointer() == 0){
                // We got to the beginning of the file,
                // which means there is 1 or 0 values
                s = "[" + value + "]";
            }else{
                s = String.valueOf(value);
            }
            raf.write(s.getBytes());
            raf.write(']'); // This follows the format of Arrays.toString(array)
            raf.setLength(raf.getFilePointer());
        }
    }finally{
        raf.close();
    }
}
private String getFileContents(File f){
    BufferedReader reader = null;
    StringBuilder sb = new StringBuilder(100);
    try{
        reader = new BufferedReader(new FileReader(f));
        while(reader.ready()){
            sb.append(reader.readLine());
        }
    }catch(IOException e){
        e.printStackTrace(System.err);
    }finally{
        if(reader != null){
            try{reader.close();}catch (IOException ignore){}
        }
    }
    return sb.toString();
  }
 }