Java'daki bir dosya uzantısını nasıl edinebilirim?

Açıkça söylemek gerekirse, MIME türünü aramıyorum.

Diyelim ki şu girdim var: /path/to/file/foo.txt

Bu girişi, özellikle .txtuzantı için ayırmak için bir yol istiyorum . Java ile bunu yapmak için herhangi bir yerleşik var mı? Kendi ayrıştırıcımı yazmaktan kaçınmak istiyorum.

Bu durumda, kullanmak FilenameUtils.getExtension gelen Apache Commons IO

İşte nasıl kullanılacağına dair bir örnek (tam yol veya sadece dosya adı belirtebilirsiniz):

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

Maven bağımlılığı:

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

Diğerleri https://search.maven.org/artifact/commons-io/commons-io/2.6/jar

Bunun için gerçekten bir "ayrıştırıcıya" mı ihtiyacınız var?

String extension = "";

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

Windows benzeri basit dosya adlarıyla uğraştığınızı varsayarsak, benzer bir şeyle değil archive.tar.gz.

Btw, bir dizinin bir '.' Olması durumunda ancak dosya adının kendisi (beğenmez /path/to.a/file)

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

Eğer kullanırsanız Guava kütüphane, sen çare olabilir Filesyarar sınıfına. Belirli bir yöntemi vardır getFileExtension(). Örneğin:

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

Ayrıca, benzer bir işlevle dosya adını da alabilirsiniz, getNameWithoutExtension () :

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

Android'de ise bunu kullanabilirsiniz:

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

Noktadan önce karakter içermeyen dosya adlarını dikkate almak için, kabul edilen yanıtın bu küçük varyasyonunu kullanmanız gerekir:

String extension = "";

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

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

Bu test edilmiş bir yöntemdir

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

Ve test durumu:

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

Benim kirli ve String.replaceAll kullanarak ufak olabilir :

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

İlk önce *açgözlü olduğunu unutmayın, böylece mümkün olduğunca mümkün olan en karakterleri kapmak ve daha sonra sadece son nokta ve dosya uzantısı bırakılacaktır.

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

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

".txt" döndür

sadece "txt" istiyorsanız, path.lastIndexOf(".") + 1

Diğer tüm cevaplardan da anlaşılacağı gibi, yeterli "yerleşik" fonksiyon yoktur. Bu güvenli ve basit bir yöntemdir.

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

Peki ya (Java 1.5 RegEx kullanarak):

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

Apache commons-io kullanmak ve sadece dosyanın uzantısını kontrol etmek istiyorum ve sonra bazı operasyon yapmaya planlıyorsanız, kullanabileceğiniz bu , burada snippet'idir:

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

İşte Java 8 için bir başka astar.

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

Aşağıdaki gibi çalışır:

1. Dizeyi "." Kullanarak dizelerden oluşan bir diziye ayırın.
2. Diziyi bir akışa dönüştürme
3. Akışın son öğesini, yani dosya uzantısını almak için reduce kullanın

JFileChooser'a ne dersiniz? Nihai çıktısını ayrıştırmanız gerekeceğinden bu basit değildir ...

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

MIME türü olan ...

Tamam ... MIME türünü bilmek istemediğinizi unutuyorum.

Aşağıdaki bağlantıda ilginç kod: 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;
}

İlgili soru: Java'daki bir dizeden dosya uzantısını nasıl kesebilirim?

.tar.gzDizin adlarında nokta bulunan bir yolda bile düzgün şekilde işleyen bir yöntem şunlardır:

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

afterLastSlashafterLastBackslashiçinde bazı eğik çizgiler varsa tüm dizeyi aramak zorunda kalmayacağı için bulma işlemini daha hızlı hale getirmek için oluşturulur .

char[]Orijinal içeride Stringhiçbir çöp ekleyerek yeniden kullanılır ve JVM muhtemelen ihbar edecek afterLastSlashiçin hemen çöp yerine yığın yığın koymak .

// Modified from EboMike's answer

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

uzantı çalıştırıldığında ".txt" olmalıdır.

İşte isteğe bağlı bir dönüş değeri olan sürüm (çünkü dosyanın bir uzantısı olduğundan emin olamıyorsunuz) ... ayrıca sağlık kontrolleri ...

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

Nasıl hakkında REGEX sürümü:

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

veya null uzantı desteklenir:

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

* nix: path: / root / docs / name: benioku için sonuç Uzantı: txt

windows için parsePath ("c: \ windows \ readme.txt"):
yol: c: \ windows \
name: benioku
Uzantı: txt

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

Burada küçük bir yöntem yaptım (ancak güvenli değil ve birçok hatayı kontrol etmiyor), ancak genel bir java programını programlayan yalnızca sizseniz, bu dosya türünü bulmak için fazlasıyla yeterli. Bu karmaşık dosya türlerinde işe yaramaz, ancak bunlar normalde çok fazla kullanılmaz.

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

Dosya Adından Dosya Adını Alma

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

Kredi

1. Apache FileNameUtils Sınıfından kopyalandı - 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

Herhangi bir kütüphane kullanmadan, String yöntemi bölünmesini aşağıdaki gibi kullanabilirsiniz:

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

        String extension = "";

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

Sadece düzenli ifade tabanlı bir alternatif. O kadar hızlı değil, o kadar iyi değil.

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

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

Yukarıdaki tüm cevapları karıştırarak uzantı bulmanın daha iyi bir yolunu buldum

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

Spektrumun cevabının basitliğini beğendim ve yorumlarından birinde, EboMike tarafından yapılan başka bir soruda, dosya yollarındaki noktaları düzelten başka bir cevaba bir bağlantı var .

Bir çeşit üçüncü taraf API'sı uygulamadan şunu öneririm:

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
}

Bunun gibi bir şey, örneğin, dosya biçiminin aktarılması gereken ImageIO'nun writeyöntemlerinden herhangi birinde yararlı olabilir .

DIY yapabileceğinizde neden tam bir üçüncü taraf API kullanıyorsunuz?

Bu özel soru bana bir sürü sorun verdi sonra ben burada yayınlıyorum bu sorun için çok basit bir çözüm buldum.

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

Bu kadar.

bunu dene.

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, java.nio.file.Files sınıfında ihtiyaçlarınız için işe yarayabilecek yerleşik bir çözüm yöntemine sahiptir :

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

Bu statik yöntemin , değişen "içerik türünü" almak için burada bulunan özellikleri kullandığını unutmayın .