Wie erhalte ich die Dateierweiterung einer Datei in Java?

Um ganz klar zu sein, ich suche nicht nach dem MIME-Typ.

Angenommen, ich habe folgende Eingabe: /path/to/file/foo.txt

Ich möchte eine Möglichkeit, diese Eingabe speziell .txtfür die Erweiterung aufzuteilen. Gibt es eine eingebaute Möglichkeit, dies in Java zu tun? Ich möchte vermeiden, meinen eigenen Parser zu schreiben.

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

Hier ist 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"

Maven-Abhängigkeit:

<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.6</version>
</dependency>

Gradle Groovy DSL

implementation 'commons-io:commons-io:2.6'

Gradle Kotlin DSL

implementation("commons-io:commons-io:2.6")

Andere https://search.maven.org/artifact/commons-io/commons-io/2.6/jar

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

String extension = "";

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

Angenommen, Sie haben es mit einfachen Windows-ähnlichen Dateinamen zu tun, nicht mit so etwas archive.tar.gz.

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

String extension = "";

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

if (i > p) {
    extension = fileName.substring(i+1);
}

private String getFileExtension(File file) {
    String name = file.getName();
    int lastIndexOf = name.lastIndexOf(".");
    if (lastIndexOf == -1) {
        return ""; // empty extension
    }
    return name.substring(lastIndexOf);
}

Wenn Sie die Guava- Bibliothek verwenden, können Sie auf die FilesUtility-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

Darüber hinaus erhalten Sie möglicherweise auch den Dateinamen mit einer ähnlichen Funktion, getNameWithoutExtension () :

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

Unter Android können Sie Folgendes verwenden:

String ext = android.webkit.MimeTypeMap.getFileExtensionFromUrl(file.getName());

Um Dateinamen ohne Zeichen vor dem Punkt zu berücksichtigen , müssen Sie diese geringfügige Abweichung 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"

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

Mein schmutziger und vielleicht kleinster mit String.replaceAll :

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

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

String path = "/Users/test/test.txt";
String extension = "";

if (path.contains("."))
     extension = path.substring(path.lastIndexOf("."));

return ".txt"

Wenn Sie nur "txt" wollen, machen Sie path.lastIndexOf(".") + 1

Wie aus allen anderen Antworten hervorgeht, gibt es keine adäquate "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;
}

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

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

Wenn Sie planen , Apache commons-io zu verwenden, und wollen nur die Dateierweiterung überprüfen und dann eine Operation zu tun, die Sie verwenden können dies hier ist ein Ausschnitt:

if(FilenameUtils.isExtension(file.getName(),"java")) {
    someoperation();
}

Hier ist ein weiterer Einzeiler für Java 8.

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

Es funktioniert wie folgt:

1. Teilen Sie die Zeichenfolge mit "." In ein Array von Zeichenfolgen auf.
2. Konvertieren Sie das Array in einen Stream
3. Verwenden Sie Reduzieren, um das letzte Element des Streams abzurufen, dh die Dateierweiterung

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

Das ist ein MIME-Typ ...

OK ... Ich vergesse, dass Sie den MIME-Typ nicht kennen wollen.

Interessanter Code unter 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 aus einem String in Java?

Hier ist eine Methode, die .tar.gzauch in einem Pfad mit Punkten in Verzeichnisnamen ordnungsgemäß funktioniert:

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

afterLastSlashwurde erstellt, um das Auffinden zu afterLastBackslashbeschleunigen, da nicht die gesamte Zeichenfolge durchsucht werden muss, wenn einige Schrägstriche darin enthalten sind.

Das char[]Innere des Originals Stringwird wiederverwendet, wobei dort kein Müll hinzugefügt wird, und die JVM wird wahrscheinlich feststellen, dass afterLastSlashes sich sofort um Müll handelt, um ihn auf den Stapel anstatt auf den Haufen zu legen .

// Modified from EboMike's answer

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

Die Erweiterung sollte beim Ausführen ".txt" enthalten.

Hier ist die Version mit Optional als Rückgabewert (da Sie nicht sicher sein können, ob die Datei eine Erweiterung hat) ... auch die Überprüfung der Integrität ...

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

Wie wäre es mit der REGEX- Version:

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

String extension = com.google.common.io.Files.getFileExtension("fileName.jpg");

Hier habe ich eine kleine Methode gemacht (jedoch nicht so sicher und prüft nicht auf viele Fehler), aber wenn nur Sie ein allgemeines Java-Programm programmieren, ist dies mehr als genug, um den Dateityp zu finden. Dies funktioniert nicht für komplexe Dateitypen, aber diese werden normalerweise nicht so häufig verwendet.

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

Abrufen der Dateierweiterung vom Dateinamen

/**
 * 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. Von der 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

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

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

        String extension = "";

        if(splits.length >= 2)
        {
            extension = splits[splits.length-1];
        }

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

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

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

Ich mag die Einfachheit der Antwort von spectre und in einem seiner Kommentare ist ein Link zu einer anderen Antwort verlinkt, die Punkte in Dateipfaden auf einer anderen Frage von EboMike korrigiert .

Ohne eine Drittanbieter-API zu implementieren, schlage ich vor:

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 bei allen ImageIO- writeMethoden hilfreich sein , bei denen das Dateiformat übergeben werden muss.

Warum eine ganze API von Drittanbietern verwenden, wenn Sie selbst basteln können?

Diese spezielle Frage hat mir viel Ärger gemacht, dann habe ich eine sehr einfache Lösung für dieses Problem gefunden, die ich hier poste.

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

Das ist es.

Versuche dies.

String[] extension = "adadad.adad.adnandad.jpg".split("\\.(?=[^\\.]+$)"); // ['adadad.adad.adnandad','jpg']
extension[1] // jpg

  @Test
    public void getFileExtension(String fileName){
      String extension = null;
      List<String> list = new ArrayList<>();
      do{
          extension =  FilenameUtils.getExtension(fileName);
          if(extension==null){
              break;
          }
          if(!extension.isEmpty()){
              list.add("."+extension);
          }
          fileName = FilenameUtils.getBaseName(fileName);
      }while (!extension.isEmpty());
      Collections.reverse(list);
      System.out.println(list.toString());
    }

Java hat in der Klasse java.nio.file.Files eine integrierte Methode, um damit umzugehen , die möglicherweise für Ihre Anforderungen geeignet ist :

File f = new File("/path/to/file/foo.txt");
String ext = Files.probeContentType(f.toPath());
if(ext.equalsIgnoreCase("txt")) do whatever;

Beachten Sie, dass diese statische Methode verwendet die Spezifikationen hier „Content - Type“ abgerufen werden, die unterschiedlich sein können.