Comment combiner des tracés en Java?

Plutôt que de garder tout basée sur une chaîne, vous devez utiliser une classe qui est conçu pour représenter un chemin du système de fichiers.

Si vous êtes à l'aide de Java 7 ou Java 8, vous devriez sérieusement envisager de l'utiliser java.nio.fichier.Path; Path.resolve peut être utilisé pour combiner un chemin avec un autre, ou avec une chaîne. Le Chemins de la classe helper est utile aussi. Par exemple:

Path path = Paths.get("foo", "bar", "baz.txt");

Si vous avez besoin pour répondre à la pré-Java-7 environnements, vous pouvez utiliser java.io.Fichier, comme ceci:

File baseDirectory = new File("foo");
File subDirectory = new File(baseDirectory, "bar");
File fileInDirectory = new File(subDirectory, "baz.txt");

Si vous voulez à nouveau comme une chaîne de caractères plus tard, vous pouvez appeler getPath(). En effet, si vous avez vraiment voulu imiter Path.Combine, vous pouvez simplement écrire quelque chose comme:

public static String combine(String path1, String path2)
{
    File file1 = new File(path1);
    File file2 = new File(file1, path2);
    return file2.getPath();
}

La principale réponse est d'utiliser les objets de Fichier. Cependant Commons IO dispose d'une classe FilenameUtils qui peut faire ce genre de chose, comme le concat() méthode.

indépendant de la plateforme approche (utilise le Fichier.séparateur, ie les travaux dépend de système d'exploitation, là où le code est en cours d'exécution:

java.nio.file.Paths.get(".", "path", "to", "file.txt")
//relative unix path: ./path/to/file.txt
//relative windows path: .\path\to\filee.txt

java.nio.file.Paths.get("/", "path", "to", "file.txt")
//absolute unix path: /path/to/filee.txt
//windows network drive path: \\path\to\file.txt

java.nio.file.Paths.get("C:", "path", "to", "file.txt")
//absolute windows path: C:\path\to\file.txt

Si vous n'avez pas besoin de plus que des chaînes de caractères, vous pouvez utiliser com.google.commun.io.Fichiers

Files.simplifyPath("some/prefix/with//extra///slashes" + "file//name")

pour obtenir

"some/prefix/with/extra/slashes/file/name"

La fin de la partie, peut-être, mais je voulais partager mon point de vue sur ce. Je suis à l'aide d'un Générateur de modèle et de permettre idéalement enchaîné append appels. Il peut facilement être étendu pour prendre en charge le travail avec Path objets.

public class Files  {
    public static class PathBuilder {
        private File file;

        private PathBuilder ( File root ) {
            file = root;
        }

        private PathBuilder ( String root ) {
            file = new File(root);
        }

        public PathBuilder append ( File more ) {
            file = new File(file, more.getPath()) );
            return this;
        }

        public PathBuilder append ( String more ) {
            file = new File(file, more);
            return this;
        }

        public File buildFile () {
            return file;
        }
    }

    public static PathBuilder buildPath ( File root ) {
        return new PathBuilder(root);
    }

    public static PathBuilder buildPath ( String root ) {
        return new PathBuilder(root);
    }
}

Exemple d'utilisation:

File root = File.listRoots()[0];
String hello = "hello";
String world = "world";
String filename = "warez.lha"; 

File file = Files.buildPath(root).append(hello).append(world)
              .append(filename).buildFile();
String absolute = file.getAbsolutePath();

L'résultant absolute contiendra quelque chose comme:

/hello/world/warez.lha

ou peut-être même:

A:\hello\world\warez.lha

Cette solution offre une interface pour rejoindre le chemin des fragments d'un String[] tableau. Il utilise java.io.Fichier.Fichier(Chaîne de parent, String enfant):

    public static joinPaths(String[] fragments) {
        String emptyPath = "";
        return buildPath(emptyPath, fragments);
    }

    private static buildPath(String path, String[] fragments) {
        if (path == null || path.isEmpty()) {
            path = "";
        }

        if (fragments == null || fragments.length == 0) {
            return "";
        }

        int pathCurrentSize = path.split("/").length;
        int fragmentsLen = fragments.length;

        if (pathCurrentSize <= fragmentsLen) {
            String newPath = new File(path, fragments[pathCurrentSize - 1]).toString();
            path = buildPath(newPath, fragments);
        }

        return path;
    }

Alors vous pouvez simplement faire:

String[] fragments = {"dir", "anotherDir/", "/filename.txt"};
String path = joinPaths(fragments);

Retourne:

"/dir/anotherDir/filename.txt"