Can you use 2 java nio file systems in one program?

I am writing a project that will generate a folder structure from a template folder structure (which I package inside my jar as a resource). I want to keep all the resources inside my program's jar file, so my users will only have to know about this one jar file, without having to worry about a separate resource folder.

I have this code here (Scala code using java libraries):

package ru.company.project
import java.nio.file.{FileSystems, Files, Path, Paths}
import java.util
object Main {
def main(args: Array[String]): Unit = {
val uri = this.getClass.getClassLoader.getResource("resource1").toURI
// create file system
val env = new util.HashMap[String, String]()
env.put("create", "true")
val jarFS = FileSystems.newFileSystem(uri, env)
val file = Paths.get(uri)
Files.walk(file).forEach(f => {
println(f)
if (Files.isRegularFile(f))
copyToLocal(f)
})
jarFS.close()
}
def copyToLocal(file: Path): Unit = {
val content = Files.readAllLines(file)
Files.write(file, content)
}
}

It is able to read the resources from my jar file just fine, but when it executes Files.write(file, content) in copyToLocal, it fails with this exception:

Exception in thread "main" java.nio.file.FileAlreadyExistsException: resource1/another_text_file.txt
at com.sun.nio.zipfs.ZipFileSystem.newOutputStream(ZipFileSystem.java:516)
at com.sun.nio.zipfs.ZipPath.newOutputStream(ZipPath.java:790)
at com.sun.nio.zipfs.ZipFileSystemProvider.newOutputStream(ZipFileSystemProvider.java:285)
at java.nio.file.Files.newOutputStream(Unknown Source)
at java.nio.file.Files.write(Unknown Source)
at java.nio.file.Files.write(Unknown Source)
at ru.company.project.Main$.copyToLocal(Main.scala:28)
at ru.company.project.Main$.$anonfun$main$1(Main.scala:20)
at java.util.stream.ForEachOps$ForEachOp$OfRef.accept(Unknown Source)
at java.util.stream.ReferencePipeline$3$1.accept(Unknown Source)
at java.util.Iterator.forEachRemaining(Unknown Source)
at java.util.Spliterators$IteratorSpliterator.forEachRemaining(Unknown Source)
at java.util.stream.AbstractPipeline.copyInto(Unknown Source)
at java.util.stream.AbstractPipeline.wrapAndCopyInto(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp.evaluateSequential(Unknown Source)
at java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(Unknown Source)
at java.util.stream.AbstractPipeline.evaluate(Unknown Source)
at java.util.stream.ReferencePipeline.forEach(Unknown Source)
at ru.company.project.Main$.main(Main.scala:17)
at ru.company.project.Main.main(Main.scala)

This is because I somehow need to use another file system to write outside the jar file, but it seems that when you do FilesSystems.newFileSystem it creates a global one.

So, how do I create another file system and use 2 file systems at the same time?

Your method copyToLocal(...) is wrong. It reads from a file and then writes back all read lines to the same file again. There is no 'magic mechanism' that 'knows' which file system to use for reading and which for writing.

So the main question is: How does an operation like Files.write(path, content) know, which FileSystem to use?

Answer: It uses the FileSystem that was used to create the path.

Longer answer: A Path object is always associated to a FileSystem. It always denotes a file or folder of a specific file system, so it holds both, the file system and the path itself.

All static methods of Files, like Files.delete(path) or Files.list(path) use the file systems associated with the given path. Methods that operate on more than one path, like Files.copy(source, target, options) are optimized in case both paths are from the same file system (which is the common case), but should also work across different file systems (as in your case).

If you use (1) the factory method Paths.get(first, ...more), the path is always associated to the default FileSystem. If your use (2) Paths.get(uri), all installed file system providers are searched for the file system. If (3) the getPath(...) method of a concrete FileSystem is used, the path is associated with this file system.

So you should use any of these three ways to control the file system that should be associated to your path, e.g.:

try(FileSystem jarFs = ...;
FileSystem defaultFs = ...) {
Path source = jarFs.getPath(...);
Path target = defaultFs.getPath(...);
Files.copy(source, target);
}

(code snippet is in Java, as I don't know Scala)

This means for your code:

...
val jarPath = Paths.get(uri)
Files.walk(jarPath).forEach(jarFile => {
println(jarFile)
if (Files.isRegularFile(jarFile))
Files.copy(jarFile, createLocalPathFor(jarFile))
})
...
def createLocalPathFor(path: Path): Path = {
// TODO: create a local path for the given file
// TODO: which local folder? which local file name?
return Paths.get(...)
}