精华内容
下载资源
问答
  • 如果很多时候我们没有约定好文件格式,我们就难以读取文件内容,此时,我们就需要一个工具来探测所读文本编码格式,此工具可以允许用户读取诸如utf-8,gbk,gb2312一类的文件格式。内置了一些常用的探测实现类,...
  • java判断文本文件编码格式

    万次阅读 2019-08-06 09:32:00
    上篇文章需要读取当前java或者配置文件编码格式,这里主要支持UTF-8、GBK、UTF-16、Unicode等 /** * 判断文件编码格式 * @param fileName :file * @return 文件编码格式 * @throws Exception */ ...

    上篇文章需要读取当前java或者配置文件的编码格式,这里主要支持UTF-8、GBK、UTF-16、Unicode等

    /**
    	 * 判断文件的编码格式
    	 * @param fileName :file
    	 * @return 文件编码格式
    	 * @throws Exception
    	 */
    	public static String codeString(File fileName) throws Exception{
    		BufferedInputStream bin = new BufferedInputStream(
    		new FileInputStream(fileName));
    		int p = (bin.read() << 8) + bin.read();
    		String code = null;
    		
    		switch (p) {
    			case 0xefbb:
    				code = "UTF-8";
    				break;
    			case 0xfffe:
    				code = "Unicode";
    				break;
    			case 0xfeff:
    				code = "UTF-16BE";
    				break;
    			default:
    				code = "GBK";
    		}
    		IOUtils.closeQuietly(bin);
    		return code;
    	}
    

    上面这段代码只能判断带bom的文本,如果非bom文本,还有两种方式
    1、 轮询常用的编码,知道找到匹配的,如下面一段测试代码

      
    
    /*
     *  Copyright 2010 Georgios Migdos <cyberpython@gmail.com>.
     * 
     *  Licensed under the Apache License, Version 2.0 (the "License");
     *  you may not use this file except in compliance with the License.
     *  You may obtain a copy of the License at
     * 
     *       http://www.apache.org/licenses/LICENSE-2.0
     * 
     *  Unless required by applicable law or agreed to in writing, software
     *  distributed under the License is distributed on an "AS IS" BASIS,
     *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     *  See the License for the specific language governing permissions and
     *  limitations under the License.
     *  under the License.
     */
    
    import java.io.BufferedInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.nio.ByteBuffer;
    import java.nio.charset.CharacterCodingException;
    import java.nio.charset.Charset;
    import java.nio.charset.CharsetDecoder;
    
    /**
     *
     * @author Georgios Migdos <cyberpython@gmail.com>
     */
    public class CharsetDetector {
    
        public Charset detectCharset(File f, String[] charsets) {
    
            Charset charset = null;
    
            for (String charsetName : charsets) {
                charset = detectCharset(f, Charset.forName(charsetName));
                if (charset != null) {
                    break;
                }
            }
    
            return charset;
        }
    
        private Charset detectCharset(File f, Charset charset) {
            try {
                BufferedInputStream input = new BufferedInputStream(new FileInputStream(f));
    
                CharsetDecoder decoder = charset.newDecoder();
                decoder.reset();
    
                byte[] buffer = new byte[512];
                boolean identified = false;
                while ((input.read(buffer) != -1) && (!identified)) {
                    identified = identify(buffer, decoder);
                }
    
                input.close();
    
                if (identified) {
                    return charset;
                } else {
                    return null;
                }
    
            } catch (Exception e) {
                return null;
            }
        }
    
        private boolean identify(byte[] bytes, CharsetDecoder decoder) {
            try {
                decoder.decode(ByteBuffer.wrap(bytes));
            } catch (CharacterCodingException e) {
                return false;
            }
            return true;
        }
    
        public static void main(String[] args) {
            File f = new File("example.txt");
    
            String[] charsetsToBeTested = {"UTF-8", "windows-1253", "ISO-8859-7"};
    
            CharsetDetector cd = new CharsetDetector();
            Charset charset = cd.detectCharset(f, charsetsToBeTested);
    
            if (charset != null) {
                try {
                    InputStreamReader reader = new InputStreamReader(new FileInputStream(f), charset);
                    int c = 0;
                    while ((c = reader.read()) != -1) {
                        System.out.print((char)c);
                    }
                    reader.close();
                } catch (FileNotFoundException fnfe) {
                    fnfe.printStackTrace();
                }catch(IOException ioe){
                    ioe.printStackTrace();
                }
    
            }else{
                System.out.println("Unrecognized charset.");
            }
        }
    }
        
    

    2、 使用谷歌依赖库来进行判断
    https://code.google.com/archive/p/juniversalchardet/

    展开全文
  • java判断文本文件编码格式juniversalchardet使用 今天项目经理让写一个判断隔断文本文件格式的接口,废话不多说直接上代码。 juniversalchardet官网地址: http:code.google.com/p/juniversalchardet/ github地址 ...

    java判断文本文件编码格式juniversalchardet使用

    今天项目经理让写一个判断文本文件格式的接口,废话不多说直接上代码。

    juniversalchardet官网地址: http:code.google.com/p/juniversalchardet/

    github地址 https://github.com/thkoch2001/juniversalchardet
    支持的编码格式
    - Chinese

    • ISO-2022-CN

    • BIG-5

    • EUC-TW

    • GB18030

    • HZ-GB-2312

    • Cyrillic

      • ISO-8859-5
      • KOI8-R
      • WINDOWS-1251
      • MACCYRILLIC
      • IBM866
      • IBM855
    • Greek

      • ISO-8859-7
      • WINDOWS-1253
    • Hebrew

      • ISO-8859-8
      • WINDOWS-1255
    • Japanese

      • ISO-2022-JP
      • Shift_JIS
      • EUC-JP
    • Korean

      • ISO-2022-KR
      • EUC-KR
    • Unicode

      • UTF-8
      • UTF-16BE / UTF-16LE
      • UTF-32BE / UTF-32LE / X-ISO-10646-UCS-4-3412 / X-ISO-10646-UCS-4-2143
    • Others

      • WINDOWS-1252

    实践

    pom.xml文件

    	<dependency>
    		<groupId>com.googlecode.juniversalchardet</groupId>
    		<artifactId>juniversalchardet</artifactId>
    		<version>1.0.3</version>
    	</dependency>
    

    java代码

    @RequestMapping("/resultCode")
        public Map<String,String> resultCode(@RequestParam("file") MultipartFile file){
            Map<String,String> map = new HashMap<>();
            /**
    		*获取文件类型        
    		*/
            String fileType = file.getContentType();
                try {
                	/**
                	*判断文件类型
                	*如.text/.sql/.xls/.xlxs等;
                	*/
                    if(fileType.contains("text") || fileType.contains("sql")||fileType.contains("excel")||fileType.contains("openxmlformats-officedocument.spreadsheetml.sheet")){
                        byte[] buf = new byte[4096];
                        InputStream fis = file.getInputStream();
                        // (1)
                        UniversalDetector detector = new UniversalDetector(null);
    
                        // (2)
                        int nread;
                        while ((nread = fis.read(buf)) > 0 && !detector.isDone()) {
                            detector.handleData(buf, 0, nread);
                        }
                        // (3)
                        detector.dataEnd();
    
                        // (4)
                        String encoding = detector.getDetectedCharset();
                        if (encoding != null) {
                            map.put("encoding",encoding);
                        } else {
                            map.put("error","No encoding detected.");
                        }
    
                        // (5)
                        detector.reset();
    
                        map.put("code","0");
                        map.put("msg","成功!");
                    }else{
                        map.put("error","请上传SQL/TEXT/xls/xlsx格式文件!");
                    }
                }catch (Exception e){
                    map.put("code","-1");
                    map.put("msg","失败!");
                }
            return map;
        }
    

    然后就可以直接调用接口测试。

    展开全文
  • * 获取文件编码格式 * @param file * @return */ public String GetCharset(File file) { String charset = "GBK"; byte[] first3Bytes = new byte[3]; try { boolean checked = false; //BufferedInp.
    /**
         * 获取文件的编码格式
         * @param file
         * @return
         */
        public String GetCharset(File file) {
            String charset = "GBK";
            byte[] first3Bytes = new byte[3];
            try {
                boolean checked = false;
                //BufferedInputStream bis = new BufferedInputStream(
                //new FileInputStream(file));
                //bis.mark(0);
                //int read = bis.read(first3Bytes, 0, 3);
                InputStream is = new FileInputStream(file);
                int read = is.read(first3Bytes, 0, 3);
    
                if (read == -1)
                    return charset;
                //Log.i(TAG,"[GetCharset]first3Bytes[0]:"+first3Bytes[0]+", first3Bytes[1]:"+first3Bytes[1]+",first3Bytes[2]:"+first3Bytes[2]);
                if (first3Bytes[0] == (byte) 0xFF && first3Bytes[1] == (byte) 0xFE) {
                    charset = "UTF-16LE";
                    checked = true;
                } else if (first3Bytes[0] == (byte) 0xFE
                        && first3Bytes[1] == (byte) 0xFF) {
                    charset = "UTF-16BE";
                    checked = true;
                } else if (first3Bytes[0] == (byte) 0xEF
                        && first3Bytes[1] == (byte) 0xBB
                        && first3Bytes[2] == (byte) 0xBF) {
                    charset = "UTF-8";
                    checked = true;
                }else if (first3Bytes[0] == (byte) 0xA
                        && first3Bytes[1] == (byte) 0x5B
                        && first3Bytes[2] == (byte) 0x30) {
                    charset = "UTF-8";
                    checked = true;
                }else if (first3Bytes[0] == (byte) 0xD
                        && first3Bytes[1] == (byte) 0xA
                        && first3Bytes[2] == (byte) 0x5B) {
                    charset = "GBK";
                    checked = true;
                }else if (first3Bytes[0] == (byte) 0x5B
                        && first3Bytes[1] == (byte) 0x54
                        && first3Bytes[2] == (byte) 0x49) {
                    charset = "windows-1251";
                    checked = true;
                }
                //bis.reset();
                InputStream istmp = new FileInputStream(file);
                if (!checked) {
                    int loc = 0;
                    while ((read = istmp.read()) != -1) {
                        loc++;
                        if (read >= 0xF0)
                            break;
                        if (0x80 <= read && read <= 0xBF)
                            break;
                        if (0xC0 <= read && read <= 0xDF) {
                            read = istmp.read();
                            if (0x80 <= read && read <= 0xBF)
                                continue;
                            else
                                break;
                        } else if (0xE0 <= read && read <= 0xEF) {
                            read = istmp.read();
                            if (0x80 <= read && read <= 0xBF) {
                                read = istmp.read();
                                if (0x80 <= read && read <= 0xBF) {
                                    charset = "UTF-8";
                                    break;
                                } else
                                    break;
                            } else
                                break;
                        }
                    }
                }
                is.close();
                istmp.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return charset;
        }

    展开全文
  • 这个文档教你如何,判读不同的文件编码类型,gbk,utf-8等等
  • 2、Windows操作系统下,文本文件的默认编码为ANSI,对中文Windows来说即为GBK。例如我们使用记事本程序新建一个文本文档,其默认字符编码即为ANSI。 3、Text文本文档有四种编码选项:ANSI、Unicode(含UnicodeBi...

    一、认识字符编码:

    1、Java中String的默认编码为UTF-8,可以使用以下语句获取:Charset.defaultCharset();

    2、Windows操作系统下,文本文件的默认编码为ANSI,对中文Windows来说即为GBK。例如我们使用记事本程序新建一个文本文档,其默认字符编码即为ANSI。

    3、Text文本文档有四种编码选项:ANSI、Unicode(含Unicode Big Endian和Unicode Little Endian)、UTF-8、UTF-16

    4、因此我们读取txt文件可能有时候并不知道其编码格式,所以需要用程序动态判断获取txt文件编码。

    • ANSI     :无格式定义,对中文操作系统为GBK或GB2312
    • UTF-8   :前三个字节为:0xE59B9E(UTF-8)、0xEFBBBF(UTF-8含BOM)
    • UTF-16 :前两字节为:0xFEFF
    • Unicode:前两个字节为:0xFFFE

    例如,Unicode文档以0xFFFE开头,用程序取出前几个字节并进行判断即可。

    5、Java编码与Text文本编码对应关系:

    Java中的编码字符串Text编码 字节标志
    GBK

    ANSI

    无格式定义
    UTF-8

    UTF-8包含两种规格:

    UTF-8

    UTF-8-BOM

    需判断前三个字节:

    前三个字节为:0xE59B9E

    前三个字节为:0xEFBBBF

    UTF-16UTF-16前两个字节为:0xFEFF
    UNICODE

    Unicode包含两种规格:

    1、UCS2 Little Endian

    2、UCS2 Big Endian

    前两个字节为:0xFFFE

    Java读取Text文件,如果编码格式不匹配,就会出现乱码现象。所以读取文本文件的时候需要设置正确字符编码。Text文档编码格式都是写在文件头的,在程序中需要先解析文件的编码格式,获得编码格式后,再以此格式读取文件就不会产生乱码了。

    二、举个例子:

    有一个文本文件:test.txt

      

    测试代码: 

    /**
     * 文件名:CharsetCodeTest.java
     * 功能描述:文件字符编码测试
     */
    
    import java.io.*;
    
    public class CharsetCodeTest {
        public static void main(String[] args) throws Exception {
            String filePath = "test.txt";
            String content = readTxt(filePath);
            System.out.println(content);
        }
    
    
    public static String readTxt(String path) {
            StringBuilder content = new StringBuilder("");
            try {
                String fileCharsetName = getFileCharsetName(path);
                System.out.println("文件的编码格式为:"+fileCharsetName);
    
                InputStream is = new FileInputStream(path);
                InputStreamReader isr = new InputStreamReader(is, fileCharsetName);
                BufferedReader br = new BufferedReader(isr);
    
                String str = "";
                boolean isFirst = true;
                while (null != (str = br.readLine())) {
                    if (!isFirst)
                        content.append(System.lineSeparator());
                        //System.getProperty("line.separator");
                    else
                        isFirst = false;
                    content.append(str);
                }
                br.close();
            } catch (Exception e) {
                e.printStackTrace();
                System.err.println("读取文件:" + path + "失败!");
            }
            return content.toString();
        }
    
    
        public static String getFileCharsetName(String fileName) throws IOException {
            InputStream inputStream = new FileInputStream(fileName);
            byte[] head = new byte[3];
            inputStream.read(head);
    
            String charsetName = "GBK";//或GB2312,即ANSI
            if (head[0] == -1 && head[1] == -2 ) //0xFFFE
                charsetName = "UTF-16";
            else if (head[0] == -2 && head[1] == -1 ) //0xFEFF
                charsetName = "Unicode";//包含两种编码格式:UCS2-Big-Endian和UCS2-Little-Endian
            else if(head[0]==-27 && head[1]==-101 && head[2] ==-98)
                charsetName = "UTF-8"; //UTF-8(不含BOM)
            else if(head[0]==-17 && head[1]==-69 && head[2] ==-65)
                charsetName = "UTF-8"; //UTF-8-BOM
    
            inputStream.close();
    
            //System.out.println(code);
            return charsetName;
        }
    }

    运行结果:

     

     

    展开全文
  • NULL 博文链接:https://zhifeiji512.iteye.com/blog/1221068
  • java判断文本编码格式的方法

    千次阅读 2017-09-18 17:24:06
    欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: ...导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
  • Java自动识别文件字符编码工具类 参考博客 https://blog.csdn.net/superbeyone/article/details/103036914 使用方式: String encode = EncodingDetect.getFileEncode(geoJsonFile); log.info("系统检测到文件[ {}...
  • java识别文件编码格式

    2015-08-31 23:16:51
    java识别文件编码格式(无三方JAR包)
  • java判断txt文件编码格式

    千次阅读 2017-06-12 13:45:12
    if(file.isFile() && file.exists()){ //判断文件是否存在 String encoding=getFilecharset(new File(s)); InputStreamReader read = new InputStreamReader( new FileInputStream(file),encoding);//考虑到编码...
  • 主要介绍了java判断一个文件是否为二进制文件的方法,涉及java针对文件的读取及编码判断技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • java自动识别文本文件字符编码

    千次阅读 2018-04-19 11:46:03
    免不了要读取磁盘中的文本文件,目前文本文件最常用的是使用“utf-8”及“gbk”字符编码,如果使用了错误的字符编码格式,就会发生乱码的问题,因而在读取前,需要约定好要读取的文本文件内容与工程代码字符编码的...
  • 利用chardet,cpdetector包获取文件格式,并判断文件类型是否带BOM
  • Java代码中一个解析Txt文本编码的工具类,可以根据指定文件路径判断文本文件编码格式,相对于简单通过文本长度的判断而言多了更多的判断类型,能够比较准确的判断文本类型,导入即用,比较方便
  • java 判断文件编码格式(支持zip)

    万次阅读 2018-02-02 22:20:34
    java 判断文件编码格式(支持zip) 前言: 最近在工作过程中遇到了这样的问题: 通过文件上传,需要导入zip包中的文件信息。 由于使用的是apache的ant.jar中的ZipFile类、ZipEntry类。由于目前该工具类并不能判断...
  • java 怎么判断文本内容的编码格式

    千次阅读 2016-05-07 11:16:29
    java 怎么判断文本内容的编码格式
  • 摘要: Java判断文本文件字符编码的两种方法:1、通过文件流的前面部分字节判断;2、通过cpdetector库 提供的监听方法来判断。 Java判断文本文件字符编码的两种方法:1、通过文件流的前面部分字节判断;2、通过...
  • java判断文件编码格式

    千次阅读 2014-02-15 22:24:40
    1:简单判断是UTF-8或不是UTF-8,因为一般除了UTF-8之外就是GBK,所以就设置默认为GBK。...其实,如果项目运行的平台就是中文操作系统,如果这些文本文件在项目内产生,即开发人员可以控制文本的编码格式,只要判定两种
  • java验证文件真实格式和编码格式工具类,验证文件文件格式和文件编码格式给出正确的文件类型以及编码格式,从此解决文件解析乱码问题的烦恼
  • Java判断TXT文本格式

    2020-11-08 17:50:34
    最近一直在做仪器数据解析,遇到了不同编码格式的文本,奈何原本写这个程序的人乱搞,只有自己弄了。 这段代码适用于绝大多数情况,特殊情况的只有靠你们自己去查相关文档进行判断了 /** * 判断txt编码格式方法 * ...
  • 最近把播放器的固件升级了,结果歌词全部变成了乱码,中文出现乱码基本都是编码格式的问题。 一个一个的手动修改太麻烦了,就写了一个简单的java代码来实现批量转换一下。 主要完成的 import info.monitorenter....
  • Java判断一个文件是否是UTF-8编码

    千次阅读 2018-10-25 22:04:21
    由于代码不同人员写的编码不一样,导致出现各类问题,第一想到的办法就是用java写一个以某种编码读取文件,再以另一种编码文件达到统一,但是该以什么编码文件呢?不能都是以GBK或UTF-8去读,否则会出现乱码问题...
  • java 判断txt文件编码格式

    千次阅读 2016-05-05 10:29:32
    * 利用第三方开源包cpdetector获取文件编码格式. * @param filePath * @return */ public static String getFileEncode(File file) { /** *  * 1、cpDetector内置了一些常用的探测实现类,这些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,512
精华内容 27,404
关键字:

java判断文本文件编码

java 订阅