En développement Java, il est fréquent de devoir déterminer le type d’un fichier. Par exemple, une fonction de téléversement doit vérifier que les fichiers envoyés par l’utilisateur correspondent aux types autorisés. Cet article présente en détail les méthodes permettant d’obtenir le type d’un fichier avec Java.
I、Déterminer le type d’un fichier à partir de son extension
La méthode la plus courante pour déterminer le type d’un fichier consiste à examiner son extension. La plupart des fichiers possèdent une extension spécifique dans le système d’exploitation ; par exemple, celle des fichiers texte est généralement.txt，l’extension des fichiers image est généralement.jpg ou.png Et ainsi de suite.
Obtenir l’extension d’un fichier avec un programme Java est très simple ; il suffit d’utiliser String de la classe substring suffit ; le code est présenté ci-dessous :
public static String getFileExtension(File file) {
String fileName = file.getName();
if (fileName.lastIndexOf(".") != -1 && fileName.lastIndexOf(".") != 0) {
return fileName.substring(fileName.lastIndexOf(".") + 1);
} else {
return "";
}
}Cette méthode reçoit un File l’objet comme paramètre, puis utiliser lastIndexOf pour trouver la position du dernier point dans le nom du fichier, c’est-à-dire le début de l’extension, puis utiliser substring La méthode récupère la chaîne correspondant à l’extension et la renvoie. Si le fichier n’a pas d’extension, elle renvoie une chaîne vide.
Le code suivant permet de tester cette méthode :
File file = new File("C:/path/to/file.txt");
String extension = getFileExtension(file);
System.out.println(extension);Le résultat de l’exécution est :
txt
Cette méthode de détermination du type de fichier présente les avantages suivants :
Simple à utiliser, avec une implémentation concise.
Efficace pour la grande majorité des fichiers, car la grande majorité possède une extension.
Cependant, cette méthode présente aussi quelques inconvénients :
L’extension du fichier peut avoir été modifiée, ce qui peut fausser le résultat de l’identification.
Certains fichiers n’ont pas de suffixe, par exemple les exécutables sans extension.
Pour déterminer plus précisément le type d’un fichier, nous pouvons également examiner son nombre magique.
II、Déterminer le type d’un fichier à l’aide de son nombre magique
Le nombre magique d’un fichier est constitué de certains octets spécifiques situés au début du fichier, qui permettent d’en identifier le type. En reconnaissant ce nombre magique, nous pouvons déterminer précisément le type du fichier, sans être induits en erreur par son extension.
En Java, on peut obtenir le nombre magique d’un fichier en lisant ses données binaires.
2.1 Lecture des données binaires d’un fichier
Nous pouvons utiliser FileInputStream pour lire les données binaires du fichier. La méthode suivante renvoie un tableau d’octets contenant les données binaires du fichier :
public static byte[] readFileToByteArray(File file) throws IOException {
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
byte[] data = new byte[(int)file.length()];
fis.read(data);
return data;
} finally {
if (fis != null) {
fis.close();
}
}
}La méthode ci-dessus utilise FileInputStream pour ouvrir le fichier, lire les données et les stocker dans un tableau d’octets. Attention, une fois la lecture du fichier terminée, il faut appeler close méthode pour fermer le flux du fichier et libérer les ressources système.
2.2 Déterminer le type d’un fichier à l’aide de son nombre magique
Une fois les données binaires du fichier obtenues, nous pouvons en déterminer le type. Chaque type de fichier possède un nombre magique spécifique, qui permet de l’identifier. Voici les nombres magiques de quelques types de fichiers courants et les méthodes d’identification correspondantes :
Le nombre magique des fichiers texte（.txt）est
EF BB BF（les fichiers encodés en UTF-8 commencent par cette séquence d’octets）, on peut utiliser la méthode suivante pour le déterminer :public static boolean isTextFile(byte[] data) { if (data.length >= 3 && data[0] == -17 && data[1] == -69 && data[2] == -65) { return true; } return false; }La signature magique des images JPEG（.jpg）est
FF D8 FF，on peut utiliser la méthode suivante pour le déterminer :public static boolean isJPEGFile(byte[] data) { if (data.length >= 3 && data[0] == -1 && data[1] == -40 && data[2] == -1) { return true; } return false; }Le nombre magique des images PNG（.png）est
89 50 4E 47 0D 0A 1A 0A，on peut utiliser la méthode suivante pour le déterminer :public static boolean isPNGFile(byte[] data) { if (data.length >= 8 && data[0] == -119 && data[1] == 80 && data[2] == 78 && data[3] == 71 && data[4] == 13 && data[5] == 10 && data[6] == 26 && data[7] == 10) { return true; } return false; }
Selon les besoins, vous pouvez ajouter d’autres types de fichiers et les méthodes de détection par nombre magique correspondantes.
2.3 Exemple complet
Voici un exemple complet montrant comment utiliser les nombres magiques pour déterminer le type d’un fichier :
import java.io.File;import java.io.FileInputStream;import java.io.IOException;public class FileTypeChecker {
public static void main(String[] args) {
File file = new File("C:/path/to/file.jpg");
try {
byte[] data = readFileToByteArray(file);
if (isJPEGFile(data)) {
System.out.println("This is a JPEG file.");
} else if (isPNGFile(data)) {
System.out.println("This is a PNG file.");
} else if (isTextFile(data)) {
System.out.println("This is a text file.");
} else {
System.out.println("Unknown file type.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static byte[] readFileToByteArray(File file) throws IOException {
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
byte[] data = new byte[(int)file.length()];
fis.read(data);
return data;
} finally {
if (fis != null) {
fis.close();
}
}
}
public static boolean isTextFile(byte[] data) {
if (data.length >= 3 && data[0] == -17 && data[1] == -69 && data[2] == -65) {
return true;
}
return false;
}
public static boolean isJPEGFile(byte[] data) {
if (data.length >= 3 && data[0] == -1 && data[1] == -40 && data[2] == -1) {
return true;
}
return false;
}
public static boolean isPNGFile(byte[] data) {
if (data.length >= 8 && data[0] == -119 && data[1] == 80 && data[2] == 78 && data[3] == 71 &&
data[4] == 13 && data[5] == 10 && data[6] == 26 && data[7] == 10) {
return true;
}
return false;
}
}Le code d’exemple ci-dessus détermine le type du fichier à partir de son nombre magique et affiche le résultat correspondant.
III、Déterminer le type de fichier à l’aide de bibliothèques tierces
Outre les méthodes précédentes, on peut aussi utiliser des bibliothèques tierces pour déterminer le type d’un fichier. Java dispose de bibliothèques tierces à code source ouvert qui facilitent cette identification.
3.1 Tika
Tika est un projet de l’Apache Software Foundation qui fournit une bibliothèque Java open source pour analyser divers formats de fichiers, notamment les textes, images, fichiers audio et vidéos. Tika permet d’extraire les métadonnées des fichiers, y compris leur type.
Il faut d’abord ajouter la dépendance à la bibliothèque Tika. Si vous utilisez Maven pour construire le projet, vous pouvez, dans pom.xml ajouter les dépendances suivantes dans le fichier :
<dependency> <groupId>org.apache.tika</groupId> <artifactId>tika-core</artifactId> <version>1.27</version> </dependency>
Ensuite, vous pouvez utiliser le code suivant pour déterminer le type du fichier :
import org.apache.tika.Tika;
public class FileTypeChecker {
public static void main(String[] args) {
Tika tika = new Tika();
try {
File file = new File("C:/path/to/file.jpg");
String fileType = tika.detect(file);
System.out.println("File type: " + fileType);
} catch (IOException e) {
e.printStackTrace();
}
}
}L’exécution du code ci-dessus affichera le type du fichier.
Tika utilise différentes méthodes pour identifier les types de fichiers, notamment l’extension et les nombres magiques. Il prend également en charge des détecteurs personnalisés, permettant d’ajouter au besoin ses propres règles d’identification des types de fichiers.
3.2 FileTypeDetector
Java fournit une API standard pour détecter les types de fichiers, à savoir FileTypeDetector L’interface et ProbeContentType classe. En implémentant cette interface, on peut définir un détecteur de types de fichiers personnalisé.
Voici un exemple de détecteur personnalisé de types de fichiers :
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.spi.FileTypeDetector;
public class CustomFileTypeDetector extends FileTypeDetector {
@Override
public String probeContentType(Path path) throws IOException {
String extension = getFileExtension(path.toFile());
if ("txt".equals(extension)) {
return "text/plain";
} else if ("jpg".equals(extension) || "jpeg".equals(extension)) {
return "image/jpeg";
} else if ("png".equals(extension)) {
return "image/png";
} else {
return null;
}
}
private String getFileExtension(File file) {
String fileName = file.getName();
if (fileName.lastIndexOf(".") != -1 && fileName.lastIndexOf(".") != 0) {
return fileName.substring(fileName.lastIndexOf(".") + 1);
} else {
return "";
}
}
}Dans cet exemple, nous déterminons le type du fichier à partir de son extension et renvoyons le type MIME correspondant.
Pour utiliser un détecteur de type de fichier personnalisé, ajoutez le code suivant au point d’entrée du programme :
File file = new File("C:/path/to/file.jpg");
Path path = file.toPath();
String fileType = Files.probeContentType(path);
System.out.println("File type: " + fileType);L’exécution du code ci-dessus affichera le type du fichier.
Attention : pour certains types de fichiers particuliers, comme les exécutables sans extension, cette méthode fondée sur l’extension peut manquer de précision. Il est donc préférable d’utiliser la méthode fondée sur les nombres magiques présentée précédemment.
IV、Synthèse
Cet article présente plusieurs méthodes pour déterminer le type d’un fichier en Java. On peut se fonder sur son extension ou sur son nombre magique. Une bibliothèque tierce comme Tika permet de déterminer plus facilement le type d’un fichier. Pour les types de fichiers particuliers, un détecteur personnalisé permet une identification précise.
Le choix d’une méthode adaptée pour déterminer le type d’un fichier dépend du contexte d’utilisation et des besoins précis. En développement, choisissez la méthode de détection la plus appropriée selon les caractéristiques des fichiers et les exigences, tout en tenant compte de l’extensibilité et de la compatibilité.
