Java 8 Solution

 Path source = Paths.get(this.getClass().getResource("/").getPath());
        Path newFolder = Paths.get(source.toAbsolutePath() + "/newFolder/");
        Files.createDirectories(newFolder);

This will surely create new folder in resource folder. but you will find new folder in your target runtime.

which will be ProjectName/target/test-classes/newFolder. if you are running this code in test case. Other wise it would be in target/classes

Don't try to find new folder in your src/resources. it will be surely in target/test-classes or target/classes.

A program should never attempt to modify itself.

• The src/main/resources directory is called “source” for a reason. Source code is compiled into a separate program. The program only contains the executable program (class files and data), not the source.
• Java programs are distributed as .jar files (or jlink’d images made from .jar files). A .jar file is one file, specifically an archive file, and its individual entries are not files and are not writable.

In summary: when other people run your code, there is nothing you can modify.

The correct way to persist user data is to write it to a known location, usually somewhere under the user’s home directory.

It is perfectly acceptable to keep read-only default data bundled with your application, which gets used if the file in the user’s known location isn’t found.

The src/main/resources folder is a folder that is supposed to contain resources for your application. As you noted, maven packages these files to the root of your file so that you can access them in your library.

Have a look at the Maven documentation about the standard directory layout.

In certain cases, it is possible to write to the context but it is not a good idea to try it. Depending on how your webapp is deployed, you might not be able to write into the directory. Consider the case when you deploy a .war archive. This would mean that you try to write into the war archive and this won't be possible.

A better idea would be to use a temporary file. In that way you can be sure this will work, regardless of the way your web application is deployed.

You can't write something in to a resource, assume that you packed your resource as a jar. Jar is only read only. You can't update that. Either you can extract the jar and edit the contents.

You can try Preferences as an alternative

Something is totally wrong if you are creating dynamically file in src/main/resources This is only going to work in your development environment. When you deploy your code using Jar or War there won't be this directory on file system. It will be contained within Jar / War or other packaging.

If you understand above and still want to do it. Go related to your current working directory to create file, Usually the working directory when you launch your Main from IDE is setup to root of project so create a file at

src/main/resources/foo.txt

will do it. Alternatively you can figure out your current working directory from your IDE launcher or at runtime using

System.getProperty("user.dir");

If you want to create a test.xml file in the directory returned by getResource(), try this:

File file = new File(classLoader.getResource(".").getFile() + "/test.xml");
if (file.createNewFile()) {
    System.out.println("File is created!");
} else {
    System.out.println("File already exists.");
}

Calling getFile() on a non-existent directory or file will return null, as explained in Reid's answer.

Try the next:

ClassLoader classloader = Thread.currentThread().getContextClassLoader();
InputStream is = classloader.getResourceAsStream("test.csv");

If the above doesn't work, various projects have been added the following class: ClassLoaderUtil¹ (code here).²

Here are some examples of how that class is used:

src\main\java\com\company\test\YourCallingClass.java
src\main\java\com\opensymphony\xwork2\util\ClassLoaderUtil.java
src\main\resources\test.csv

// java.net.URL
URL url = ClassLoaderUtil.getResource("test.csv", YourCallingClass.class);
Path path = Paths.get(url.toURI());
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);

// java.io.InputStream
InputStream inputStream = ClassLoaderUtil.getResourceAsStream("test.csv", YourCallingClass.class);
InputStreamReader streamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
BufferedReader reader = new BufferedReader(streamReader);
for (String line; (line = reader.readLine()) != null;) {
    // Process line
}

Notes

1. See it in The Wayback Machine.
2. Also in GitHub.

When at the "Add resource folder", Build Path -> Configure Build Path -> Source (Tab) -> Add Folder -> Create new Folder

add "my-resource.txt" file inside the new folder. Then in your code:

    InputStream res =
    Main.class.getResourceAsStream("/my-resource.txt");

    BufferedReader reader =
        new BufferedReader(new InputStreamReader(res));
    String line = null;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
    reader.close();