Comment obtenir l'extension de fichier d'un fichier en Java?


484

Juste pour être clair, je ne recherche pas le type MIME.

Disons que j'ai l'entrée suivante: /path/to/file/foo.txt

Je voudrais un moyen de décomposer cette entrée, en particulier .txtpour l'extension. Existe-t-il un moyen intégré de le faire en Java? Je voudrais éviter d'écrire mon propre analyseur.


12
Vous ne savez jamais quand une nouvelle plate-forme va arriver qui définit les extensions comme étant séparées par une virgule. Vous devez maintenant écrire du code dépendant de la plateforme. Les frameworks Java devraient être plus avant-gardistes et avoir des API pour obtenir des extensions où ils écrivent le code dépendant de la plate-forme et vous, en tant qu'utilisateur de l'API, dites simplement obtenir l'extension.
ArtOfWarfare

@ArtOfWarfare: OMG. Créons un avec beaucoup de 100MB JRE milliers des cours , mais s'il vous plaît assurez - vous de ne pas mettre en œuvre une méthode des rendements "txt"de "filename.txt"parce que certains quelque part la plate - forme pourrait vouloir utiliser "filename,txt".
Eric Duminil

@EricDuminil "Assurez-vous de ne pas implémenter de méthode qui renvoie" txt "de" filename.txt "" ??? Essayez path.substring(path.lastIndexOf("."));..... Et oui ... Ils sont sûrs de ne pas dupliquer quelque chose pour rien ...
VelocityPulse

@VelocityPulse C'est exactement ce qui me dérange. Puisqu'il n'y a aucun moyen standard d'obtenir l'extension de fichier, vous obtenez des dizaines de réponses à moitié fausses et des implémentations légèrement différentes. Votre code utilise 2 méthodes (j'aurais aimé avoir une seule méthode explicite), il renvoie ".txt"de "filename.txt", ce qui n'est peut-être pas le résultat souhaité, et pire encore, il échoue avec StringIndexOutOfBoundsExceptionau lieu de renvoyer une chaîne vide s'il n'y a pas d'extension.
Eric Duminil

Réponses:


649

Dans ce cas, utilisez FilenameUtils.getExtension depuis Apache Commons IO

Voici un exemple de la façon de l'utiliser (vous pouvez spécifier le chemin d'accès complet ou simplement le nom du fichier):

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

Dépendance 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")

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


70
A noter qu'il ne renvoie que "gz" pour un fichier nommé archive.tar.gz.
Zitrax

106
@Zitrax c'est parce que "gz" est l'extension du fichier.
BrainSlugs83

6
@ BrainSlugs83 Que signifie donc "tar"?
TuGordoBello

31
@zhelon .gz signifie gnu zipped file et .tar signifie (t) ape (ar) chive. Donc .tar.gz est un fichier tar à l'intérieur d'un fichier compressé gnu, qui a l'extension .gz.
cirovladimir

5
Il n'y a aucune raison d'apporter une autre bibliothèque pour cette tâche simple.
masterwok

311

Avez-vous vraiment besoin d'un "analyseur" pour cela?

String extension = "";

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

En supposant que vous ayez affaire à des noms de fichiers similaires à Windows, pas quelque chose comme ça archive.tar.gz.

Btw, dans le cas où un répertoire peut avoir un '.', Mais le nom de fichier lui-même ne le fait pas (comme /path/to.a/file), vous pouvez le faire

String extension = "";

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

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

4
Merci! Bien sûr, vous pourriez avoir besoin d'un analyseur / objet pour cela, si vous vouliez faire plus de manipulations que simplement l'extension ... dites si vous voulez juste le chemin, le répertoire parent, le nom du fichier (moins l'extension), etc. m venant de C # et .Net où nous avons ceci: msdn.microsoft.com/en-us/library/…
longda

10
Comme vous le dites, il y a un certain nombre de choses à penser, au-delà de la simple utilisation du naïf lastIndexOf ("."). Je suppose qu'Apache Commons a une méthode pour cela, qui prend en compte tous les petits problèmes potentiels délicats.
MatrixFrog

12
Je pense que i > 0devrait être changé en i >= 0ou i != -1. Cela prend en charge les noms de fichiers comme .htaccess.
Pijusn

8
quelle que soit la simplicité d'un extrait de code ... vous devez toujours le mettre à jour / le maintenir / le tester / le rendre disponible en tant que dépendance pratique ... beaucoup plus facile s'il y avait déjà une bibliothèque faisant tout cela
Don Cheadle

2
Sur plus gotcha est si le fichier se termine par un point. Mieux dans une lib. if (i> p && i <(fileName.length () - 1)) {extension = fileName.substring (i + 1);
tgkprog

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

13
Il convient de noter que cela renvoie le «.» ainsi, votre extension de fichier sera '.txt' par opposition à 'txt' dans certaines des autres réponses
NickEntin

2
Meilleure réponse et @NickEntin Meilleur commentaire. Pour supprimer le point "." à partir de l'extension du fichier, peut être codé comme int lastIndexOf = name.lastIndexOf (".") + 1;
Hanzallah Afgan

11
cette approche peut ne pas fonctionner dans certains cas, par exemple /usr/bin/foo.bar/httpconf
Iman Akbari

8
@ lukasz1985 1. des centaines de paquets linux font des répertoires avec des noms comme "init.d", en outre, il n'est pas sûr de s'appuyer sur le chemin sans répertoires avec des points, car ce n'est pas illégal 2. Je codais pour Android, donc j'ai utilisé un SDK méthode je ne me souviens pas mais je suppose que stackoverflow.com/a/3571239/2546146 n'a pas ce défaut
Iman Akbari

6
@Iman Akbari: getName () ne renvoie que le nom du fichier lui-même, qui serait "httpconf" dans votre exemple.
président de Dreamspace, le

85

Si vous utilisez la bibliothèque Guava , vous pouvez recourir à la Filesclasse d'utilité. Il a une méthode spécifique, getFileExtension(). Par exemple:

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

De plus, vous pouvez également obtenir le nom de fichier avec une fonction similaire, getNameWithoutExtension () :

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

4
Vraiment? C'est une grande bibliothèque, pleine d'utilitaires. La plupart d'entre eux feront partie de Java8, comme la grande fonction Guava .
JeanValjean

Malheureusement, tout le monde ne peut pas décider quelles bibliothèques utiliser. Au moins, nous avons Apache Commons, même s'il est ancien.
Lluis Martinez

1
si vous voyez le code source, getFileExtensionce n'est int dotIndex = fileName.lastIndexOf('.'); return (dotIndex == -1) ? "" : fileName.substring(dotIndex + 1)vraiment pas grave. notez également que Filesmarqué comme "instable" pour une raison quelconque.
Al-Mothafar

@ Al-Mothafar beaucoup de classes sont marquées comme instables (voir les constructeurs multimap), je ne comprends pas non plus pourquoi: plusieurs sorties ont été faites, mais rien n'y a changé.
JeanValjean

27

Si sur Android, vous pouvez utiliser ceci:

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

Notez que cela ne fonctionnera pas si la chaîne n'est pas encodée (par exemple contient un espace ou un caractère chinois), voir: stackoverflow.com/a/14321470/1074998
Fruit

14

Afin de prendre en compte les noms de fichiers sans caractères avant le point, vous devez utiliser cette légère variation de la réponse acceptée:

String extension = "";

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

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

devrait probablement se défendre contre "foo". contribution.
chrisinmtown

14

Ceci est une méthode testée

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

Et cas de test:

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

10

Mon sale et peut minuscule en utilisant String.replaceAll :

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

Notez que le premier *est gourmand, donc il saisira autant de caractères que possible, puis il ne restera que le dernier point et l'extension de fichier.


Cela échoue si le fichier n'a pas d'extension.
Zack

Oui, malheureusement, il peut toujours être utilisé pour des scénarios simples comme la détection rapide de type de fichier et comme avoir une extension incorrecte n'est pas très différent de n'en avoir aucune, ou on peut mettre une condition if lorsque le résultat du remplacement est égal à l'entrée.
Ebrahim Byagowi

1
Ou encore plus court.replaceAll(".*\\.", "")
Ebrahim Byagowi

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

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

retourner ".txt"

si vous ne voulez que "txt", faites path.lastIndexOf(".") + 1


9

Comme il ressort de toutes les autres réponses, il n'y a pas de fonction «intégrée» adéquate. Il s'agit d'une méthode simple et sûre.

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

Que diriez-vous (en utilisant Java 1.5 RegEx):

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

6

Si vous prévoyez d'utiliser commons-io Apache, et que vous voulez juste vérifier l'extension du fichier puis effectuez une opération, vous pouvez utiliser ce , voici un extrait:

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

Notez que cette vérification est sensible à la casse selon les documents.
Babken Vardanyan

6

Voici un autre one-liner pour Java 8.

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

Cela fonctionne comme suit:

  1. Divisez la chaîne en un tableau de chaînes à l'aide de "."
  2. Convertir le tableau en flux
  3. Utilisez réduire pour obtenir le dernier élément du flux, c'est-à-dire l'extension de fichier

4

Qu'en est-il de JFileChooser? Ce n'est pas simple car vous devrez analyser sa sortie finale ...

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

qui est un type MIME ...

OK ... j'oublie que vous ne voulez pas connaître son type MIME.

Code intéressant dans le lien suivant: 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;
}

Question connexe: Comment découper une extension de fichier à partir d'une chaîne en Java?


4

Voici une méthode qui gère .tar.gzcorrectement, même dans un chemin avec des points dans les noms de répertoire:

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

afterLastSlashest créé pour afterLastBackslashaccélérer la recherche car il n'aura pas à rechercher la chaîne entière s'il y a des barres obliques.

L' char[]intérieur de l'original Stringest réutilisé, sans ajout de déchets, et la JVM remarquera probablement qu'il afterLastSlashs'agit immédiatement de déchets afin de le mettre sur la pile au lieu du tas .


cette méthode est copiée à partir du code source de Guava, vous devez le mentionner.
humazed

1
Je n'ai pas copié ça. Si c'est dans le code source de Guava, ils l'ont copié d'ici. Peut-être les informer.
Olathe

désolé, ce n'est pas identique, alors que vous et le développeur de Guava ayez juste la même idée.
humazed

2
Vraiment "gz" est l'extension correcte à renvoyer. Si le code appelant peut également gérer "tar", il doit en outre vérifier, en dehors d'une getExtensionfonction. Si le nom de fichier de l'utilisateur est "my zip. don't touch.tar.gz"alors cette méthode retournera la mauvaise extension.
intrepidis

2
// Modified from EboMike's answer

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

l'extension doit avoir ".txt" en cours d'exécution.


13
Se bloque si le nom n'a pas d'extension.
EboMike

2

Voici la version avec Facultatif comme valeur de retour (car vous ne pouvez pas être sûr que le fichier a une extension) ...

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

Que diriez- vous de la version 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));
}

ou avec une extension nulle prise en charge:

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

résultat pour * nix:
chemin: / root / docs /
nom: readme
Extension: txt

pour Windows, parsePath ("c: \ windows \ readme.txt"):
chemin: c: \ windows \
nom: readme
Extension: txt


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

1

Ici, j'ai fait une petite méthode (mais pas si sécurisée et ne vérifie pas de nombreuses erreurs), mais si c'est seulement vous qui programmez un programme java général, c'est plus que suffisant pour trouver le type de fichier. Cela ne fonctionne pas pour les types de fichiers complexes, mais ceux-ci ne sont normalement pas autant utilisés.

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

OP recherche une méthode intégrée
Panther

(1) Vous devez utiliser lastIndexOfles noms de fichiers comme ceux-ci john.smith.report.docsont traités correctement. (2) Vous devez gérer correctement les cas lorsqu'il n'y a pas d'extension. Cette méthode retourne ABC/XYZpour un chemin comme abc/xyz, ce qui n'a aucun sens. Il serait plus logique de revenir ""ou null. (3) Le séparateur de fichiers n'est pas toujours /.
Radiodef

1

Obtention d'une extension de fichier à partir d'un nom de fichier

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

Crédits

  1. Copié de la classe Apache FileNameUtils - 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

Sans utiliser de bibliothèque, vous pouvez utiliser la méthode String divisée comme suit:

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

        String extension = "";

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

0

Juste une alternative basée sur l'expression régulière. Pas si vite, pas si bien.

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

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

0

J'ai trouvé un meilleur moyen de trouver une extension en mélangeant toutes les réponses ci-dessus

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

J'aime la simplicité de la réponse du spectre , et lié dans l'un de ses commentaires est un lien vers une autre réponse qui fixe des points dans les chemins de fichiers, sur une autre question, faite par EboMike .

Sans implémenter une sorte d'API tierce, je suggère:

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
}

Quelque chose comme ça peut être utile, par exemple, dans n'importe laquelle des writeméthodes d'ImageIO , où le format de fichier doit être transmis.

Pourquoi utiliser une API tierce quand vous pouvez bricoler?


0

Cette question particulière m'a donné beaucoup de mal alors j'ai trouvé une solution très simple à ce problème que je poste ici.

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

C'est ça.


3
OP a besoin d'un moyen d'extraire l'extension - pas d'en tester une.
Predrag Manojlovic

en fait, tout ce que vous développez dans la plupart des cas, vous devez uniquement traiter un type particulier de fichiers. Donc, si votre problème survient dans ce domaine, cela vous aidera.
Vikram Bhardwaj

4
Ce qui ne répond pas à ses exigences
Predrag Manojlovic

2
Ce n'est pas une réponse à la question, mais c'est bien ce que je cherchais.
Ediolot

-1

essaye ça.

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

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

-4

Java a une manière intégrée de gérer cela, dans la classe java.nio.file.Files , qui peut répondre à vos besoins:

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

Notez que cette méthode statique utilise les spécifications trouvées ici pour récupérer le "type de contenu", qui peut varier.


28
Ceci est une erreur. Le type de retour pour probeContentType est le type de contenu MIME, pas l'extension de fichier. Il ne correspond généralement pas à l'extension. Cela serait également assez lent dans un navigateur de fichiers, car il ouvre réellement le fichier pour déterminer le type.
Charles
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.