जावा में बाइनरी/टेक्स्ट फ़ाइल प्रकार निर्धारित करना?

Question

अर्थात्, आप टेक्स्ट (xml/txt, एन्कोडिंग-स्वतंत्र) से एक संग्रह (जार/रार/आदि) फ़ाइल कैसे बताएंगे?

Answer 1

कोई गारंटीयुक्त तरीका नहीं है, लेकिन यहां संभावनाओं की एक जोड़ी हैं:

1) फ़ाइल पर एक हैडर के लिए देखो। दुर्भाग्यवश, हेडर फ़ाइल-विशिष्ट हैं, इसलिए जब आप यह पता लगाने में सक्षम हो सकते हैं कि यह एक आरएआर फ़ाइल है, तो आपको टेक्स्ट या बाइनरी का अधिक सामान्य जवाब नहीं मिलेगा।

2) चरित्र बनाम गैर-वर्ण प्रकारों की संख्या की गणना करें। टेक्स्ट फाइलें ज्यादातर वर्णमाला वर्ण होंगी जबकि बाइनरी फाइलें - विशेष रूप से संपीड़ित जैसे रार, ज़िप, और ऐसे - बाइट्स को समान रूप से प्रतिनिधित्व किया जाएगा।

3) न्यूलाइन के नियमित रूप से दोहराने वाले पैटर्न की तलाश करें।

Answer 2

आप DROID उपकरण को आजमा सकते हैं।

Answer 3

http://en.wikipedia.org/wiki/Magic_number_(programming)

Answer 4

देखें फ़ाइल बाइट्स 0x09 (टैब) के होते हैं, तो 0x0A (लाइन फ़ीड), 0x0C (फार्म फ़ीड), 0x0D (गाड़ी वापसी), या 0x20 0x7E के माध्यम से है, तो यह शायद ASCII पाठ है ।

यदि फ़ाइल में ऊपर दिए गए तीन को छोड़कर 0x00 से 0x1F कोई अन्य ASCII नियंत्रण वर्ण है, तो यह शायद बाइनरी डेटा है।

यूटीएफ -8 टेक्स्ट हाई ऑर्डर बिट के साथ किसी बाइट के लिए एक बहुत ही विशिष्ट पैटर्न का पालन करता है, लेकिन आईएसओ -885 9 -1 जैसी निश्चित लंबाई वाली एन्कोडिंग नहीं होती है। यूटीएफ -16 में अक्सर शून्य बाइट (0x00) हो सकता है, लेकिन केवल हर दूसरे स्थिति में।

आपको किसी और चीज़ के लिए कमजोर ह्युरिस्टिक की आवश्यकता होगी।

Answer 5

JMimeMagic लाइब्रेरी पर एक नज़र डालें।

jMimeMagic फाइल या धाराओं के MIME प्रकार का निर्धारण करने के लिए एक जावा पुस्तकालय है।

Answer 6

बस आपको बताने के लिए, मैंने काफी अलग रास्ता चुना है। मैं अपने मामले में, केवल 2 प्रकार की फाइलें हैं, संभावना है कि किसी दिए गए फ़ाइल को बाइनरी एक उच्च होगा। तो

1. उस फ़ाइल बाइनरी है, कर क्या किया जाना चाहिए था की कोशिश अनुमान (जैसे deserialize)
2. पकड़ अपवाद शाब्दिक रूप
3. इलाज फ़ाइल
4. कि अगर विफल रहता है, कुछ फ़ाइल स्वयं
साथ कुछ गड़बड़ है

Answer 7

रन file -bi {filename}। यदि जो कुछ भी लौटाता है वह 'टेक्स्ट /' से शुरू होता है, तो यह गैर-बाइनरी है, अन्यथा यह है। ;-)

Answer 8

मैं इस कोड का इस्तेमाल किया और यह बहुत अच्छी तरह से अंग्रेजी और जर्मन पाठ के लिए काम करता है:

private boolean isTextFile(String filePath) throws Exception { 
    File f = new File(filePath); 
    if(!f.exists()) 
     return false; 
    FileInputStream in = new FileInputStream(f); 
    int size = in.available(); 
    if(size > 1000) 
     size = 1000; 
    byte[] data = new byte[size]; 
    in.read(data); 
    in.close(); 
    String s = new String(data, "ISO-8859-1"); 
    String s2 = s.replaceAll(
      "[a-zA-Z0-9ßöäü\\.\\*!\"§\\$\\%&/()=\\?@~'#:,;\\"+ 
      "+><\\|\\[\\]\\{\\}\\^°²³\\\\ \\n\\r\\t_\\-`´âêîô"+ 
      "ÂÊÔÎáéíóàèìòÁÉÍÓÀÈÌÒ©‰¢£¥€±¿»«¼½¾™ª]", ""); 
    // will delete all text signs 

    double d = (double)(s.length() - s2.length())/(double)(s.length()); 
    // percentage of text signs in the text 
    return d > 0.95; 
} 

Answer 9

मैं इस एक बना दिया। थोड़ा सा सरल, लेकिन लैटिन-आधारित भाषाओं के लिए, अनुपात समायोजन के साथ इसे ठीक काम करना चाहिए।

/** 
* Guess whether given file is binary. Just checks for anything under 0x09. 
*/ 
public static boolean isBinaryFile(File f) throws FileNotFoundException, IOException { 
    FileInputStream in = new FileInputStream(f); 
    int size = in.available(); 
    if(size > 1024) size = 1024; 
    byte[] data = new byte[size]; 
    in.read(data); 
    in.close(); 

    int ascii = 0; 
    int other = 0; 

    for(int i = 0; i < data.length; i++) { 
     byte b = data[i]; 
     if(b < 0x09) return true; 

     if(b == 0x09 || b == 0x0A || b == 0x0C || b == 0x0D) ascii++; 
     else if(b >= 0x20 && b <= 0x7E) ascii++; 
     else other++; 
    } 

    if(other == 0) return false; 

    return 100 * other/(ascii + other) > 95; 
} 

Answer 10

जावा 7 फ़ाइलें वर्ग http://docs.oracle.com/javase/7/docs/api/java/nio/file/Files.html#probeContentType(java.nio.file.Path)

boolean isBinaryFile(File f) throws IOException { 
     String type = Files.probeContentType(f.toPath()); 
     if (type == null) { 
      //type couldn't be determined, assume binary 
      return true; 
     } else if (type.startsWith("text")) { 
      return false; 
     } else { 
      //type isn't text 
      return true; 
     } 
    }