IOException is a super class of FileNotFoundException. Therefore your catch block for IOException also catches every FileNotFoundException.

You should implement the function as follows:

public static void writeAssignment(ArrayList<String> assignment, String filename) throws FileNotFoundException {

    try (FileWriter writer = new FileWriter(filename)) {
        for (String str : assignment) {
            writer.write(str + "\n");
        }
    } catch (FileNotFoundException e) {
        throw e; // catch and re-throw
    } catch (IOException e) {
        System.err.print("Something went wrong");
    }
}

In general, you do not want to upload anything into your application's files - it opens you to many security problems if someone figures out how to overwrite parts of the application, and in most application servers, it is simply not writable.

A much better approach is to have a designated server folder where you can write things. For example, you could have the following in your configuration:

myapp.base-folder = /any/server/folder/you/want

And then, in the code, you would find that folder as follows:

// env is an @AutoWired private Environment
File baseFolder = new File(env.getProperty("myapp.base-folder"));

I find this better than using a database (as @Stultuske suggested in comments), because databases are great for relations, but mostly overkill for actual files. Files can be accessed externally without firing up the database with minimal hassle, and having them separate keeps your database much easier to backup.

To generate links to the file, simply create a link as you would to any other type of request

<a th:href="@{/file/${fileId}|}">Download file</a>

-- and to handle it in the server, but returning the contents of the file:

@GetMapping(value="/file/{id}")
public StreamingResponseBody getFile(@PathVariable long id) throws IOException {        
    File f = new File(baseFolder, ""+id); // numerical id prevents filesytem traversal
    InputStream in;
    if (f.exists()) {
        in = new BufferedInputStream(new FileInputStream(f));
    } else {
        // you could also signal error by returning a 404
        in = new BufferedInputStream(getClass().getClassLoader()
                .getResourceAsStream("static/img/unknown-id.jpg"));
    }
    return new StreamingResponseBody() {
        @Override
        public void writeTo(OutputStream os) throws IOException {
            FileCopyUtils.copy(in, os);
        }
    };
}

I prefer numerical IDs to avoid hassles with path traversal - but you can easily use string filenames instead, and deal with security issues by carefully checking that the canonical path of the requested file starts with the canonical path of your baseFolder

I agree with @cyber-rookie, it is probably best to close resources in a finally block.

Java 7 introduced "try-with-resources" in order to cut down on programming mistakes...

https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html

You can now write...

    try (FileWriter writer = new FileWriter("file.txt")) {
        writer.write("i am writing");
    } catch (IOException e) {
        e.printStackTrace();
    }

The compiler will add the extra code to close the writer at the end of the block for you

Your problem is this line:

FileWriter fw = new FileWriter(file2);

Constructing the FileWriter is throwing an IOException, and because it is outside your try-Catch block, it isn't being caught. I suggest you try addding it in the following way:

try(FileWriter fw = new FileWriter(file2); BufferedWriter bw = new BufferedWriter(fw);) 
//and then the rest of your try catch block

This turns your try-catch into a try-with-resources block which basically means once the code is block is finished the writers should automatically close

EDIT

If you assign the variables in the try-with-Resources like so:

try(FileWriter fw = new FileWriter(file2); BufferedWriter bw = new BufferedWriter(fw);
    FileInputStream fis = new FileInputStream(file); BufferedInputStream bis = new BufferedInputStream(fis);
    DataInputStream dis = new DataInputStream(bis)) {

then you can remove all of these:

// dispose all the resources after using them.
fis.close();
bis.close();
dis.close();
bw.flush();
bw.close();

As the try-with-resources can automatically try and close anything within the (at the start to save you trying to do it manually)

Supplementary notes about the comment.

@RequestMapping(value="/newFile", method=RequestMethod.GET)
    public String newFile(String folder, String path, String data){     
//      File file = new File("D:/home/site/wwwroot/testfile");      
        File file = new File( folder );
        file.mkdirs();
        try {
//          BufferedWriter writer = new BufferedWriter( new FileWriter("D:/home/site/wwwroot/testfile/cout.txt") );
            BufferedWriter writer = new BufferedWriter( new FileWriter( path ) );    
            writer.write( data );       
            writer.flush();
            writer.close();   
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        return "hello world";
    }

This is the correct idom (and it works fine):

   InputStream in = null;
   OutputStream out = null;
   try {
       in = new FileInputStream(inputFileName);
       out = new FileOutputStream(outputFileName);
       copy(in, out);
   finally {
       close(in);
       close(out);
   }

  public static void close(Closeable c) {
     if (c == null) return; 
     try {
         c.close();
     } catch (IOException e) {
         //log the exception
     }
  }

The reason this works fine is that the exception thrown before you got to finally will be thrown after your finally code finishes, provided that your finally code doesn't itself throw an exception or otherwise terminate abnormally.

Edit: As of Java 7 (and Android SDK 19 - KitKat) there is now a Try with resources syntax to make this cleaner. How to deal with that is addressed in this question.

Note that the following is only applicable for Java 6 and earlier. For Java 7 and later, you should switch to using try-with-resources ... as described in other answers.

If you are trying to catch and report all exceptions at source (in Java 6 or earlier), a better solution is this:

ObjectOutputStream oos = null;
try {
   oos = new ObjectOutputStream(new FileOutputStream(file));
   oos.writeObject(shapes);
   oos.flush();
} catch (FileNotFoundException ex) {
    // complain to user
} catch (IOException ex) {
    // notify user
} finally {
    if (oos != null) {
        try {
            oos.close();
        } catch (IOException ex) {
            // ignore ... any significant errors should already have been
            // reported via an IOException from the final flush.
        }
    }
}

Notes:

• The standard Java wrapper streams, readers and writers all propagate close and flush to their wrapped streams, etc. So you only need to close or flush the outermost wrapper.
• The purpose of flushing explicitly at the end of the try block is so that the (real) handler for IOException gets to see any write failures¹.
• When you do a close or flush on an output stream, there is a "once in a blue moon" chance that an exception will be thrown due to disc errors or file system full. You should not squash this exception!.

If you often have to "close a possibly null stream ignoring IOExceptions", then you could write yourself a helper method like this:

public void closeQuietly(Closeable closeable) {
    if (closeable != null) {
        try {
            closeable.close();
        } catch (IOException ex) {
            // ignore
        }
    }
}

then you can replace the previous finally block with:

} finally {
    closeQuietly(oos);
}

Another answer points out that a closeQuietly method is already available in an Apache Commons library ... if you don't mind adding a dependency to your project for a 10 line method.

But be careful that you only use closeQuietly on streams where IO exceptions really are irrelevant.

UPDATE : closeQuietly is deprecated in version 2.6 of the Apache Commons API. Java 7+ try-with-resources makes it redundant.

On the issue of flush() versus close() that people were asking about in comments:

• The standard "filter" and "buffered" output streams and writers have an API contract that states that close() causes all buffered output to be flushed. You should find that all other (standard) output classes that do output buffering will behave the same way. So, for a standard class it is redundant to call flush() immediately before close().

• For custom and 3rd-party classes, you need to investigate (e.g. read the javadoc, look at the code), but any close() method that doesn't flush buffered data is arguably broken.

• Finally, there is the issue of what flush() actually does. What the javadoc says is this (for OutputStream ...)

  If the intended destination of this stream is an abstraction provided by the underlying operating system, for example a file, then flushing the stream guarantees only that bytes previously written to the stream are passed to the operating system for writing; it does not guarantee that they are actually written to a physical device such as a disk drive.

  So ... if you hope / imagine that calling flush() guarantees that your data will persist, you are wrong! (If you need to do that kind of thing, look at the FileChannel.force method ...)

How to handle any kind of exception is essential to Java development. There is two ways to do it:

public void write(String text) //notice I deleted the throw
{
    try{
        FileWriter writer = new FileWriter(path, true);
        PrintWriter printer = new PrintWriter(writer);
        printer.printf("%s" + "%n", text);
        printer.close();
    catch(IOException ioe){
        //you write here code if an ioexcepion happens. You can leave it empty if you want
    }
}

and...

public void write(String text) throws IOException //See here it says throws IOException. You must then handle the exception when calling the method
{
    FileWriter writer = new FileWriter(path, true);
    PrintWriter printer = new PrintWriter(writer);
    printer.printf("%s" + "%n", text);
    printer.close();
}

//like this:
public static void main(String[] args) //or wherever you are calling write from
{
    try{
            write("hello"); //this call can throw an exception which must be caught somewhere
        }catch(IOException ioe){/*whatever*/}
}