Esiste un equivalente Java per System.IO.Path.Combine()
in C # /. NET? O qualche codice per raggiungere questo obiettivo?
Questo metodo statico combina una o più stringhe in un percorso.
Esiste un equivalente Java per System.IO.Path.Combine()
in C # /. NET? O qualche codice per raggiungere questo obiettivo?
Questo metodo statico combina una o più stringhe in un percorso.
Risposte:
Invece di mantenere tutto basato su stringhe, è necessario utilizzare una classe progettata per rappresentare un percorso del file system.
Se stai usando Java 7 o Java 8, dovresti prendere in seria considerazione l'uso di java.nio.file.Path
; Path.resolve
può essere utilizzato per combinare un percorso con un altro o con una stringa. Anche la Paths
classe helper è utile. Per esempio:
Path path = Paths.get("foo", "bar", "baz.txt");
Se è necessario soddisfare ambienti pre-Java-7, è possibile utilizzare java.io.File
, in questo modo:
File baseDirectory = new File("foo");
File subDirectory = new File(baseDirectory, "bar");
File fileInDirectory = new File(subDirectory, "baz.txt");
Se lo desideri indietro come stringa in seguito, puoi chiamare getPath()
. Infatti, se davvero volessi imitare Path.Combine
, potresti semplicemente scrivere qualcosa del tipo:
public static String combine(String path1, String path2)
{
File file1 = new File(path1);
File file2 = new File(file1, path2);
return file2.getPath();
}
path2
(ignorando path1
) se path2
è un percorso assoluto. La versione Java scenderà leader /
o \
e trattarlo come un percorso relativo.
File.getCanonicalPath
.
File
in C # se lo desideri. (Suppongo che tu intenda l'esistenza di File
un vantaggio, di cui concordo.)
In Java 7, dovresti usare resolve
:
Path newPath = path.resolve(childPath);
Mentre la classe Path NIO2 può sembrare un po 'ridondante a File con un'API inutilmente diversa, in realtà è sottilmente più elegante e robusta.
Nota che Paths.get()
(come suggerito da qualcun altro) non ha un sovraccarico che prende un Path
, e fare Paths.get(path.toString(), childPath)
NON è la stessa cosa di resolve()
. Dai Paths.get()
documenti :
Si noti che sebbene questo metodo sia molto conveniente, l'utilizzo di esso implica un riferimento presupposto al FileSystem predefinito e limita l'utilità del codice chiamante. Quindi non dovrebbe essere usato nel codice della libreria destinato al riutilizzo flessibile. Un'alternativa più flessibile consiste nell'utilizzare un'istanza Path esistente come ancora, ad esempio:
Path dir = ... Path path = dir.resolve("file");
La funzione sorella resolve
è l'eccellente relativize
:
Path childPath = path.relativize(newPath);
La risposta principale è usare gli oggetti File. Tuttavia Commons IO ha una classe FilenameUtils che può fare questo tipo di cose, come il metodo concat () .
So che è molto tempo dalla risposta originale di Jon, ma avevo un requisito simile al PO.
Per estendere la soluzione di Jon ho escogitato quanto segue, che prenderà uno o più segmenti di percorso prendendo il maggior numero di segmenti di percorso che puoi lanciarvi.
uso
Path.combine("/Users/beardtwizzle/");
Path.combine("/", "Users", "beardtwizzle");
Path.combine(new String[] { "/", "Users", "beardtwizzle", "arrayUsage" });
Codice qui per gli altri con un problema simile
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();
}
}
approccio indipendente dalla piattaforma (utilizza File.separator, ovvero funzionerà in base al sistema operativo in cui è in esecuzione il codice:
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
Per migliorare la risposta di JodaStephen, Apache Commons IO ha FilenameUtils che lo fa. Esempio (su Linux):
assert org.apache.commons.io.FilenameUtils.concat("/home/bob", "work\\stuff.log") == "/home/bob/work/stuff.log"
È indipendente dalla piattaforma e produrrà qualsiasi separatore di cui il tuo sistema ha bisogno.
Ecco una soluzione che gestisce più parti del percorso e condizioni dei bordi:
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 non hai bisogno di più di stringhe, puoi utilizzare com.google.common.io.Files
Files.simplifyPath("some/prefix/with//extra///slashes" + "file//name")
ottenere
"some/prefix/with/extra/slashes/file/name"
Forse in ritardo alla festa, ma volevo condividere la mia opinione su questo. Sto usando un modello Builder e consento append
chiamate concatenate . Può essere facilmente esteso per supportare anche il lavoro con Path
oggetti.
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);
}
}
Esempio di utilizzo:
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();
Il risultato absolute
conterrà qualcosa come:
/hello/world/warez.lha
o forse anche:
A:\hello\world\warez.lha
Questo funziona anche in Java 8:
Path file = Paths.get("Some path");
file = Paths.get(file + "Some other path");
Questa soluzione offre un'interfaccia per unire frammenti di percorso da un array String []. Utilizza java.io.File.File (String parent, String child) :
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;
}
Quindi puoi semplicemente fare:
String[] fragments = {"dir", "anotherDir/", "/filename.txt"};
String path = joinPaths(fragments);
Ritorna:
"/dir/anotherDir/filename.txt"