it-swarm.com.de

Wie bekomme ich die Dateierweiterung einer Datei in Java?

Nur um klar zu sein, ich suche nicht nach dem MIME-Typ.

Nehmen wir an, ich habe folgende Eingabe: /path/to/file/foo.txt

Ich möchte eine Möglichkeit, diese Eingabe aufzubrechen, insbesondere in .txt für die Erweiterung. Gibt es eine integrierte Möglichkeit, dies in Java zu tun? Ich möchte es vermeiden, meinen eigenen Parser zu schreiben.

399
longda

Verwenden Sie in diesem Fall FilenameUtils.getExtension aus Apache Commons IO

Hier ein Beispiel für die Verwendung (Sie können entweder den vollständigen Pfad oder nur den Dateinamen angeben):

String ext1 = FilenameUtils.getExtension("/path/to/file/foo.txt"); // returns "txt"
String ext2 = FilenameUtils.getExtension("bar.exe"); // returns "exe"
557
Juan Rojas

Benötigen Sie wirklich einen "Parser" dafür?

String extension = "";

int i = fileName.lastIndexOf('.');
if (i > 0) {
    extension = fileName.substring(i+1);
}

Angenommen, es handelt sich um einfache, Windows-ähnliche Dateinamen, nicht um archive.tar.gz.

Übrigens, für den Fall, dass ein Verzeichnis ein '.' Hat, aber der Dateiname selbst nicht (wie /path/to.a/file), können Sie tun

String extension = "";

int i = fileName.lastIndexOf('.');
int p = Math.max(fileName.lastIndexOf('/'), fileName.lastIndexOf('\\'));

if (i > p) {
    extension = fileName.substring(i+1);
}
270
EboMike
private String getFileExtension(File file) {
    String name = file.getName();
    int lastIndexOf = name.lastIndexOf(".");
    if (lastIndexOf == -1) {
        return ""; // empty extension
    }
    return name.substring(lastIndexOf);
}
87
spectre

Wenn Sie die Bibliothek Guava verwenden, können Sie auf die Files utility-Klasse zurückgreifen. Es hat eine bestimmte Methode, getFileExtension() . Zum Beispiel:

String path = "c:/path/to/file/foo.txt";
String ext = Files.getFileExtension(path);
System.out.println(ext); //prints txt

Außerdem können Sie den Dateinamen mit einer ähnlichen Funktion erhalten: getNameWithoutExtension () :

String filename = Files.getNameWithoutExtension(path);
System.out.println(filename); //prints foo
77
JeanValjean

Unter Android können Sie Folgendes verwenden:

String ext = Android.webkit.MimeTypeMap.getFileExtensionFromUrl(file.getName());
28
intrepidis

Um Dateinamen ohne Zeichen vor dem Punkt zu berücksichtigen, müssen Sie diese geringfügige Variation der akzeptierten Antwort verwenden:

String extension = "";

int i = fileName.lastIndexOf('.');
if (i >= 0) {
    extension = fileName.substring(i+1);
}

"file.doc" => "doc"
"file.doc.gz" => "gz"
".doc" => "doc"
15
Sylvain Leroux

Mein schmutziger und winzigster Einsatz von String.replaceAll :

.replaceAll("^.*\\.(.*)$", "$1")

Beachten Sie, dass * zuerst gierig ist, also die meisten möglichen Zeichen so weit wie möglich erfasst, und dann nur der letzte Punkt und die Dateierweiterung übrig bleiben.

10
Ebrahim Byagowi

Dies ist eine getestete Methode

public static String getExtension(String fileName) {
    char ch;
    int len;
    if(fileName==null || 
            (len = fileName.length())==0 || 
            (ch = fileName.charAt(len-1))=='/' || ch=='\\' || //in the case of a directory
             ch=='.' ) //in the case of . or ..
        return "";
    int dotInd = fileName.lastIndexOf('.'),
        sepInd = Math.max(fileName.lastIndexOf('/'), fileName.lastIndexOf('\\'));
    if( dotInd<=sepInd )
        return "";
    else
        return fileName.substring(dotInd+1).toLowerCase();
}

Und Testfall:

@Test
public void testGetExtension() {
    assertEquals("", getExtension("C"));
    assertEquals("ext", getExtension("C.ext"));
    assertEquals("ext", getExtension("A/B/C.ext"));
    assertEquals("", getExtension("A/B/C.ext/"));
    assertEquals("", getExtension("A/B/C.ext/.."));
    assertEquals("bin", getExtension("A/B/C.bin"));
    assertEquals("hidden", getExtension(".hidden"));
    assertEquals("dsstore", getExtension("/user/home/.dsstore"));
    assertEquals("", getExtension(".strange."));
    assertEquals("3", getExtension("1.2.3"));
    assertEquals("exe", getExtension("C:\\Program Files (x86)\\Java\\bin\\javaw.exe"));
}
9
yavuzkavus

Wie aus allen anderen Antworten ersichtlich, gibt es keine ausreichende "eingebaute" Funktion. Dies ist eine sichere und einfache Methode.

String getFileExtension(File file) {
    if (file == null) {
        return "";
    }
    String name = file.getName();
    int i = name.lastIndexOf('.');
    String ext = i > 0 ? name.substring(i + 1) : "";
    return ext;
}
7
intrepidis

Wie wäre es (mit Java 1.5 RegEx):

    String[] split = fullFileName.split("\\.");
    String ext = split[split.length - 1];
6
Ninju Bohra

Wenn Sie vorhaben, Apache commons-io zu verwenden und nur die Dateierweiterung überprüfen und dann einige Operationen ausführen möchten, können Sie this verwenden. Hier ist ein Ausschnitt:

if(FilenameUtils.isExtension(file.getName(),"Java")) {
    someoperation();
}
6
Geng Jiawen

Hier ist eine Methode, die .tar.gz richtig behandelt, selbst in einem Pfad mit Punkten in Verzeichnisnamen:

private static final String getExtension(final String filename) {
  if (filename == null) return null;
  final String afterLastSlash = filename.substring(filename.lastIndexOf('/') + 1);
  final int afterLastBackslash = afterLastSlash.lastIndexOf('\\') + 1;
  final int dotIndex = afterLastSlash.indexOf('.', afterLastBackslash);
  return (dotIndex == -1) ? "" : afterLastSlash.substring(dotIndex + 1);
}

afterLastSlash wurde erstellt, um afterLastBackslash schneller zu finden, da nicht die gesamte Zeichenfolge durchsucht werden muss, wenn einige Schrägstriche darin sind.

Der char[] in der ursprünglichen String wird wiederverwendet und fügt dort keinen Müll hinzu, und die JVM wird wahrscheinlich feststellen, dass afterLastSlash sofort Müll ist, um ihn anstelle des Heap auf den Stapel zu legen.

4
Olathe

Wie wäre es mit JFileChooser? Es ist nicht einfach, da Sie die endgültige Ausgabe analysieren müssen ...

JFileChooser filechooser = new JFileChooser();
File file = new File("your.txt");
System.out.println("the extension type:"+filechooser.getTypeDescription(file));

welches ist ein MIME-Typ ...

OK ... Ich habe vergessen, dass Sie den MIME-Typ nicht kennen möchten.

Interessanter Code in folgendem Link: http://download.Oracle.com/javase/tutorial/uiswing/components/filechooser.html

/*
 * Get the extension of a file.
 */  
public static String getExtension(File f) {
    String ext = null;
    String s = f.getName();
    int i = s.lastIndexOf('.');

    if (i > 0 &&  i < s.length() - 1) {
        ext = s.substring(i+1).toLowerCase();
    }
    return ext;
}

Verwandte Frage: Wie schneide ich eine Dateierweiterung von einem String in Java ab?

4
eee

Hier ist die Version mit Optional als Rückgabewert (da Sie nicht sicher sein können, ob die Datei eine Erweiterung hat) ... 

import Java.io.File;
import Java.util.Optional;

public class GetFileExtensionTool {

    public static Optional<String> getFileExtension(File file) {
        if (file == null) {
            throw new NullPointerException("file argument was null");
        }
        if (!file.isFile()) {
            throw new IllegalArgumentException("getFileExtension(File file)"
                    + " called on File object that wasn't an actual file"
                    + " (perhaps a directory or device?). file had path: "
                    + file.getAbsolutePath());
        }
        String fileName = file.getName();
        int i = fileName.lastIndexOf('.');
        if (i > 0) {
            return Optional.of(fileName.substring(i + 1));
        } else {
            return Optional.empty();
        }
    }
}
2
schuttek

Wie wäre es mitREGEXversion:

static final Pattern PATTERN = Pattern.compile("(.*)\\.(.*)");

Matcher m = PATTERN.matcher(path);
if (m.find()) {
    System.out.println("File path/name: " + m.group(1));
    System.out.println("Extention: " + m.group(2));
}

oder mit unterstützter NULL-Erweiterung:

static final Pattern PATTERN =
    Pattern.compile("((.*\\" + File.separator + ")?(.*)(\\.(.*)))|(.*\\" + File.separator + ")?(.*)");

class Separated {
    String path, name, ext;
}

Separated parsePath(String path) {
    Separated res = new Separated();
    Matcher m = PATTERN.matcher(path);
    if (m.find()) {
        if (m.group(1) != null) {
            res.path = m.group(2);
            res.name = m.group(3);
            res.ext = m.group(5);
        } else {
            res.path = m.group(6);
            res.name = m.group(7);
        }
    }
    return res;
}


Separated sp = parsePath("/root/docs/readme.txt");
System.out.println("path: " + sp.path);
System.out.println("name: " + sp.name);
System.out.println("Extention: " + sp.ext);

ergebnis für * nix:
pfad:/root/docs /
name: readme
Erweiterung: txt

für Windows parsePath ("c:\windows\readme.txt"):
pfad: c:\windows \
name: readme
Erweiterung: txt

2
Dmitry Sokolyuk

Dateierweiterung aus Dateiname abrufen

/**
 * The extension separator character.
 */
private static final char EXTENSION_SEPARATOR = '.';

/**
 * The Unix separator character.
 */
private static final char UNIX_SEPARATOR = '/';

/**
 * The Windows separator character.
 */
private static final char WINDOWS_SEPARATOR = '\\';

/**
 * The system separator character.
 */
private static final char SYSTEM_SEPARATOR = File.separatorChar;

/**
 * Gets the extension of a filename.
 * <p>
 * This method returns the textual part of the filename after the last dot.
 * There must be no directory separator after the dot.
 * <pre>
 * foo.txt      --> "txt"
 * a/b/c.jpg    --> "jpg"
 * a/b.txt/c    --> ""
 * a/b/c        --> ""
 * </pre>
 * <p>
 * The output will be the same irrespective of the machine that the code is running on.
 *
 * @param filename the filename to retrieve the extension of.
 * @return the extension of the file or an empty string if none exists.
 */
public static String getExtension(String filename) {
    if (filename == null) {
        return null;
    }
    int index = indexOfExtension(filename);
    if (index == -1) {
        return "";
    } else {
        return filename.substring(index + 1);
    }
}

/**
 * Returns the index of the last extension separator character, which is a dot.
 * <p>
 * This method also checks that there is no directory separator after the last dot.
 * To do this it uses {@link #indexOfLastSeparator(String)} which will
 * handle a file in either Unix or Windows format.
 * <p>
 * The output will be the same irrespective of the machine that the code is running on.
 *
 * @param filename  the filename to find the last path separator in, null returns -1
 * @return the index of the last separator character, or -1 if there
 * is no such character
 */
public static int indexOfExtension(String filename) {
    if (filename == null) {
        return -1;
    }
    int extensionPos = filename.lastIndexOf(EXTENSION_SEPARATOR);
    int lastSeparator = indexOfLastSeparator(filename);
    return (lastSeparator > extensionPos ? -1 : extensionPos);
}

/**
 * Returns the index of the last directory separator character.
 * <p>
 * This method will handle a file in either Unix or Windows format.
 * The position of the last forward or backslash is returned.
 * <p>
 * The output will be the same irrespective of the machine that the code is running on.
 *
 * @param filename  the filename to find the last path separator in, null returns -1
 * @return the index of the last separator character, or -1 if there
 * is no such character
 */
public static int indexOfLastSeparator(String filename) {
    if (filename == null) {
        return -1;
    }
    int lastUnixPos = filename.lastIndexOf(UNIX_SEPARATOR);
    int lastWindowsPos = filename.lastIndexOf(WINDOWS_SEPARATOR);
    return Math.max(lastUnixPos, lastWindowsPos);
}

Credits

  1. Aus Apache FileNameUtils-Klasse kopiert - http://grepcode.com/file/repo1.maven.org/maven2/commons-io/commons-io/1.3.2/org/Apache/commons/io/FilenameUtils.Java # FilenameUtils.getExtension% 28Java.lang.String% 29
1
Vasanth

Ohne Verwendung einer Bibliothek können Sie die String-Methode wie folgt verwenden:

        String[] splits = fileNames.get(i).split("\\.");

        String extension = "";

        if(splits.length >= 2)
        {
            extension = splits[splits.length-1];
        }
1
Farah
String extension = com.google.common.io.Files.getFileExtension("fileName.jpg");
1
Alfaville

Hier ist ein weiterer One-Liner für Java 8. 

String ext = Arrays.stream(fileName.split("\\.")).reduce((a,b) -> b).orElse(null)

Es funktioniert wie folgt:

  1. Teilen Sie den String mit "." In ein Array von Strings auf.
  2. Konvertieren Sie das Array in einen Stream
  3. Verwenden Sie "verkleinern", um das letzte Element des Streams, d
// Modified from EboMike's answer

String extension = "/path/to/file/foo.txt".substring("/path/to/file/foo.txt".lastIndexOf('.'));

erweiterung sollte ".txt" enthalten, wenn ausgeführt.

1
longda

Hier habe ich eine kleine Methode erstellt (allerdings nicht so sicher und prüft nicht auf viele Fehler), aber wenn nur Sie ein allgemeines Java-Programm programmieren, reicht dies aus, um den Dateityp zu finden. Dies funktioniert nicht für komplexe Dateitypen, aber diese werden normalerweise nicht so oft verwendet. 

    public static String getFileType(String path){
       String fileType = null;
       fileType = path.substring(path.indexOf('.',path.lastIndexOf('/'))+1).toUpperCase();
       return fileType;
}
1
Rivalion
path = "/Users/test/test.txt"

extension = path.substring(path.lastIndexOf("."), path.length());

return ".text"

wenn Sie nur "Text" möchten, machen Sie path.lastIndexOf(".") + 1

1

Diese spezielle Frage bereitet mir viel Mühe, dann habe ich eine sehr einfache Lösung für dieses Problem gefunden, die ich hier posten.

file.getName().toLowerCase().endsWith(".txt");

Das ist es.

0
vikram Bhardwaj

Nur eine auf regulären Ausdrücken basierende Alternative. Nicht so schnell, nicht so gut. 

Pattern pattern = Pattern.compile("\\.([^.]*)$");
Matcher matcher = pattern.matcher(fileName);

if (matcher.find()) {
    String ext = matcher.group(1);
}
0
serhiy.h

Ich mag die Einfachheit von spectre's Antwort , und in einem seiner Kommentare ist ein Link zu einer anderen Antwort verlinkt, die Punkte in Dateipfaden fixiert, auf eine andere Frage von EboMike .

Ohne eine API eines Drittanbieters zu implementieren, empfehle ich Folgendes:

private String getFileExtension(File file) {

    String name = file.getName().substring(Math.max(file.getName().lastIndexOf('/'),
            file.getName().lastIndexOf('\\')) < 0 ? 0 : Math.max(file.getName().lastIndexOf('/'),
            file.getName().lastIndexOf('\\')));
    int lastIndexOf = name.lastIndexOf(".");
    if (lastIndexOf == -1) {
        return ""; // empty extension
    }
    return name.substring(lastIndexOf + 1); // doesn't return "." with extension
}

So etwas kann beispielsweise in jeder der write-Methoden von ImageIO nützlich sein , bei denen das Dateiformat übergeben werden muss.

Warum eine ganze Drittanbieter-API verwenden, wenn Sie selbst basteln können?

0
DDPWNAGE

Ich habe einen besseren Weg gefunden, eine Erweiterung zu finden, indem ich alle obigen Antworten mische

public static String getFileExtension(String fileLink) {

        String extension;
        Uri uri = Uri.parse(fileLink);
        String scheme = uri.getScheme();
        if (scheme != null && scheme.equals(ContentResolver.SCHEME_CONTENT)) {
            MimeTypeMap mime = MimeTypeMap.getSingleton();
            extension = mime.getExtensionFromMimeType(CoreApp.getInstance().getContentResolver().getType(uri));
        } else {
            extension = MimeTypeMap.getFileExtensionFromUrl(fileLink);
        }

        return extension;
    }

public static String getMimeType(String fileLink) {
        String type = CoreApp.getInstance().getContentResolver().getType(Uri.parse(fileLink));
        if (!TextUtils.isEmpty(type)) return type;
        MimeTypeMap mime = MimeTypeMap.getSingleton();
        return mime.getMimeTypeFromExtension(FileChooserUtil.getFileExtension(fileLink));
    }
0
Raghav Satyadev