Re: Resource confusion

If you're going to use .getResource(), the String "name" that you supply
is actually a '/'-separated path name that identifies something on a
classloader classpath. You have a number of classloaders involved every
time you run your app; fact is that your phrase-list file (even if you
had a '/'-separated path spec for it) very likely isn't on the classpath
for any of those classloaders.

It doesn't sound to me like you need either the getResource() or
getResourceAsStream() approaches (which are available through
ClassLoader or delegated from Class); you might be better off saving and
using file URLs.

The exact form of a file URL varies across systems but they all have the
file: scheme. On a UNIX system

URL phraseListUrl = new URL("file:///home/me/Games/PhraseLists");

would work, but off the top of my head on a Windows box it's something like

URL phraseListUrl = new URL("file:///C:/Games/PhraseLists");

This is just informational, because your app doesn't have to construct
these things, just save them. Your user does the heavy lifting by
selecting the location with a file chooser; that gives you a File
object. You can save out the result with

userSelectedFile.toURI().toURL().toString()

To return to getResource() or getResourceAsStream(), and classloaders:
the situation is more complicated in Java application server
environments [1], and for this reason context classloaders were made
available as (imperfect) solutions. But you are not in that scenario.

I'll also add that *if* it made sense for you to have a file resource on
the classpath, and you were using getResource() or
getResourceAsStream(), it doesn't make sense for you to pose the
question "which classloader should I use?" That's not *your* decision to
make, per se - you can influence that choice by where you place the
resource, but you don't directly select a classloader (again, unless you
were in a server environment and using a context classloader).

AHS

1. As anyone can attest who has spent quality hours wrestling with a
situation where instance 1 of class X hasn't the same class as instance
2 of class X...for various reasons.