该解决方案提供了一个接口，用于连接String[]数组中的路径片段。它使用java.io.File。文件(父字符串，子字符串):

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

然后你可以这样做:

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

返回:

"/dir/anotherDir/filename.txt"

下面是一个处理多路径部分和边缘条件的解决方案:

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

我知道距离Jon最初的回答已经有很长时间了，但我对OP有类似的要求。

通过扩展Jon的解决方案，我想出了下面的方法，这将占用一个或多个路径段占用尽可能多的路径段。

使用

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

这里为其他有类似问题的人编写代码

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

也许来晚了，但我想分享一下我对这件事的看法。我不喜欢把整个库都拉来做这样的事情。相反，我使用Builder模式，并允许方便地链式附加(更多)调用。它甚至允许混合文件和字符串，并且可以很容易地扩展到支持路径。此外，它可以在Linux、Macintosh等上自动正确地处理不同的路径分隔符。

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

用法示例:

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

生成的绝对值将包含如下内容:

/hello/world/warez.lha

或者甚至:

A:\hello\world\warez.lha

为了加强JodaStephen的回答，Apache Commons IO有FilenameUtils。示例(Linux):

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

它是平台独立的，可以生成系统所需的任何分隔符。

如果只需要字符串，可以使用com.google.common.io.Files

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

得到

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