Similar question has been asked here Java. How to append text to top of file.txt but seem like not solved yet

You might want to try this:

BufferedReader read= new BufferedReader(new FileReader(yourfilename));
ArrayList list = new ArrayList();

String dataRow = read.readLine(); 
while (dataRow != null){
    list.add(dataRow);
    dataRow = read.readLine(); 
}

FileWriter writer = new FileWriter(yourfilename); //same as your file name above so that it will replace it
writer.append(headerComments);

for (int i = 0; i < list.size(); i++){
    writer.append(System.getProperty("line.separator"));
    writer.append(list.get(i));
}
writer.flush();
writer.close();

There is a way, it involves rewriting the whole file though (but no temporary file). As others mentioned, no file system supports prepending content to a file. Here is some sample code that uses a RandomAccessFile to write and read content while keeping some content buffered in memory:

public static void main(final String args[]) throws Exception {
    File f = File.createTempFile(Main.class.getName(), "tmp");
    f.deleteOnExit();

    System.out.println(f.getPath());

    // put some dummy content into our file
    BufferedWriter w = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f)));
    for (int i = 0; i < 1000; i++) {
        w.write(UUID.randomUUID().toString());
        w.write('\n');
    }
    w.flush();
    w.close();

            // append "some uuids" to our file
    int bufLength = 4096;
    byte[] appendBuf = "some uuids\n".getBytes();
    byte[] writeBuf = appendBuf;
    byte[] readBuf = new byte[bufLength];

    int writeBytes = writeBuf.length;

    RandomAccessFile rw = new RandomAccessFile(f, "rw");
    int read = 0;
    int write = 0;

    while (true) {
                    // seek to read position and read content into read buffer
        rw.seek(read);
        int bytesRead = rw.read(readBuf, 0, readBuf.length);

                    // seek to write position and write content from write buffer
        rw.seek(write);
        rw.write(writeBuf, 0, writeBytes);

                    // no bytes read - end of file reached
        if (bytesRead < 0) {
                            // end of
            break;
        }

                    // update seek positions for write and read
        read += bytesRead;
        write += writeBytes;
        writeBytes = bytesRead;

                    // reuse buffer, create new one to replace (short) append buf
        byte[] nextWrite = writeBuf == appendBuf ? new byte[bufLength] : writeBuf;
        writeBuf = readBuf;
        readBuf = nextWrite;
    };

    rw.close();

            // now show the content of our file
    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(f)));

    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

You can use RandomAccessFile to and seek the cursor to 0th position using seek(long position) method, before starting to write.

As explained in this thread

RandomAccessFile f = new RandomAccessFile(new File("yourFile.txt"), "rw");
f.seek(0); // to the beginning
f.write("Jennifer".getBytes());
f.close();

Edit: As pointed out below by many comments, this solution overwrites the file content from beginning. To completely replace the content, the File may have to be deleted and re-written.

The solution with FileWriter is working, however you have no possibility to specify output encoding then, in which case the default encoding for machine will be used, and this is usually not UTF-8!

So at best use FileOutputStream:

    Writer writer = new BufferedWriter(new OutputStreamWriter(
        new FileOutputStream(file, true), "UTF-8"));

Just in case it will be useful for someone here is full source code of method to prepend lines to a file using Apache Commons IO library. The code does not read whole file into memory, so will work on files of any size.

public static void prependPrefix(File input, String prefix) throws IOException {
    LineIterator li = FileUtils.lineIterator(input);
    File tempFile = File.createTempFile("prependPrefix", ".tmp");
    BufferedWriter w = new BufferedWriter(new FileWriter(tempFile));
    try {
        w.write(prefix);
        while (li.hasNext()) {
            w.write(li.next());
            w.write("\n");
        }
    } finally {
        IOUtils.closeQuietly(w);
        LineIterator.closeQuietly(li);
    }
    FileUtils.deleteQuietly(input);
    FileUtils.moveFile(tempFile, input);
}

To write text, you need to create a Writer - such as OutputStreamWriter. You can use FileWriter instead, but I prefer to wrap a FileOutputStream in an OutputStreamWriter as that way I can control the encoding.

You can't really prepend to the start of a file though - you'll have to write the new text to the start of a new file, then copy the contents of the old file afterwards, then rename the files if necessary. Exactly how you do that will depend on the contents of the existing file.

Initialization of input stream will remove file content, so you can read file content first, and then write to it as following:

public static void main(String[] args) throws FileNotFoundException {
        boolean foundException = false;
        Scanner keyboard = new Scanner(System.in);
        do {
            try {
                System.out.print("Please enter input file name: ");
                String fileName = keyboard.next();
                File inputFile = new File("inputfile.txt");
                Scanner scanner = new Scanner(new File("inputfile.txt"));
                ArrayList<String> lines = new ArrayList<>();

                int lineNum = 1;
                while (scanner.hasNextLine()) {
                    String line = scanner.nextLine();
                    line = line.trim();
                    if (line.length() > 0) {
                        lines.add(lineNum + "." + line);
                        lineNum++;
                    }
                }
                PrintStream out = new PrintStream(new File("inputfile.txt"));
                for (String line : lines)
                    out.println(line);

            } catch (FileNotFoundException x) {
                System.out.println("File does not exist");
                foundException = true;
            }

        } while (foundException);
    }

And method name called on file object does not return number of lines in file. I will refer to docs:

The length, in bytes, of the file denoted by this abstract pathname, or 0L if the file does not exist. Some operating systems may return 0L for pathnames denoting system-dependent entities such as devices or pipes.

You may read your file into an ArrayList, you can add elements in any position and manipulate all elements and its data, then you can write it again into file.

PD: you can not add a line directly to the file, you just can read and write/append data to it, you must manipulte de data in memory and then write it again.

let me know if this is useful for you

the input file being used has duplicates records DETAILS: aa bb aa gg bb bb

To remove duplicates, I am using the following code

File Readfile= new File(n.getProperty("file"));
BufferedReader reader= new BufferedReader(new FileReader(Readfile));
Set<String> lines = new HashSet<String>(10000);
String line;
while((line=reader.readLine())!=null){
    lines.add(line);
}
reader.close();
File file =new File("stripduplicates.txt");

if(!file.exists()){
    file.createNewFile();
}
BufferedWriter writer = new BufferedWriter(new FileWriter(file.getPath()));
   //EDIT done
    writer.write("DETAILS:");
for(String unique: lines){
    //EDIT done
      if(!(unique.startsWith("DETAILS:"))
        {
        writer.write(unique);
        writer.newLine();
        }
}
writer.close();
}

The output is coming as needed

DETAILS: aa gg bb

StringBuilder result = new StringBuilder();

org.apache.commons.io.LineIterator it = org.apache.commons.io.FileUtils.lineIterator(file);
try {
  while (it.hasNext()) {
    String line = it.nextLine();
    result.append("sometext ").append(line).append(" sometext\n")
  }
} finally {
  it.close();
}

org.apache.commons.io.FileUtils.writeStringToFile(outFile, result.toString());