Wsrtjtyk

Here is the code, in which I'm trying to write using Filewriter. This is working fine.

File f2 = new File("Path");

f2.createNewFile();

FileWriter writing = new FileWriter(f2);    

writing.write("i'm into you , i'm into you");   

writing.flush(); 

In the following code, I'm trying to write using bufferedwriter. This is not adding any text into the same file. For different file, it is working.

BufferedWriter buffwrite = new BufferedWriter(writing);     buffwrite.write("java");    

writing.flush(); 

Yes, definitely you can write both in same class.
Your code is not adding any text into the same file because you are Flushing out FileWriter before BufferedWriter. I just edited your code as below and it worked fine.

File f2 = new File("Path");

f2.createNewFile();

FileWriter writing = new FileWriter(f2);  

writing.write("i'm into you , i'm into you");



BufferedWriter buffwrite = new BufferedWriter(writing); 

buffwrite.write("java"); 



buffwrite.flush();//flush BufferedWriter first followed by FileWriter

writing.flush(); 

These IO related classes are designed based on decorator pattern.

If you refer to the BufferedWriter class javadoc, you'd find a constructor that takes a Writer type object. Writer is an abstract class which is extended by FileWriter among other classes. Pass your FileWriter object in the constructor and then call the write (...) and flush methods of BufferedWriter.

All IO classes work in this pattern.

Yes you can write.Please checkout the below usecases for writing file in java using FileWriter, BufferedWriter, FileOutputStream and Files in java.

package com.journaldev.files;



import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.OutputStream;

import java.nio.file.Files;

import java.nio.file.Paths;



public class WriteFile {



    /**

     * This class shows how to write file in java

     * @param args

     * @throws IOException 

     */

    public static void main(String args) {

        String data = "I will write this String to File in Java";

        int noOfLines = 10000;

        writeUsingFileWriter(data);



        writeUsingBufferedWriter(data, noOfLines);



        writeUsingFiles(data);



        writeUsingOutputStream(data);

        System.out.println("DONE");

    }



    /**

     * Use Streams when you are dealing with raw data

     * @param data

     */

    private static void writeUsingOutputStream(String data) {

        OutputStream os = null;

        try {

            os = new FileOutputStream(new File("/Users/pankaj/os.txt"));

            os.write(data.getBytes(), 0, data.length());

        } catch (IOException e) {

            e.printStackTrace();

        }finally{

            try {

                os.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }



    /**

     * Use Files class from Java 1.7 to write files, internally uses OutputStream

     * @param data

     */

    private static void writeUsingFiles(String data) {

        try {

            Files.write(Paths.get("/Users/pankaj/files.txt"), data.getBytes());

        } catch (IOException e) {

            e.printStackTrace();

        }

    }



    /**

     * Use BufferedWriter when number of write operations are more

     * It uses internal buffer to reduce real IO operations and saves time

     * @param data

     * @param noOfLines

     */

    private static void writeUsingBufferedWriter(String data, int noOfLines) {

        File file = new File("/Users/pankaj/BufferedWriter.txt");

        FileWriter fr = null;

        BufferedWriter br = null;

        String dataWithNewLine=data+System.getProperty("line.separator");

        try{

            fr = new FileWriter(file);

            br = new BufferedWriter(fr);

            for(int i = noOfLines; i>0; i--){

                br.write(dataWithNewLine);

            }

        } catch (IOException e) {

            e.printStackTrace();

        }finally{

            try {

                br.close();

                fr.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }



    /**

     * Use FileWriter when number of write operations are less

     * @param data

     */

    private static void writeUsingFileWriter(String data) {

        File file = new File("/Users/pankaj/FileWriter.txt");

        FileWriter fr = null;

        try {

            fr = new FileWriter(file);

            fr.write(data);

        } catch (IOException e) {

            e.printStackTrace();

        }finally{

            //close resources

            try {

                fr.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }



}

You should close the resources your opened: FileWriter writing and BufferedWriter buffwrite. This (JavaDoc)

Flushes the stream. If the stream has saved any characters from the
various write() methods in a buffer, write them immediately to their
intended destination. Then, if that destination is another character
or byte stream, flush it. Thus one flush() invocation will flush all
the buffers in a chain of Writers and OutputStreams.

The right way is to use the try-resource statement. This will tale care to close opened resources.

Or use the java.nio.file.Files.write methods which will do the resource handling.