Bagaimana saya mendapatkan ekstensi file dari suatu file di Java?

Untuk lebih jelasnya, saya tidak mencari tipe MIME.

Katakanlah saya memiliki input berikut: /path/to/file/foo.txt

Saya ingin cara memecah input ini, khususnya .txtuntuk ekstensi. Apakah ada cara yang dibangun untuk melakukan ini di Jawa? Saya ingin menghindari menulis parser saya sendiri.

Dalam hal ini, gunakan FilenameUtils.getExtension dari Apache Commons IO

Berikut adalah contoh cara menggunakannya (Anda dapat menentukan path lengkap atau hanya nama file):

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

Ketergantungan maven:

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

DSL Gradle Groovy

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

Gradle Kotlin DSL

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

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

Apakah Anda benar-benar membutuhkan "pengurai" untuk ini?

String extension = "";

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

Dengan asumsi bahwa Anda berurusan dengan nama file sederhana seperti Windows, bukan sesuatu seperti archive.tar.gz .

Btw, untuk kasus direktori mungkin memiliki '.', Tetapi nama file itu sendiri tidak (seperti /path/to.a/file), Anda dapat melakukan

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

Jika Anda menggunakan perpustakaan Guava , Anda dapat menggunakan Fileskelas utilitas. Ini memiliki metode khusus getFileExtension(),. Contohnya:

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

Selain itu Anda juga dapat memperoleh nama file dengan fungsi yang serupa, getNameWithoutExtension () :

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

Jika di Android, Anda dapat menggunakan ini:

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

Untuk mempertimbangkan nama file akun tanpa karakter sebelum titik, Anda harus menggunakan sedikit variasi dari jawaban yang diterima:

String extension = "";

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

"file.doc" => "doc"
"file.doc.gz" => "gz"
".doc" => "doc"

Ini adalah metode yang diuji

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

Dan uji kasus:

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

Saya kotor dan mungkin paling kecil menggunakan String.replaceAll :

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

Perhatikan bahwa pertama *adalah rakus sehingga akan mengambil karakter paling mungkin sejauh mungkin dan kemudian hanya titik terakhir dan ekstensi file akan ditinggalkan.

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

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

kembali ".txt"

jika Anda hanya ingin "txt", buat path.lastIndexOf(".") + 1

Seperti yang jelas dari semua jawaban lain, tidak ada fungsi "bawaan" yang memadai. Ini adalah metode yang aman dan sederhana.

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

Bagaimana dengan (menggunakan Java 1.5 RegEx):

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

Jika Anda berencana untuk menggunakan Apache commons-io, dan hanya ingin memeriksa ekstensi file dan kemudian melakukan beberapa operasi, Anda dapat menggunakan ini , berikut ini cuplikannya:

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

Berikut ini adalah satu-liner untuk Java 8.

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

Ia bekerja sebagai berikut:

1. Pisahkan string menjadi array string menggunakan "."
2. Konversikan array menjadi stream
3. Gunakan perkecil untuk mendapatkan elemen terakhir dari aliran, yaitu ekstensi file

Bagaimana dengan JFileChooser? Ini tidak mudah karena Anda perlu mengurai hasil akhirnya ...

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

yang merupakan tipe MIME ...

OKE ... Saya lupa bahwa Anda tidak ingin tahu tipe MIME-nya.

Kode menarik di tautan berikut: 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;
}

Pertanyaan terkait: Bagaimana cara saya memotong ekstensi file dari sebuah String di Java?

Berikut adalah metode yang menangani .tar.gzdengan benar, bahkan di jalur dengan titik-titik dalam nama direktori:

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 dibuat untuk membuat temuan afterLastBackslash lebih cepat karena tidak perlu mencari seluruh string jika ada beberapa garis miring di dalamnya.

Bagian char[]dalam aslinya Stringdigunakan kembali, menambahkan tidak ada sampah di sana, dan JVM mungkin akan melihat bahwa afterLastSlashsegera sampah untuk meletakkannya di tumpukan, bukan tumpukan .

// Modified from EboMike's answer

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

ekstensi harus memiliki ".txt" di dalamnya ketika dijalankan.

Inilah versi dengan Opsional sebagai nilai pengembalian (karena Anda tidak dapat memastikan file memiliki ekstensi) ... juga cek kewarasan ...

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

Bagaimana dengan versi REGEX :

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

atau dengan ekstensi nol yang didukung:

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

hasil untuk * nix:
path: / root / docs /
name: readme
Extention: txt

untuk windows, parsePath ("c: \ windows \ readme.txt"):
path: c: \ windows \
name: readme
Extention: txt

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

Di sini saya membuat metode kecil (namun tidak aman dan tidak memeriksa banyak kesalahan), tetapi jika hanya Anda yang memprogram program java umum, ini lebih dari cukup untuk menemukan filetype. Ini tidak berfungsi untuk tipe file kompleks, tetapi biasanya tidak digunakan sebanyak itu.

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

Mendapatkan Ekstensi File dari Nama File

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

Kredit

1. Disalin dari Apache FileNameUtils Class - 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

Tanpa menggunakan pustaka apa pun, Anda dapat menggunakan metode String split sebagai berikut:

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

        String extension = "";

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

Hanya alternatif berbasis ekspresi reguler. Tidak secepat itu, tidak sebagus itu.

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

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

Saya menemukan cara yang lebih baik untuk menemukan ekstensi dengan mencampurkan semua jawaban di atas

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

Saya suka kesederhanaan jawaban spektre , dan terhubung dalam salah satu komentarnya adalah tautan ke jawaban lain yang memperbaiki titik-titik di jalur file, pada pertanyaan lain, yang dibuat oleh EboMike .

Tanpa menerapkan semacam API pihak ketiga, saya sarankan:

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
}

Sesuatu seperti ini mungkin berguna dalam, katakanlah, salah satu writemetode ImageIO , di mana format file harus diteruskan.

Mengapa menggunakan seluruh API pihak ketiga saat Anda bisa menggunakan DIY?

Pertanyaan khusus ini memberi saya banyak masalah kemudian saya menemukan solusi yang sangat sederhana untuk masalah ini yang saya posting di sini.

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

Itu dia.

coba ini.

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 memiliki cara untuk menangani hal ini, di kelas java.nio.file.Files , yang dapat bekerja untuk kebutuhan Anda:

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

Perhatikan bahwa metode statis ini menggunakan spesifikasi yang ditemukan di sini untuk mengambil "tipe konten," yang dapat bervariasi.