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.

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.

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

As the comments already say, files in the JARs are considered read-only.

You have to create a file at some user or installation directory based location (or a location chosen by the user).

If you have pre-configured data you have at least 2 options:

• Ship the file along the JAR file using some kind of packaging tool (can also be a ZIP file). For ZIP files have a look at the Maven Assembly Plugin, if you're using Maven.
• Extract the file from the JAR.

For the latter use case I've written some utility classes:

public void extractResource(String resourcePathString, Path targetDirPath) throws IOException, URISyntaxException {  
    URI jarURI = JarFiles.getJarURI(SomeClassInTheJar.class);  
    try (FileSystem jarFS = JarFiles.newJarFileSystem(jarURI)) {  
        Path resourcePath = jarFS.getPath(resourcePathString);  

        CopyFileVisitor.copy(resourcePath, targetDirPath);  
    }  
}  

With the help of CopyFileVisitor you can easily recursively extract/ add directories from/ to JAR or ZIP files, as CopyFileVisitor uses PathUtils and thus works across file systems.

JarFiles.getJarURI gets the JAR URI of a class.

For more information have a look at the tutorial: https://www.softsmithy.org/softsmithy-lib/lib/2.1.1/docs/tutorial/nio-file/index.html#ExtractJarResourceSample

The library is Open Source. You can get it from Maven Central:

        <dependency>
            <groupId>org.softsmithy.lib</groupId>
            <artifactId>softsmithy-lib-core</artifactId>
            <version>2.1.1</version>
        </dependency>

You can output text to a file in the resources folder, but the process is a bit tedious.

1. Tell Maven to write the location of your resources folder into a file
2. Read the location of your resources folder in Java
3. Use that location to write your file to

Notes

• Why bother specifying the location of your resources folder file? Isn't it src/main/resources always? Well no, if you have a nested module structure like

  rootModule   
  ├─ childModule1   
  │  └─ src    
  │     └─ main    
  │        └─ resources    
  └─ childModule2 
     └─ ...  
  

  then the relative path src/main/resources resolves to parentModule/src/main/resources which does not exist.

• Once you write the file to the resources folder, it will not be accessible through Class.getResource(). Class.getResource() provides you with read access to files located in your classpath. The files located in your resources folder are "copied" to your binary output folder (read classpath) during "compilation". In order to access your newly created resource file with the help of Class.getResource(), you will have to recompile & restart the application. However, you can still access it by the location you used for writing the file.

Guide

1. add RESOURCE_PATH property to the Maven pom, and tell Maven to compile properties found in resource files
2. add an utility file src/main/resources/RESOURCE_PATH, which only contains the RESOURCE_PATH property
3. extract the RESOURCE_PATH property from the utility file in Java
4. rebuild the project if needed (e.g. if file/folder structure changes)

POM

<project>
    ...
    <properties>
        <RESOURCE_PATH>${project.basedir}/src/main/resources</RESOURCE_PATH>
    </properties>
    ...
    <build>
        ...
        <resources>
            <resource>
                <directory>${RESOURCE_PATH}</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
        ....
    </build>
    ...
</project>

Utility file (src/main/resources/RESOURCE_PATH)

${RESOURCE_PATH}

Java

/**
 * Reads the relative path to the resource directory from the <code>RESOURCE_PATH</code> file located in
 * <code>src/main/resources</code>
 * @return the relative path to the <code>resources</code> in the file system, or
 *         <code>null</code> if there was an error
 */
private static String getResourcePath() {
    try {
        URI resourcePathFile = System.class.getResource("/RESOURCE_PATH").toURI();
        String resourcePath = Files.readAllLines(Paths.get(resourcePathFile)).get(0);
        URI rootURI = new File("").toURI();
        URI resourceURI = new File(resourcePath).toURI();
        URI relativeResourceURI = rootURI.relativize(resourceURI);
        return relativeResourceURI.getPath();
    } catch (Exception e) {
        return null;
    }
}

public static void main(String[] args) throws URISyntaxException, IOException {
    File file = new File(getResourcePath() + "/abc.txt");
    // write something to file here
    System.out.println(file.lastModified());
}

I hope that works. Maybe you need maven resources:resources plugin and do mvn generate-resources process-resources

You can't write to files inside your JAR file, because they aren't actually files, they are ZIP entries.

The easiest way to store configuration for a Java application is to use Preferences:

Preferences prefs = Preferences.userNodeForPackage(MyApp.class);

Now all you have to do is use any of the get methods to read, and put methods to write.

For input, try below:

     InputStreamReader isReader = 
                      new InputStreamReader(
                          this.getClass().getResourceAsStream(templateName));
      BufferedReader br = new BufferedReader(isReader);     

or

     InputStreamReader isReader = 
                      new InputStreamReader(
                          <youclassName>.class.getResourceAsStream(templateName));
      BufferedReader br = new BufferedReader(isReader);   

For output, try below:

      PrintWriter writer = 
               new PrintWriter(
                     new File(this.getClass().getResource(templateName).getPath()));