Como combinar caminhos em Java?

Existe um equivalente Java para System.IO.Path.Combine()em C # /. NET? Ou algum código para fazer isso?

Este método estático combina uma ou mais seqüências de caracteres em um caminho.

Em vez de manter tudo baseado em cadeias, você deve usar uma classe projetada para representar um caminho do sistema de arquivos.

Se você estiver usando Java 7 ou Java 8, considere fortemente o uso java.nio.file.Path; Path.resolvepode ser usado para combinar um caminho com outro ou com uma string. A Pathsclasse auxiliar também é útil. Por exemplo:

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

Se você precisar atender a ambientes pré-Java-7, poderá usar o java.io.Fileseguinte:

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

Se você quiser voltar como uma sequência posteriormente, poderá ligar getPath(). De fato, se você realmente quisesse imitar Path.Combine, poderia escrever algo como:

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

No Java 7, você deve usar resolve:

Path newPath = path.resolve(childPath);

Embora a classe Path NIO2 possa parecer um pouco redundante para File com uma API desnecessariamente diferente, ela é de fato sutilmente mais elegante e robusta.

Observe que Paths.get()(como sugerido por outra pessoa) não tem uma sobrecarga usando a Path, e fazer Paths.get(path.toString(), childPath)NÃO é a mesma coisa que resolve(). Dos Paths.get()documentos :

Observe que, embora esse método seja muito conveniente, sua utilização implicará uma referência assumida ao FileSystem padrão e limitará o utilitário do código de chamada. Portanto, não deve ser usado no código da biblioteca destinado à reutilização flexível. Uma alternativa mais flexível é usar uma instância Path existente como uma âncora, como:

Path dir = ...
Path path = dir.resolve("file");

A função irmã resolveé a excelente relativize:

Path childPath = path.relativize(newPath);

A resposta principal é usar objetos de arquivo. No entanto, o Commons IO tem uma classe FilenameUtils que pode fazer esse tipo de coisa, como o método concat () .

Eu sei que faz muito tempo desde a resposta original de Jon, mas eu tinha um requisito semelhante ao do OP.

Como forma de estender a solução de Jon, vim com o seguinte, o qual seguirá um ou mais segmentos do caminho, tantos segmentos do caminho que você puder lançar nele.

Uso

Path.combine("/Users/beardtwizzle/");
Path.combine("/", "Users", "beardtwizzle");
Path.combine(new String[] { "/", "Users", "beardtwizzle", "arrayUsage" });

Código aqui para outras pessoas com um problema semelhante

public class Path {
    public static String combine(String... paths)
    {
        File file = new File(paths[0]);

        for (int i = 1; i < paths.length ; i++) {
            file = new File(file, paths[i]);
        }

        return file.getPath();
    }
}

abordagem independente de plataforma (usa File.separator, ou seja, funcionará depende do sistema operacional em que o código está sendo executado:

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

Para aprimorar a resposta do JodaStephen, o Apache Commons IO possui o FilenameUtils, que faz isso. Exemplo (no Linux):

assert org.apache.commons.io.FilenameUtils.concat("/home/bob", "work\\stuff.log") == "/home/bob/work/stuff.log"

É independente da plataforma e produzirá os separadores que seu sistema precisar.

Aqui está uma solução que lida com várias partes do caminho e condições da aresta:

public static String combinePaths(String ... paths)
{
  if ( paths.length == 0)
  {
    return "";
  }

  File combined = new File(paths[0]);

  int i = 1;
  while ( i < paths.length)
  {
    combined = new File(combined, paths[i]);
    ++i;
  }

  return combined.getPath();
}

Se você não precisar de mais do que strings, poderá usar com.google.common.io.Files

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

para obter

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

Talvez esteja atrasado para a festa, mas eu queria compartilhar minha opinião sobre isso. Estou usando um padrão Builder e permiti appendchamadas em cadeia convenientemente . Ele pode ser facilmente estendido para suportar o trabalho com Pathobjetos também.

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);
    }
}

Exemplo de uso:

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();

O resultado absoluteconterá algo como:

/hello/world/warez.lha

ou talvez até:

A:\hello\world\warez.lha

Isso também funciona no Java 8:

Path file = Paths.get("Some path");
file = Paths.get(file + "Some other path");

Esta solução oferece uma interface para juntar fragmentos de caminho de uma matriz String []. Ele usa java.io.File.File (String pai, String filho) :

    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;
    }

Então você pode simplesmente fazer:

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

Devoluções:

"/dir/anotherDir/filename.txt"