Java读取、写入文件如何解决乱码问题

来源：互联网发布：war3 mac 版本转换器编辑：程序博客网时间：2024/05/20 09:45

读取文件流时，经常会遇到乱码的现象，造成乱码的原因当然不可能是一个，这里主要介绍因为文件编码格式而导致的乱码的问题。首先，明确一点，文本文件与二进制文件的概念与差异。

文本文件是基于字符编码的文件，常见的编码有ASCII编码，UNICODE编码、ANSI编码等等。二进制文件是基于值编码的文件，你可以根据具体应用，指定某个值是什么意思（这样一个过程，可以看作是自定义编码。）

因此可以看出文本文件基本上是定长编码的(也有非定长的编码如UTF-8)。而二进制文件可看成是变长编码的，因为是值编码嘛，多少个比特代表一个值，完全由你决定。

对于二进制文件，是千万不能使用字符串的，因为字符串默认初始化时会使用系统默认编码，然而，二进制文件因为自定义编码自然与固定格式的编码会有所冲突，所以对于二进制的文件只能采用字节流读取、操作、写入。

对于文本文件，因为编码固定，所以只要在读取文件之前，采用文件自身的编码格式解析文件，然后获取字节，再然后，通过指定格式初始化字符串，那么得到的文本是不会乱码的。虽然，二进制文件也可以获取到它的文本编码格式，但是那是不准确的，所以不能同日而语。

具体操作如下：

1）获取文本文件的格式

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
public static String getFileEncode(String path) {
    String charset ="asci";
    byte[] first3Bytes =new byte[3];
    BufferedInputStream bis =null;
    try{
      booleanchecked = false;
      bis =new BufferedInputStream(newFileInputStream(path));
      bis.mark(0);
      intread = bis.read(first3Bytes, 0,3);
      if(read == -1)
        returncharset;
      if(first3Bytes[0] == (byte)0xFF && first3Bytes[1] == (byte)0xFE) {
        charset ="Unicode";//UTF-16LE
        checked =true;
      }else if(first3Bytes[0] == (byte)0xFE && first3Bytes[1] == (byte)0xFF) {
        charset ="Unicode";//UTF-16BE
        checked =true;
      }else if(first3Bytes[0] == (byte)0xEF && first3Bytes[1] == (byte)0xBB && first3Bytes[2] == (byte)0xBF) {
        charset ="UTF8";
        checked =true;
      }
      bis.reset();
      if(!checked) {
        intlen = 0;
        intloc = 0;
        while((read = bis.read()) != -1) {
          loc++;
          if(read >= 0xF0)
            break;
          if(0x80 <= read && read <= 0xBF)//单独出现BF以下的，也算是GBK
            break;
          if(0xC0 <= read && read <= 0xDF) {
            read = bis.read();
            if(0x80 <= read && read <= 0xBF)
            //双字节 (0xC0 - 0xDF) (0x80 - 0xBF),也可能在GB编码内
              continue;
            else
              break;
          }else if(0xE0 <= read && read <= 0xEF) {//也有可能出错，但是几率较小
            read = bis.read();
            if(0x80 <= read && read <= 0xBF) {
              read = bis.read();
              if(0x80 <= read && read <= 0xBF) {
                charset ="UTF-8";
                break;
              }else
                break;
            }else
              break;
          }
        }
        //TextLogger.getLogger().info(loc + " " + Integer.toHexString(read));
      }
    }catch (Exception e) {
      e.printStackTrace();
    }finally {
      if(bis != null) {
        try{
          bis.close();
        }catch (IOException ex) {
        }
      }
    }
    returncharset;
  }
  
  privatestatic String getEncode(intflag1, int flag2, int flag3) {
    String encode="";
    // txt文件的开头会多出几个字节，分别是FF、FE（Unicode）,
    // FE、FF（Unicode big endian）,EF、BB、BF（UTF-8）
    if(flag1 == 255 && flag2 == 254) {
      encode="Unicode";
    }
    elseif (flag1 == 254&& flag2 == 255) {
      encode="UTF-16";
    }
    elseif (flag1 == 239&& flag2 == 187 && flag3 == 191) {
      encode="UTF8";
    }
    else{
      encode="asci";// ASCII码
    }
    returnencode;
  }

2）通过文件的编码格式读取文件流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
   * 通过路径获取文件的内容，这个方法因为用到了字符串作为载体，为了正确读取文件（不乱码），只能读取文本文件，安全方法！
   */
  publicstatic String readFile(String path){
    String data =null;
    // 判断文件是否存在
    File file =new File(path);
    if(!file.exists()){
      returndata;
    }
    // 获取文件编码格式
    String code = FileEncode.getFileEncode(path);
    InputStreamReader isr =null;
    try{
      // 根据编码格式解析文件
      if("asci".equals(code)){
        // 这里采用GBK编码，而不用环境编码格式，因为环境默认编码不等于操作系统编码
        // code = System.getProperty("file.encoding");
        code ="GBK";
      }
      isr =new InputStreamReader(newFileInputStream(file),code);
      // 读取文件内容
      intlength = -1 ;
      char[] buffer =new char[1024];
      StringBuffer sb =new StringBuffer();
      while((length = isr.read(buffer,0, 1024) ) != -1){
        sb.append(buffer,0,length);
      }
      data =new String(sb);
    }catch(Exception e){
      e.printStackTrace();
      log.info("getFile IO Exception:"+e.getMessage());
    }finally{
      try{
        if(isr !=null){
          isr.close();
        }
      }catch (IOException e) {
        e.printStackTrace();
        log.info("getFile IO Exception:"+e.getMessage());
      }
    }
    returndata;
  }

3）通过文件指定的格式写入文件

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
   * 按照指定的路径和编码格式保存文件内容，这个方法因为用到了字符串作为载体，为了正确写入文件（不乱码），只能写入文本内容，安全方法
   *
   * @param data
   *     将要写入到文件中的字节数据
   * @param path
   *     文件路径,包含文件名
   * @return boolean
   *      当写入完毕时返回true;
   */
  publicstatic booleanwriteFile(byte data[], String path , String code){
    booleanflag = true;
    OutputStreamWriter osw =null;
    try{
      File file =new File(path);
      if(!file.exists()){
        file =new File(file.getParent());
        if(!file.exists()){
          file.mkdirs();
        }
      }
      if("asci".equals(code)){
        code ="GBK";
      }
      osw =new OutputStreamWriter(newFileOutputStream(path),code);
      osw.write(newString(data,code));
      osw.flush();
    }catch(Exception e){
      e.printStackTrace();
      log.info("toFile IO Exception:"+e.getMessage());
      flag =false;
    }finally{
      try{
        if(osw !=null){
          osw.close();
        }
      }catch(IOException e){
        e.printStackTrace();
        log.info("toFile IO Exception:"+e.getMessage());
        flag =false;
      }
    }
    returnflag;
  }

4）对于二进制文件而且内容很少的，例如Word文档等，可以使用如下方式读取、写入文件

/**
   * 从指定路径读取文件到字节数组中,对于一些非文本格式的内容可以选用这个方法
   *      457364578634785634534
   * @param path
   *     文件路径,包含文件名
   * @return byte[]
   *       文件字节数组
   *     
   */
  publicstatic byte[] getFile(String path)throws IOException {
    FileInputStream stream=newFileInputStream(path);
    intsize=stream.available();
    bytedata[]=new byte[size];
    stream.read(data);
    stream.close();
    stream=null;
    returndata;
  }
  
  
  
  /**
   * 把字节内容写入到对应的文件，对于一些非文本的文件可以采用这个方法。
   * @param data
   *      将要写入到文件中的字节数据
   * @param path
   *      文件路径,包含文件名
   * @return boolean isOK 当写入完毕时返回true;
   * @throws Exception
   */
  publicstatic booleantoFile(byte data[], String path) throws Exception {
    FileOutputStream out=newFileOutputStream(path);
    out.write(data);
    out.flush();
    out.close();
    out=null;
    returntrue;
  }

阅读全文

0 0