Come posso ottenere l'estensione di un file in Java?

Giusto per essere chiari, non sto cercando il tipo MIME.

Diciamo che ho il seguente input: /path/to/file/foo.txt

Vorrei un modo per suddividere questo input, in particolare .txtper l'estensione. Esiste un modo integrato per farlo in Java? Vorrei evitare di scrivere il mio parser.

In questo caso, utilizzare FilenameUtils.getExtension da Apache Commons IO

Ecco un esempio di come usarlo (è possibile specificare il percorso completo o solo il nome del file):

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

Dipendenza da Maven:

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

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

Hai davvero bisogno di un "parser" per questo?

String extension = "";

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

Supponendo che tu abbia a che fare con nomi di file simili a Windows, non qualcosa del genere archive.tar.gz.

A proposito, nel caso in cui una directory possa avere un '.', Ma il nome del file stesso non (come /path/to.a/file), puoi fare

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

Se si utilizza la libreria Guava , è possibile ricorrere alla Filesclasse di utilità. Ha un metodo specifico, getFileExtension(). Per esempio:

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

Inoltre puoi anche ottenere il nome file con una funzione simile, getNameWithoutExtension () :

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

Se su Android, puoi usare questo:

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

Per tenere conto dei nomi dei file senza caratteri prima del punto, devi usare quella leggera variazione della risposta accettata:

String extension = "";

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

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

Questo è un metodo testato

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

E caso di prova:

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

Il mio sporco e può essere il più piccolo usando String.replaceAll :

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

Nota che prima *è avido, quindi afferrerà il maggior numero possibile di caratteri e poi rimarrà solo l'ultimo punto e l'estensione del file.

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

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

return ".txt"

se vuoi solo "txt", crea path.lastIndexOf(".") + 1

Come è ovvio da tutte le altre risposte, non esiste una funzione "incorporata" adeguata. Questo è un metodo sicuro e semplice.

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

Che ne dici (usando Java 1.5 RegEx):

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

Se si prevede di utilizzare Apache commons-io, e basta voler controllare l'estensione del file e poi fare qualche operazione, è possibile utilizzare questo , ecco un frammento:

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

Ecco un altro one-liner per Java 8.

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

Funziona come segue:

1. Dividi la stringa in una matrice di stringhe usando "."
2. Converti l'array in un flusso
3. Utilizzare riduci per ottenere l'ultimo elemento del flusso, ovvero l'estensione del file

Che ne dici di JFileChooser? Non è semplice in quanto dovrai analizzarne l'output finale ...

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

che è un tipo MIME ...

OK ... Ho dimenticato che non vuoi conoscere il suo tipo MIME.

Codice interessante al seguente 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;
}

Domanda correlata: come tagliare un'estensione di file da una stringa in Java?

Ecco un metodo che gestisce .tar.gzcorrettamente, anche in un percorso con punti nei nomi di directory:

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è stato creato per rendere la ricerca afterLastBackslashpiù veloce poiché non dovrà cercare l'intera stringa se ci sono delle barre.

L' char[]interno dell'originale Stringviene riutilizzato, non aggiungendo immondizia lì e la JVM noterà probabilmente che afterLastSlashè immediatamente immondizia per metterlo nello stack anziché nell'heap .

// Modified from EboMike's answer

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

l'estensione dovrebbe contenere ".txt" quando viene eseguita.

Ecco la versione con Opzionale come valore di ritorno (perché non puoi essere sicuro che il file abbia un'estensione) ... anche i controlli di integrità ...

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

Che ne dici della versione 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));
}

o con estensione null supportata:

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

risultato per * nix:
percorso: / root / docs /
nome: readme
Estensione: txt

per windows, parsePath ("c: \ windows \ readme.txt"):
percorso: c: \ windows \
name: readme
Estensione: txt

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

Qui ho fatto un piccolo metodo (comunque non così sicuro e non controlla molti errori), ma se sei solo tu a programmare un programma java generale, questo è più che sufficiente per trovare il tipo di file. Questo non funziona per tipi di file complessi, ma quelli normalmente non sono usati così tanto.

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

Ottenere l'estensione del file dal nome del 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);
}

Crediti

1. Copiato dalla classe FileNameUtils di Apache - 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

Senza l'uso di alcuna libreria, è possibile utilizzare la suddivisione del metodo String come segue:

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

        String extension = "";

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

Solo un'alternativa basata su espressioni regolari. Non così veloce, non così buono.

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

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

Ho trovato un modo migliore per trovare l'estensione mescolando tutte le risposte sopra

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

Mi piace la semplicità della risposta di spectre , e in uno dei suoi commenti è collegato un collegamento a un'altra risposta che corregge i punti nei percorsi dei file, su un'altra domanda, fatta da EboMike .

Senza implementare una sorta di API di terze parti, suggerisco:

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
}

Qualcosa del genere può essere utile, per esempio, in uno qualsiasi dei writemetodi di ImageIO , in cui deve essere passato il formato del file.

Perché utilizzare un'intera API di terze parti quando puoi fare il fai-da-te?

Questa particolare domanda mi ha dato molti problemi, poi ho trovato una soluzione molto semplice per questo problema che sto postando qui.

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

Questo è tutto.

prova questo.

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 ha un modo integrato di gestirlo , nella classe java.nio.file.Files , che potrebbe funzionare per le tue esigenze:

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

Si noti che questo metodo statico utilizza le specifiche trovate qui per recuperare il "tipo di contenuto", che può variare.