file myfile.txt
file /bin/ls
file image.jpg

myfile.txt: ASCII text
/bin/ls: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=..., stripped
image.jpg: JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 1920x1080, components 3

file [選項(xiàng)] 文件名...

file document.pdf

file -b document.pdf
# 輸出: PDF document, version 1.7

file -i document.pdf
# 輸出: document.pdf: application/pdf; charset=binary

file -L symlink_to_file

file -z compressed.gz

file -f filelist.txt

# 檢查上傳目錄中的所有文件
find /var/www/uploads -type f -exec file {} \;

# 找出所有非文本文件
find /tmp -type f -exec file {} \; | grep -v "text"

# 確認(rèn)編譯后的文件確實(shí)是可執(zhí)行文件
file myprogram
# 應(yīng)該輸出類(lèi)似: ELF 64-bit LSB executable...

# 自定義魔術(shù)文件示例
0       string          MYAPP1.0        My Custom Application File
>4      byte            x               \b, version %d
>5      leshort         x               \b.%d

file -m ~/.magic myfile.dat

# 統(tǒng)計(jì)目錄中各種文件類(lèi)型的數(shù)量
file * | cut -d: -f2 | sort | uniq -c | sort -nr

# 只獲取文件類(lèi)型部分，用于腳本處理
file -b --mime-type myfile.pdf
# 輸出: application/pdf

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class SimpleFileIdentifier {
    
    // 魔術(shù)數(shù)字映射表
    private static final Map<String, String> MAGIC_NUMBERS = new HashMap<>();
    
    static {
        // 初始化魔術(shù)數(shù)字
        MAGIC_NUMBERS.put("89504E470D0A1A0A", "PNG image");
        MAGIC_NUMBERS.put("FFD8FFE0", "JPEG image");
        MAGIC_NUMBERS.put("FFD8FFE1", "JPEG image");
        MAGIC_NUMBERS.put("FFD8FFDB", "JPEG image");
        MAGIC_NUMBERS.put("255044462D", "PDF document"); // %PDF-
        MAGIC_NUMBERS.put("504B0304", "ZIP archive"); // PK..
        MAGIC_NUMBERS.put("526172211A0700", "RAR archive"); // Rar!..
        MAGIC_NUMBERS.put("526172211A070100", "RAR archive"); // Rar!....
        MAGIC_NUMBERS.put("1F8B08", "GZIP compressed");
        MAGIC_NUMBERS.put("424D", "BMP image"); // BM
        MAGIC_NUMBERS.put("474946383761", "GIF image"); // GIF87a
        MAGIC_NUMBERS.put("474946383961", "GIF image"); // GIF89a
    }
    
    public static String identifyFileType(String filePath) throws IOException {
        Path path = Paths.get(filePath);
        
        // 檢查文件是否存在
        if (!Files.exists(path)) {
            return "File does not exist";
        }
        
        // 檢查是否為目錄
        if (Files.isDirectory(path)) {
            return "directory";
        }
        
        // 讀取文件頭部字節(jié)
        byte[] header = readHeaderBytes(path, 8);
        
        // 嘗試匹配魔術(shù)數(shù)字
        String fileType = matchMagicNumber(header);
        if (fileType != null) {
            return fileType;
        }
        
        // 如果沒(méi)有匹配到魔術(shù)數(shù)字，嘗試文本檢測(cè)
        if (isTextFile(path)) {
            return "ASCII text";
        }
        
        return "data"; // 未知二進(jìn)制數(shù)據(jù)
    }
    
    private static byte[] readHeaderBytes(Path path, int length) throws IOException {
        try (InputStream is = Files.newInputStream(path)) {
            byte[] buffer = new byte[length];
            int bytesRead = is.read(buffer);
            if (bytesRead < length) {
                byte[] result = new byte[bytesRead];
                System.arraycopy(buffer, 0, result, 0, bytesRead);
                return result;
            }
            return buffer;
        }
    }
    
    private static String matchMagicNumber(byte[] header) {
        // 將字節(jié)數(shù)組轉(zhuǎn)換為十六進(jìn)制字符串
        String hexHeader = bytesToHex(header);
        
        // 嘗試匹配不同長(zhǎng)度的魔術(shù)數(shù)字
        for (int len = hexHeader.length(); len >= 2; len -= 2) {
            String prefix = hexHeader.substring(0, len);
            if (MAGIC_NUMBERS.containsKey(prefix)) {
                return MAGIC_NUMBERS.get(prefix);
            }
        }
        
        return null;
    }
    
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }
    
    private static boolean isTextFile(Path path) {
        try {
            byte[] content = Files.readAllBytes(path);
            if (content.length == 0) {
                return true; // 空文件視為文本文件
            }
            
            // 檢查是否包含大量非打印字符
            int nonPrintableCount = 0;
            for (byte b : content) {
                if (b < 32 && b != 9 && b != 10 && b != 13) { // 不包括制表符、換行符、回車(chē)符
                    nonPrintableCount++;
                }
            }
            
            // 如果非打印字符比例超過(guò)30%，則認(rèn)為是二進(jìn)制文件
            return ((double) nonPrintableCount / content.length) < 0.3;
            
        } catch (IOException e) {
            return false;
        }
    }
    
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage: java SimpleFileIdentifier <file_path>");
            return;
        }
        
        try {
            String result = identifyFileType(args[0]);
            System.out.println(args[0] + ": " + result);
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class AdvancedFileIdentifier {
    
    // 魔術(shù)數(shù)字到文件類(lèi)型的映射
    private static final Map<String, FileType> MAGIC_SIGNATURES = new HashMap<>();
    
    static {
        // 圖像文件
        MAGIC_SIGNATURES.put("89504E470D0A1A0A", 
            new FileType("PNG image", "image/png"));
        MAGIC_SIGNATURES.put("FFD8FFE0", 
            new FileType("JPEG image", "image/jpeg"));
        MAGIC_SIGNATURES.put("FFD8FFE1", 
            new FileType("JPEG image", "image/jpeg"));
        MAGIC_SIGNATURES.put("FFD8FFDB", 
            new FileType("JPEG image", "image/jpeg"));
        MAGIC_SIGNATURES.put("474946383761", 
            new FileType("GIF image", "image/gif"));
        MAGIC_SIGNATURES.put("474946383961", 
            new FileType("GIF image", "image/gif"));
        MAGIC_SIGNATURES.put("424D", 
            new FileType("BMP image", "image/bmp"));
        
        // 文檔文件
        MAGIC_SIGNATURES.put("255044462D", 
            new FileType("PDF document", "application/pdf"));
        MAGIC_SIGNATURES.put("504B0304", 
            new FileType("ZIP archive", "application/zip"));
        MAGIC_SIGNATURES.put("526172211A0700", 
            new FileType("RAR archive", "application/x-rar-compressed"));
        MAGIC_SIGNATURES.put("526172211A070100", 
            new FileType("RAR archive", "application/x-rar-compressed"));
        
        // 壓縮文件
        MAGIC_SIGNATURES.put("1F8B08", 
            new FileType("GZIP compressed", "application/gzip"));
        MAGIC_SIGNATURES.put("425A68", 
            new FileType("BZIP2 compressed", "application/x-bzip2"));
        
        // 可執(zhí)行文件
        MAGIC_SIGNATURES.put("7F454C46", 
            new FileType("ELF executable", "application/x-executable"));
        
        // Office文檔
        MAGIC_SIGNATURES.put("D0CF11E0A1B11AE1", 
            new FileType("Microsoft Office document", "application/msword"));
    }
    
    // 文件類(lèi)型內(nèi)部類(lèi)
    static class FileType {
        private final String description;
        private final String mimeType;
        
        public FileType(String description, String mimeType) {
            this.description = description;
            this.mimeType = mimeType;
        }
        
        public String getDescription() { return description; }
        public String getMimeType() { return mimeType; }
        
        @Override
        public String toString() {
            return description;
        }
    }
    
    public static FileType identifyFileType(String filePath) throws IOException {
        Path path = Paths.get(filePath);
        
        // 檢查文件是否存在
        if (!Files.exists(path)) {
            throw new FileNotFoundException("File does not exist: " + filePath);
        }
        
        // 檢查是否為目錄
        if (Files.isDirectory(path)) {
            return new FileType("directory", "inode/directory");
        }
        
        // 獲取文件大小
        long fileSize = Files.size(path);
        if (fileSize == 0) {
            return new FileType("empty", "inode/x-empty");
        }
        
        // 讀取文件頭部字節(jié)（最多16字節(jié)）
        byte[] header = readHeaderBytes(path, 16);
        
        // 嘗試匹配魔術(shù)數(shù)字
        FileType fileType = matchMagicSignature(header);
        if (fileType != null) {
            return fileType;
        }
        
        // 如果沒(méi)有匹配到魔術(shù)數(shù)字，嘗試文本檢測(cè)
        if (isPlainTextFile(path)) {
            String encoding = detectEncoding(path);
            return new FileType("ASCII text", "text/plain; charset=" + encoding);
        }
        
        // 檢查是否為UTF-8編碼的文本文件
        if (isUtf8TextFile(path)) {
            return new FileType("UTF-8 Unicode text", "text/plain; charset=utf-8");
        }
        
        return new FileType("data", "application/octet-stream"); // 未知二進(jìn)制數(shù)據(jù)
    }
    
    private static byte[] readHeaderBytes(Path path, int maxLength) throws IOException {
        try (InputStream is = Files.newInputStream(path)) {
            byte[] buffer = new byte[maxLength];
            int totalRead = 0;
            int bytesRead;
            
            while (totalRead < maxLength && (bytesRead = is.read(buffer, totalRead, maxLength - totalRead)) != -1) {
                totalRead += bytesRead;
            }
            
            if (totalRead < maxLength) {
                byte[] result = new byte[totalRead];
                System.arraycopy(buffer, 0, result, 0, totalRead);
                return result;
            }
            
            return buffer;
        }
    }
    
    private static FileType matchMagicSignature(byte[] header) {
        String hexHeader = bytesToHex(header);
        
        // 嘗試匹配不同長(zhǎng)度的簽名
        for (int len = Math.min(hexHeader.length(), 32); len >= 2; len -= 2) {
            String prefix = hexHeader.substring(0, len);
            if (MAGIC_SIGNATURES.containsKey(prefix)) {
                return MAGIC_SIGNATURES.get(prefix);
            }
        }
        
        return null;
    }
    
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }
    
    private static boolean isPlainTextFile(Path path) {
        try {
            // 對(duì)于大文件，只檢查前幾KB
            long maxSizeToCheck = Math.min(Files.size(path), 8192);
            byte[] content = Files.readAllBytes(path);
            
            if (maxSizeToCheck < content.length) {
                byte[] truncated = new byte[(int) maxSizeToCheck];
                System.arraycopy(content, 0, truncated, 0, (int) maxSizeToCheck);
                content = truncated;
            }
            
            if (content.length == 0) {
                return true;
            }
            
            // 檢查是否包含大量非ASCII字符
            int nonAsciiCount = 0;
            for (byte b : content) {
                if (b < 0 || (b > 127 && b != -1)) { // 負(fù)數(shù)表示非ASCII
                    nonAsciiCount++;
                }
            }
            
            // 如果非ASCII字符比例超過(guò)20%，可能不是純文本
            return ((double) nonAsciiCount / content.length) < 0.2;
            
        } catch (IOException e) {
            return false;
        }
    }
    
    private static boolean isUtf8TextFile(Path path) {
        try {
            // 嘗試作為UTF-8讀取
            byte[] content = Files.readAllBytes(path);
            if (content.length == 0) {
                return true;
            }
            
            // 簡(jiǎn)單的UTF-8驗(yàn)證
            int i = 0;
            while (i < content.length) {
                byte b = content[i];
                if ((b & 0x80) == 0) {
                    // 1-byte sequence
                    i++;
                } else if ((b & 0xE0) == 0xC0) {
                    // 2-byte sequence
                    if (i + 1 >= content.length) return false;
                    if ((content[i+1] & 0xC0) != 0x80) return false;
                    i += 2;
                } else if ((b & 0xF0) == 0xE0) {
                    // 3-byte sequence
                    if (i + 2 >= content.length) return false;
                    if ((content[i+1] & 0xC0) != 0x80) return false;
                    if ((content[i+2] & 0xC0) != 0x80) return false;
                    i += 3;
                } else if ((b & 0xF8) == 0xF0) {
                    // 4-byte sequence
                    if (i + 3 >= content.length) return false;
                    if ((content[i+1] & 0xC0) != 0x80) return false;
                    if ((content[i+2] & 0xC0) != 0x80) return false;
                    if ((content[i+3] & 0xC0) != 0x80) return false;
                    i += 4;
                } else {
                    return false; // Invalid UTF-8
                }
            }
            
            // 如果能成功解析為UTF-8，再檢查是否主要是文本
            String text = new String(content, "UTF-8");
            int controlCharCount = 0;
            for (char c : text.toCharArray()) {
                if (c < 32 && c != '\t' && c != '\n' && c != '\r') {
                    controlCharCount++;
                }
            }
            
            return ((double) controlCharCount / text.length()) < 0.3;
            
        } catch (Exception e) {
            return false;
        }
    }
    
    private static String detectEncoding(Path path) {
        // 簡(jiǎn)單的編碼檢測(cè)
        try {
            byte[] content = Files.readAllBytes(path);
            if (content.length == 0) {
                return "us-ascii";
            }
            
            // 檢查UTF-8 BOM
            if (content.length >= 3 && 
                content[0] == (byte)0xEF && 
                content[1] == (byte)0xBB && 
                content[2] == (byte)0xBF) {
                return "utf-8";
            }
            
            // 檢查UTF-16 LE BOM
            if (content.length >= 2 && 
                content[0] == (byte)0xFF && 
                content[1] == (byte)0xFE) {
                return "utf-16le";
            }
            
            // 檢查UTF-16 BE BOM
            if (content.length >= 2 && 
                content[0] == (byte)0xFE && 
                content[1] == (byte)0xFF) {
                return "utf-16be";
            }
            
            // 默認(rèn)假設(shè)為ASCII
            return "us-ascii";
            
        } catch (IOException e) {
            return "unknown";
        }
    }
    
    public static void printFileInfo(String filePath, boolean showMime) {
        try {
            FileType fileType = identifyFileType(filePath);
            if (showMime) {
                System.out.println(filePath + ": " + fileType.getMimeType());
            } else {
                System.out.println(filePath + ": " + fileType.getDescription());
            }
        } catch (IOException e) {
            System.err.println(filePath + ": ERROR - " + e.getMessage());
        }
    }
    
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage: java AdvancedFileIdentifier [-i] <file_path> [file_path...]");
            System.out.println("  -i: Show MIME type instead of description");
            return;
        }
        
        boolean showMime = false;
        int startIndex = 0;
        
        if (args[0].equals("-i")) {
            showMime = true;
            startIndex = 1;
        }
        
        if (startIndex >= args.length) {
            System.out.println("No files specified");
            return;
        }
        
        for (int i = startIndex; i < args.length; i++) {
            printFileInfo(args[i], showMime);
        }
    }
}

import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

public class ProfessionalFileIdentifier {
    
    // 支持的文件類(lèi)型簽名
    private static final Map<String, FileTypeSignature> FILE_SIGNATURES = new HashMap<>();
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    static {
        initializeSignatures();
    }
    
    static class FileTypeSignature {
        private final String description;
        private final String mimeType;
        private final String extension;
        private final int confidenceLevel; // 1-100
        
        public FileTypeSignature(String description, String mimeType, String extension, int confidenceLevel) {
            this.description = description;
            this.mimeType = mimeType;
            this.extension = extension;
            this.confidenceLevel = confidenceLevel;
        }
        
        // Getters
        public String getDescription() { return description; }
        public String getMimeType() { return mimeType; }
        public String getExtension() { return extension; }
        public int getConfidenceLevel() { return confidenceLevel; }
        
        @Override
        public String toString() {
            return String.format("%s (%s) - %d%% confidence", description, mimeType, confidenceLevel);
        }
    }
    
    private static void initializeSignatures() {
        // 圖像格式
        FILE_SIGNATURES.put("89504E470D0A1A0A", 
            new FileTypeSignature("PNG image", "image/png", "png", 100));
        FILE_SIGNATURES.put("FFD8FFE0", 
            new FileTypeSignature("JPEG image", "image/jpeg", "jpg", 95));
        FILE_SIGNATURES.put("FFD8FFE1", 
            new FileTypeSignature("JPEG image", "image/jpeg", "jpg", 95));
        FILE_SIGNATURES.put("FFD8FFDB", 
            new FileTypeSignature("JPEG image", "image/jpeg", "jpg", 95));
        FILE_SIGNATURES.put("474946383761", 
            new FileTypeSignature("GIF image", "image/gif", "gif", 100));
        FILE_SIGNATURES.put("474946383961", 
            new FileTypeSignature("GIF image", "image/gif", "gif", 100));
        FILE_SIGNATURES.put("424D", 
            new FileTypeSignature("BMP image", "image/bmp", "bmp", 90));
        FILE_SIGNATURES.put("49492A00", 
            new FileTypeSignature("TIFF image", "image/tiff", "tif", 95));
        FILE_SIGNATURES.put("4D4D002A", 
            new FileTypeSignature("TIFF image", "image/tiff", "tif", 95));
        
        // 文檔格式
        FILE_SIGNATURES.put("255044462D", 
            new FileTypeSignature("PDF document", "application/pdf", "pdf", 100));
        FILE_SIGNATURES.put("D0CF11E0A1B11AE1", 
            new FileTypeSignature("Microsoft Office document", "application/msword", "doc", 85));
        FILE_SIGNATURES.put("504B030414000600", 
            new FileTypeSignature("Microsoft Office Open XML", "application/vnd.openxmlformats-officedocument", "docx", 90));
        
        // 壓縮格式
        FILE_SIGNATURES.put("504B0304", 
            new FileTypeSignature("ZIP archive", "application/zip", "zip", 95));
        FILE_SIGNATURES.put("526172211A0700", 
            new FileTypeSignature("RAR archive", "application/x-rar-compressed", "rar", 95));
        FILE_SIGNATURES.put("526172211A070100", 
            new FileTypeSignature("RAR archive", "application/x-rar-compressed", "rar", 95));
        FILE_SIGNATURES.put("1F8B08", 
            new FileTypeSignature("GZIP compressed", "application/gzip", "gz", 95));
        FILE_SIGNATURES.put("425A68", 
            new FileTypeSignature("BZIP2 compressed", "application/x-bzip2", "bz2", 95));
        FILE_SIGNATURES.put("504B0506", 
            new FileTypeSignature("ZIP archive (empty)", "application/zip", "zip", 90));
        
        // 可執(zhí)行文件
        FILE_SIGNATURES.put("7F454C46", 
            new FileTypeSignature("ELF executable", "application/x-executable", "bin", 95));
        FILE_SIGNATURES.put("4D5A", 
            new FileTypeSignature("Windows PE executable", "application/x-msdownload", "exe", 90));
        
        // 音頻視頻
        FILE_SIGNATURES.put("494433", 
            new FileTypeSignature("MP3 audio", "audio/mpeg", "mp3", 85));
        FILE_SIGNATURES.put("52494646", 
            new FileTypeSignature("RIFF container (WAV/AVI)", "audio/wav", "wav", 80));
        FILE_SIGNATURES.put("00000018667479706D703432", 
            new FileTypeSignature("MP4 video", "video/mp4", "mp4", 90));
        
        // 數(shù)據(jù)庫(kù)
        FILE_SIGNATURES.put("53514C69746520666F726D6174203300", 
            new FileTypeSignature("SQLite database", "application/x-sqlite3", "db", 100));
    }
    
    public static class FileIdentificationResult {
        private final String fileName;
        private final String filePath;
        private final FileTypeSignature identifiedType;
        private final String fallbackType;
        private final long fileSize;
        private final Date lastModified;
        private final boolean isDirectory;
        private final boolean exists;
        
        public FileIdentificationResult(String fileName, String filePath, FileTypeSignature identifiedType, 
                                      String fallbackType, long fileSize, Date lastModified, 
                                      boolean isDirectory, boolean exists) {
            this.fileName = fileName;
            this.filePath = filePath;
            this.identifiedType = identifiedType;
            this.fallbackType = fallbackType;
            this.fileSize = fileSize;
            this.lastModified = lastModified;
            this.isDirectory = isDirectory;
            this.exists = exists;
        }
        
        // Getters
        public String getFileName() { return fileName; }
        public String getFilePath() { return filePath; }
        public FileTypeSignature getIdentifiedType() { return identifiedType; }
        public String getFallbackType() { return fallbackType; }
        public long getFileSize() { return fileSize; }
        public Date getLastModified() { return lastModified; }
        public boolean isDirectory() { return isDirectory; }
        public boolean exists() { return exists; }
        
        public String getFormattedFileSize() {
            if (fileSize < 1024) return fileSize + " B";
            else if (fileSize < 1024 * 1024) return String.format("%.1f KB", fileSize / 1024.0);
            else if (fileSize < 1024 * 1024 * 1024) return String.format("%.1f MB", fileSize / (1024.0 * 1024.0));
            else return String.format("%.1f GB", fileSize / (1024.0 * 1024.0 * 1024.0));
        }
        
        public String getFormattedLastModified() {
            return DATE_FORMAT.format(lastModified);
        }
        
        public String getFinalTypeDescription() {
            if (!exists) return "File does not exist";
            if (isDirectory) return "directory";
            if (identifiedType != null) return identifiedType.getDescription();
            return fallbackType != null ? fallbackType : "unknown data";
        }
        
        public String getFinalMimeType() {
            if (!exists) return "application/x-not-exist";
            if (isDirectory) return "inode/directory";
            if (identifiedType != null) return identifiedType.getMimeType();
            return "application/octet-stream";
        }
        
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(fileName).append(": ").append(getFinalTypeDescription());
            sb.append(" (").append(getFormattedFileSize()).append(", modified: ").append(getFormattedLastModified()).append(")");
            return sb.toString();
        }
    }
    
    public static FileIdentificationResult identifyFile(String filePath, boolean followLinks) throws IOException {
        Path path = Paths.get(filePath);
        
        // 解析符號(hào)鏈接
        if (followLinks && Files.isSymbolicLink(path)) {
            try {
                path = Files.readSymbolicLink(path);
            } catch (IOException e) {
                // 如果無(wú)法解析符號(hào)鏈接，繼續(xù)使用原路徑
            }
        }
        
        BasicFileAttributes attrs;
        try {
            attrs = Files.readAttributes(path, BasicFileAttributes.class);
        } catch (NoSuchFileException e) {
            return new FileIdentificationResult(
                new File(filePath).getName(), 
                filePath, 
                null, 
                null, 
                0, 
                new Date(), 
                false, 
                false
            );
        }
        
        // 檢查是否為目錄
        if (attrs.isDirectory()) {
            return new FileIdentificationResult(
                new File(filePath).getName(),
                filePath,
                null,
                null,
                attrs.size(),
                new Date(attrs.lastModifiedTime().toMillis()),
                true,
                true
            );
        }
        
        // 讀取文件頭部
        byte[] header = readHeaderBytes(path, 32);
        
        // 匹配文件簽名
        FileTypeSignature matchedSignature = matchFileSignature(header);
        
        // 如果沒(méi)有匹配到簽名，嘗試文本檢測(cè)
        String fallbackType = null;
        if (matchedSignature == null) {
            if (isPlainTextFile(path)) {
                fallbackType = "ASCII text";
            } else if (isUtf8TextFile(path)) {
                fallbackType = "UTF-8 Unicode text";
            } else {
                fallbackType = "data";
            }
        }
        
        return new FileIdentificationResult(
            new File(filePath).getName(),
            filePath,
            matchedSignature,
            fallbackType,
            attrs.size(),
            new Date(attrs.lastModifiedTime().toMillis()),
            false,
            true
        );
    }
    
    private static byte[] readHeaderBytes(Path path, int maxLength) throws IOException {
        try (InputStream is = Files.newInputStream(path)) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int totalRead = 0;
            int bytesRead;
            
            while (totalRead < maxLength && (bytesRead = is.read(buffer, 0, 
                   Math.min(buffer.length, maxLength - totalRead))) != -1) {
                baos.write(buffer, 0, bytesRead);
                totalRead += bytesRead;
            }
            
            return baos.toByteArray();
        }
    }
    
    private static FileTypeSignature matchFileSignature(byte[] header) {
        if (header.length == 0) {
            return null;
        }
        
        String hexHeader = bytesToHex(header);
        
        // 嘗試匹配不同長(zhǎng)度的簽名
        List<Map.Entry<String, FileTypeSignature>> matches = new ArrayList<>();
        
        for (Map.Entry<String, FileTypeSignature> entry : FILE_SIGNATURES.entrySet()) {
            String signature = entry.getKey();
            if (hexHeader.startsWith(signature)) {
                matches.add(entry);
            }
        }
        
        // 如果有多個(gè)匹配，選擇最長(zhǎng)的那個(gè)（最具體的）
        if (!matches.isEmpty()) {
            matches.sort((a, b) -> Integer.compare(b.getKey().length(), a.getKey().length()));
            return matches.get(0).getValue();
        }
        
        return null;
    }
    
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }
    
    private static boolean isPlainTextFile(Path path) {
        try {
            long size = Files.size(path);
            if (size == 0) {
                return true;
            }
            
            // 對(duì)于大文件，只檢查前8KB
            long checkSize = Math.min(size, 8192);
            byte[] content = Files.readAllBytes(path);
            
            if (checkSize < content.length) {
                byte[] truncated = new byte[(int) checkSize];
                System.arraycopy(content, 0, truncated, 0, (int) checkSize);
                content = truncated;
            }
            
            int nonPrintableCount = 0;
            for (byte b : content) {
                // 允許的控制字符：制表符(9)、換行符(10)、回車(chē)符(13)
                if (b < 32 && b != 9 && b != 10 && b != 13) {
                    nonPrintableCount++;
                }
                // 檢查高位設(shè)置的字符（可能是非ASCII）
                if (b < 0) {
                    nonPrintableCount++; // 對(duì)于純ASCII文本，負(fù)值表示非ASCII
                }
            }
            
            // 如果非打印字符比例小于30%，認(rèn)為是文本文件
            return ((double) nonPrintableCount / content.length) < 0.3;
            
        } catch (IOException e) {
            return false;
        }
    }
    
    private static boolean isUtf8TextFile(Path path) {
        try {
            byte[] content = Files.readAllBytes(path);
            if (content.length == 0) {
                return true;
            }
            
            // 檢查UTF-8 BOM
            if (content.length >= 3 && 
                content[0] == (byte)0xEF && 
                content[1] == (byte)0xBB && 
                content[2] == (byte)0xBF) {
                // 跳過(guò)BOM
                byte[] withoutBom = new byte[content.length - 3];
                System.arraycopy(content, 3, withoutBom, 0, withoutBom.length);
                content = withoutBom;
            }
            
            // 驗(yàn)證UTF-8編碼
            int i = 0;
            while (i < content.length) {
                byte b = content[i];
                if ((b & 0x80) == 0) {
                    // 1-byte sequence (ASCII)
                    i++;
                } else if ((b & 0xE0) == 0xC0) {
                    // 2-byte sequence
                    if (i + 1 >= content.length) return false;
                    if ((content[i+1] & 0xC0) != 0x80) return false;
                    i += 2;
                } else if ((b & 0xF0) == 0xE0) {
                    // 3-byte sequence
                    if (i + 2 >= content.length) return false;
                    if ((content[i+1] & 0xC0) != 0x80) return false;
                    if ((content[i+2] & 0xC0) != 0x80) return false;
                    i += 3;
                } else if ((b & 0xF8) == 0xF0) {
                    // 4-byte sequence
                    if (i + 3 >= content.length) return false;
                    if ((content[i+1] & 0xC0) != 0x80) return false;
                    if ((content[i+2] & 0xC0) != 0x80) return false;
                    if ((content[i+3] & 0xC0) != 0x80) return false;
                    i += 4;
                } else {
                    return false; // Invalid UTF-8
                }
            }
            
            // 如果是有效的UTF-8，檢查是否主要是文本內(nèi)容
            String text;
            try {
                text = new String(content, "UTF-8");
            } catch (Exception e) {
                return false;
            }
            
            int controlCharCount = 0;
            for (char c : text.toCharArray()) {
                if (c < 32 && c != '\t' && c != '\n' && c != '\r') {
                    controlCharCount++;
                }
            }
            
            return ((double) controlCharCount / text.length()) < 0.3;
            
        } catch (Exception e) {
            return false;
        }
    }
    
    public static List<FileIdentificationResult> identifyFiles(List<String> filePaths, boolean followLinks) {
        List<FileIdentificationResult> results = new ArrayList<>();
        
        for (String filePath : filePaths) {
            try {
                FileIdentificationResult result = identifyFile(filePath, followLinks);
                results.add(result);
            } catch (IOException e) {
                results.add(new FileIdentificationResult(
                    new File(filePath).getName(),
                    filePath,
                    null,
                    "ERROR: " + e.getMessage(),
                    0,
                    new Date(),
                    false,
                    false
                ));
            }
        }
        
        return results;
    }
    
    public static List<FileIdentificationResult> identifyDirectory(String dirPath, boolean recursive, boolean followLinks) {
        List<FileIdentificationResult> results = new ArrayList<>();
        
        try {
            Path dir = Paths.get(dirPath);
            if (!Files.exists(dir)) {
                System.err.println("Directory does not exist: " + dirPath);
                return results;
            }
            
            if (!Files.isDirectory(dir)) {
                // 如果不是目錄，當(dāng)作普通文件處理
                try {
                    results.add(identifyFile(dirPath, followLinks));
                } catch (IOException e) {
                    System.err.println("Error processing " + dirPath + ": " + e.getMessage());
                }
                return results;
            }
            
            if (recursive) {
                Files.walk(dir)
                    .filter(Files::isRegularFile)
                    .forEach(path -> {
                        try {
                            results.add(identifyFile(path.toString(), followLinks));
                        } catch (IOException e) {
                            System.err.println("Error processing " + path + ": " + e.getMessage());
                        }
                    });
            } else {
                Files.list(dir)
                    .filter(Files::isRegularFile)
                    .forEach(path -> {
                        try {
                            results.add(identifyFile(path.toString(), followLinks));
                        } catch (IOException e) {
                            System.err.println("Error processing " + path + ": " + e.getMessage());
                        }
                    });
            }
            
        } catch (IOException e) {
            System.err.println("Error accessing directory " + dirPath + ": " + e.getMessage());
        }
        
        return results;
    }
    
    public static void printResults(List<FileIdentificationResult> results, boolean showMime, boolean showDetails) {
        for (FileIdentificationResult result : results) {
            if (showDetails) {
                System.out.println("=== File Information ===");
                System.out.println("Name: " + result.getFileName());
                System.out.println("Path: " + result.getFilePath());
                System.out.println("Type: " + result.getFinalTypeDescription());
                if (showMime) {
                    System.out.println("MIME: " + result.getFinalMimeType());
                }
                System.out.println("Size: " + result.getFormattedFileSize());
                System.out.println("Last Modified: " + result.getFormattedLastModified());
                if (result.getIdentifiedType() != null) {
                    System.out.println("Confidence: " + result.getIdentifiedType().getConfidenceLevel() + "%");
                    System.out.println("Suggested Extension: ." + result.getIdentifiedType().getExtension());
                }
                System.out.println("========================");
            } else {
                if (showMime) {
                    System.out.println(result.getFileName() + ": " + result.getFinalMimeType());
                } else {
                    System.out.println(result);
                }
            }
        }
    }
    
    public static void printSummary(List<FileIdentificationResult> results) {
        System.out.println("\n=== Summary ===");
        System.out.println("Total files processed: " + results.size());
        
        long totalSize = results.stream()
            .filter(FileIdentificationResult::exists)
            .mapToLong(FileIdentificationResult::getFileSize)
            .sum();
        
        System.out.println("Total size: " + formatFileSize(totalSize));
        
        Map<String, Long> typeCounts = results.stream()
            .filter(r -> r.exists() && !r.isDirectory())
            .collect(Collectors.groupingBy(
                FileIdentificationResult::getFinalTypeDescription,
                Collectors.counting()
            ));
        
        System.out.println("File types:");
        typeCounts.entrySet().stream()
            .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
            .forEach(entry -> 
                System.out.println("  " + entry.getKey() + ": " + entry.getValue() + " file(s)")
            );
    }
    
    private static String formatFileSize(long size) {
        if (size < 1024) return size + " B";
        else if (size < 1024 * 1024) return String.format("%.1f KB", size / 1024.0);
        else if (size < 1024 * 1024 * 1024) return String.format("%.1f MB", size / (1024.0 * 1024.0));
        else return String.format("%.1f GB", size / (1024.0 * 1024.0 * 1024.0));
    }
    
    public static void main(String[] args) {
        if (args.length == 0) {
            printHelp();
            return;
        }
        
        boolean showMime = false;
        boolean showDetails = false;
        boolean followLinks = false;
        boolean recursive = false;
        boolean summary = false;
        boolean batchMode = false;
            List<String> filesToProcess = new ArrayList<>();
        
        for (int i = 0; i < args.length; i++) {
            String arg = args[i];
            
            if (arg.equals("-h") || arg.equals("--help")) {
                printHelp();
                return;
            } else if (arg.equals("-i") || arg.equals("--mime")) {
                showMime = true;
            } else if (arg.equals("-l") || arg.equals("--long")) {
                showDetails = true;
            } else if (arg.equals("-L") || arg.equals("--follow-links")) {
                followLinks = true;
            } else if (arg.equals("-r") || arg.equals("--recursive")) {
                recursive = true;
            } else if (arg.equals("-s") || arg.equals("--summary")) {
                summary = true;
            } else if (arg.equals("-f") || arg.equals("--file-list")) {
                if (i + 1 < args.length) {
                    batchMode = true;
                    String fileListPath = args[++i];
                    try {
                        List<String> fileList = Files.readAllLines(Paths.get(fileListPath));
                        filesToProcess.addAll(fileList);
                    } catch (IOException e) {
                        System.err.println("Error reading file list: " + e.getMessage());
                        return;
                    }
                } else {
                    System.err.println("Missing filename after " + arg);
                    return;
                }
            } else if (arg.startsWith("-")) {
                System.err.println("Unknown option: " + arg);
                printHelp();
                return;
            } else {
                filesToProcess.add(arg);
            }
        }
        
        if (filesToProcess.isEmpty()) {
            System.out.println("No files specified");
            return;
        }
        
        List<FileIdentificationResult> results = new ArrayList<>();
        
        if (batchMode) {
            // 批量模式，每個(gè)參數(shù)都是文件路徑
            results = identifyFiles(filesToProcess, followLinks);
        } else {
            // 普通模式，檢查每個(gè)參數(shù)是文件還是目錄
            for (String path : filesToProcess) {
                File file = new File(path);
                if (file.isDirectory()) {
                    List<FileIdentificationResult> dirResults = identifyDirectory(path, recursive, followLinks);
                    results.addAll(dirResults);
                } else {
                    try {
                        results.add(identifyFile(path, followLinks));
                    } catch (IOException e) {
                        System.err.println("Error processing " + path + ": " + e.getMessage());
                    }
                }
            }
        }
        
        printResults(results, showMime, showDetails);
        
        if (summary && !results.isEmpty()) {
            printSummary(results);
        }
    }
    
    private static void printHelp() {
        System.out.println("Professional File Identifier");
        System.out.println("Usage: java ProfessionalFileIdentifier [OPTIONS] <file_or_directory>...");
        System.out.println();
        System.out.println("Options:");
        System.out.println("  -i, --mime           Show MIME type instead of description");
        System.out.println("  -l, --long           Show detailed information");
        System.out.println("  -L, --follow-links   Follow symbolic links");
        System.out.println("  -r, --recursive      Recursively process directories");
        System.out.println("  -s, --summary        Show summary statistics");
        System.out.println("  -f, --file-list <file>  Read file paths from specified file");
        System.out.println("  -h, --help           Show this help message");
        System.out.println();
        System.out.println("Examples:");
        System.out.println("  java ProfessionalFileIdentifier myfile.pdf");
        System.out.println("  java ProfessionalFileIdentifier -i myfile.pdf");
        System.out.println("  java ProfessionalFileIdentifier -l myfile.pdf");
        System.out.println("  java ProfessionalFileIdentifier -r /path/to/directory");
        System.out.println("  java ProfessionalFileIdentifier -f filelist.txt");
        System.out.println();
        System.out.println("Supported file formats include: PNG, JPEG, GIF, BMP, TIFF, PDF, ZIP, RAR, GZIP, BZIP2, ELF, MP3, WAV, MP4, SQLite, and more.");
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

public class CachedFileIdentifier extends ProfessionalFileIdentifier {
    private static final ConcurrentHashMap<String, FileIdentificationResult> CACHE = new ConcurrentHashMap<>();
    private static final long CACHE_EXPIRATION_MS = TimeUnit.MINUTES.toMillis(5);
    
    private static class CacheEntry {
        final FileIdentificationResult result;
        final long timestamp;
        
        CacheEntry(FileIdentificationResult result) {
            this.result = result;
            this.timestamp = System.currentTimeMillis();
        }
        
        boolean isExpired() {
            return System.currentTimeMillis() - timestamp > CACHE_EXPIRATION_MS;
        }
    }
    
    public static FileIdentificationResult identifyFileWithCache(String filePath, boolean followLinks) throws IOException {
        // 清理過(guò)期緩存
        CACHE.entrySet().removeIf(entry -> entry.getValue().isExpired());
        
        // 檢查緩存
        CacheEntry cached = CACHE.get(filePath);
        if (cached != null && !cached.isExpired()) {
            return cached.result;
        }
        
        // 執(zhí)行實(shí)際識(shí)別
        FileIdentificationResult result = identifyFile(filePath, followLinks);
        
        // 緩存結(jié)果
        CACHE.put(filePath, new CacheEntry(result));
        
        return result;
    }
}

import java.util.concurrent.*;
import java.util.stream.Collectors;

public class ParallelFileIdentifier {
    
    public static List<FileIdentificationResult> identifyFilesParallel(List<String> filePaths, 
                                                                    boolean followLinks, 
                                                                    int threads) {
        ExecutorService executor = Executors.newFixedThreadPool(threads);
        List<Future<FileIdentificationResult>> futures = new ArrayList<>();
        
        for (String filePath : filePaths) {
            Future<FileIdentificationResult> future = executor.submit(() -> {
                try {
                    return ProfessionalFileIdentifier.identifyFile(filePath, followLinks);
                } catch (IOException e) {
                    return new ProfessionalFileIdentifier.FileIdentificationResult(
                        new File(filePath).getName(),
                        filePath,
                        null,
                        "ERROR: " + e.getMessage(),
                        0,
                        new Date(),
                        false,
                        false
                    );
                }
            });
            futures.add(future);
        }
        
        List<FileIdentificationResult> results = new ArrayList<>();
        for (Future<FileIdentificationResult> future : futures) {
            try {
                results.add(future.get());
            } catch (InterruptedException | ExecutionException e) {
                // 處理異常
                System.err.println("Error in parallel processing: " + e.getMessage());
            }
        }
        
        executor.shutdown();
        return results;
    }
}

public class SecureFileIdentifier {
    
    private static final Set<String> BLACKLISTED_EXTENSIONS = Set.of(
        "exe", "bat", "cmd", "com", "scr", "pif", "vbs", "js", "jar"
    );
    
    public static boolean isSafeToProcess(String filePath) {
        File file = new File(filePath);
        
        // 規(guī)范化路徑，防止../攻擊
        try {
            String canonicalPath = file.getCanonicalPath();
            String absolutePath = file.getAbsolutePath();
            
            // 檢查路徑遍歷
            if (!canonicalPath.equals(absolutePath)) {
                return false;
            }
            
            // 檢查黑名單擴(kuò)展名
            String fileName = file.getName();
            int dotIndex = fileName.lastIndexOf('.');
            if (dotIndex > 0) {
                String extension = fileName.substring(dotIndex + 1).toLowerCase();
                if (BLACKLISTED_EXTENSIONS.contains(extension)) {
                    return false;
                }
            }
            
            return true;
            
        } catch (IOException e) {
            return false;
        }
    }
    
    public static FileIdentificationResult secureIdentifyFile(String filePath, boolean followLinks) throws IOException {
        if (!isSafeToProcess(filePath)) {
            throw new SecurityException("File path is not safe to process: " + filePath);
        }
        
        return ProfessionalFileIdentifier.identifyFile(filePath, followLinks);
    }
}

public class SizeLimitedFileIdentifier {
    
    private static final long MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
    
    public static FileIdentificationResult identifyFileWithSizeLimit(String filePath, boolean followLinks) throws IOException {
        Path path = Paths.get(filePath);
        
        if (!Files.exists(path)) {
            throw new FileNotFoundException("File does not exist: " + filePath);
        }
        
        long fileSize = Files.size(path);
        if (fileSize > MAX_FILE_SIZE) {
            throw new IOException("File too large to process: " + fileSize + " bytes (limit: " + MAX_FILE_SIZE + ")");
        }
        
        return ProfessionalFileIdentifier.identifyFile(filePath, followLinks);
    }
}

import javax.servlet.http.Part;
import java.io.IOException;
import java.io.InputStream;

public class FileUploadValidator {
    
    public static class UploadValidationResult {
        private final boolean isValid;
        private final String errorMessage;
        private final String detectedType;
        private final String suggestedExtension;
        
        public UploadValidationResult(boolean isValid, String errorMessage, String detectedType, String suggestedExtension) {
            this.isValid = isValid;
            this.errorMessage = errorMessage;
            this.detectedType = detectedType;
            this.suggestedExtension = suggestedExtension;
        }
        
        // Getters
        public boolean isValid() { return isValid; }
        public String getErrorMessage() { return errorMessage; }
        public String getDetectedType() { return detectedType; }
        public String getSuggestedExtension() { return suggestedExtension; }
    }
    
    private static final Set<String> ALLOWED_MIME_TYPES = Set.of(
        "image/jpeg", "image/png", "image/gif", "application/pdf"
    );
    
    private static final long MAX_UPLOAD_SIZE = 10 * 1024 * 1024; // 10MB
    
    public static UploadValidationResult validateUpload(Part filePart) {
        try {
            // 檢查文件大小
            long fileSize = filePart.getSize();
            if (fileSize > MAX_UPLOAD_SIZE) {
                return new UploadValidationResult(false, "File too large", null, null);
            }
            
            if (fileSize == 0) {
                return new UploadValidationResult(false, "Empty file", null, null);
            }
            
            // 讀取文件頭部進(jìn)行類(lèi)型檢測(cè)
            byte[] header = readHeaderFromPart(filePart, 32);
            
            // 識(shí)別文件類(lèi)型
            ProfessionalFileIdentifier.FileTypeSignature signature = 
                ProfessionalFileIdentifier.matchFileSignature(header);
            
            if (signature == null) {
                return new UploadValidationResult(false, "Unknown or unsupported file type", null, null);
            }
            
            // 檢查MIME類(lèi)型是否允許
            if (!ALLOWED_MIME_TYPES.contains(signature.getMimeType())) {
                return new UploadValidationResult(false, "File type not allowed", signature.getDescription(), signature.getExtension());
            }
            
            return new UploadValidationResult(true, null, signature.getDescription(), signature.getExtension());
            
        } catch (Exception e) {
            return new UploadValidationResult(false, "Error validating file: " + e.getMessage(), null, null);
        }
    }
    
    private static byte[] readHeaderFromPart(Part filePart, int maxLength) throws IOException {
        try (InputStream is = filePart.getInputStream()) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int totalRead = 0;
            int bytesRead;
            
            while (totalRead < maxLength && (bytesRead = is.read(buffer, 0, 
                   Math.min(buffer.length, maxLength - totalRead))) != -1) {
                baos.write(buffer, 0, bytesRead);
                totalRead += bytesRead;
            }
            
            return baos.toByteArray();
        }
    }
}

// 偽代碼：基于機(jī)器學(xué)習(xí)的文件類(lèi)型識(shí)別
public class MLBasedFileIdentifier {
    
    private MLModel model;
    
    public FileType predictFileType(byte[] fileContent) {
        // 提取特征
        FeatureVector features = extractFeatures(fileContent);
        
        // 使用機(jī)器學(xué)習(xí)模型預(yù)測(cè)
        PredictionResult prediction = model.predict(features);
        
        // 返回預(yù)測(cè)結(jié)果
        return new FileType(
            prediction.getClassName(),
            prediction.getMimeType(),
            prediction.getConfidence()
        );
    }
    
    private FeatureVector extractFeatures(byte[] content) {
        // 提取統(tǒng)計(jì)特征、模式特征等
        // 如：字節(jié)分布、熵值、特定模式出現(xiàn)頻率等
        return new FeatureVector();
    }
}

// 偽代碼：與云文件識(shí)別服務(wù)集成
public class CloudFileIdentifier {
    
    private CloudFileRecognitionService cloudService;
    
    public FileIdentificationResult identifyFileCloud(String filePath) throws IOException {
        // 讀取文件內(nèi)容
        byte[] fileContent = Files.readAllBytes(Paths.get(filePath));
        
        // 調(diào)用云服務(wù)API
        CloudRecognitionResult result = cloudService.recognizeFile(fileContent);
        
        // 轉(zhuǎn)換為本地格式
        return convertToLocalResult(result);
    }
    
    private FileIdentificationResult convertToLocalResult(CloudRecognitionResult cloudResult) {
        // 轉(zhuǎn)換邏輯
        return new FileIdentificationResult(/* ... */);
    }
}