You can use a try-with-resources block

try (PrintWriter fileOut = new PrintWriter(new BufferedWriter(new     FileWriter(csvFileIn)))) {
    //WHATEVER you need to do
}

Since PrintWriter implements AutoCloseable it will close by itself once the try block is complete (even if an exception is raised)

Check more info about this here

Yes, closing any Writer/Reader will close all other Writers and Readers that they wrap. Don't close it until you are ready to close the underlying socket.

If the directory doesn't exist you need to create it. Java won't create it by itself since the File class is just a link to an entity that can also not exist at all.

As you stated the error is that the file cannot be created. If you read the documentation of PrintWriter constructor you can see

FileNotFoundException - If the given string does not denote an existing, writable regular file and a new regular file of that name cannot be created, or if some other error occurs while opening or creating the file

You should try creating a path for the folder it contains before:

File file = new File("C:/Users/Me/Desktop/directory/file.txt");
file.getParentFile().mkdirs();

PrintWriter printWriter = new PrintWriter(file);

Calling close() causes all the data to be flushed. You have constructed a PrintWriter without enabling auto-flush (a second argument to one of the constructors), which would mean you would have to manually call flush(), which close() does for you.

Closing also frees up any system resources used by having the file open. Although the VM and Operating System will eventually close the file, it is good practice to close it when you are finished with it to save memory on the computer.

You may also which to put the close() inside a finally block to ensure it always gets called. Such as:

PrintWriter out = null;
try {
    File f = new File("c:/users/dell/desktop/ja/MyLOgs.txt");
    out = new PrintWriter(new FileWriter(f,true));
    out.println("the name of the  user is "+name+"\n");
    out.println("the email of the user is "+ email+"\n");
} finally {
    out.close();
}

See: PrintWriter

Sanchit also makes a good point about getting the Java 7 VM to automatically close your streams the moment you don't need them automatically.

I would not recommend multiple classes writing in the same file concurrently. My idea will be to implement a queue for your Logger class in which all the classes integrated with it will push their logs to.

Whenever a class push its logs to the queue it should ask the logger to write to the file.

Create a boolean writing in your Logger instance that prevents multiple write commands to be executed to avoid any duplication.

Your write method keeps writing until the queue is empty and then resets the writing boolean to false.

// A sample logger class
public class Logger {
  static Queue<String> pending = new LinkedList<String>();
  static boolean writing = false;
  static PrintWriter pw = new PrintWriter("production.log", "UTF-8");

  public static void write() {
    if(!writing) {
      writing = true;
      pw.open();
      while(!pending.isEmpty()) {
        pw.println(pending.poll());
      }
      pw.close();
      writing = false;
    }
  }
}

You now open and close your file less frequently and you do not lose any of your logs.