我有这样两个代码，FileOutputStreamTest类是读取指定文件的数据，FileOutputStream类往指定文件中写入数据，当执行的时候，FileOutputStreamTest类得到结果如图所示，而打开执行FileOutputStream类所得到的文件如图所示，问题是，为什么读取数据中文字符会出现乱码，而写入数据却不会呢？哪位高手帮帮忙！
其中FileInputStreamTest.java代码如下：

1. package com.test;
   
2. import java.io.FileInputStream;
   
3. import java.io.FileNotFoundException;
   
4. import java.io.IOException;
   
5. 
   
6. public class FileInputStreamTest {
   
7. 
   
8.         /**
   
9.          * @param args
   
10.          */
    
11.         public static void main(String[] args) {
    
12.                 // TODO Auto-generated method stub
    
13.                 FileInputStream fin=null;
    
14.                 try {
    
15.                         fin=new FileInputStream("D:\\java\\123.txt");
    
16.                         System.out.println("可读取的字节数："+fin.available());
    
17.                         int i=fin.read();
    
18.                         while(i!=-1)
    
19.                         {
    
20.                                 System.out.print((char)i);
    
21.                                 i=fin.read();
    
22.                         }               
    
23.                 } catch (FileNotFoundException e) {
    
24.                         // TODO: handle exception
    
25.                         e.printStackTrace();
    
26.                 }
    
27.                 catch (IOException e) {
    
28.                         // TODO: handle exception
    
29.                 e.printStackTrace();
    
30.                 }
    
31.                 finally
    
32.                 {
    
33.                         try {
    
34.                                 if (null!=fin) {
    
35.                                         fin.close();
    
36.                                 }
    
37.                         } catch (IOException e) {
    
38.                                 // TODO: handle exception
    
39.                                 e.printStackTrace();
    
40.                         }
    
41.                 }
    
42.         }
    
43. }

复制代码

123.txt文件内容如图:

执行代码结果:



FileOutputStreamTest.java代码如下：

1. package com.test;
   
2. import java.io.*;
   
3. 
   
4. public class FileOutputStreamTest {
   
5. 
   
6.         /**
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 // TODO Auto-generated method stub
    
11.                 FileOutputStream out=null;
    
12.                 try {
    
13.                         out=new FileOutputStream("D:\\java\\456.txt",true);
    
14.                         out.write('#');
    
15.                         out.write("hello,java".getBytes());
    
16.                         out.write("1345".getBytes());
    
17.                         out.write("我是一名Java程序员".getBytes());
    
18.                     out.flush();
    
19.                 } catch (FileNotFoundException e) {
    
20.                         // TODO: handle exception
    
21.                         e.printStackTrace();
    
22.                 }
    
23.                 catch (IOException e) {
    
24.                         // TODO: handle exception
    
25.                         e.printStackTrace();
    
26.                 }
    
27.                 finally
    
28.                 {
    
29.                         if (out!=null) {
    
30.                                 try {
    
31.                                         out.close();
    
32.                                 } catch (IOException e) {
    
33.                                         // TODO: handle exception
    
34.                                         e.printStackTrace();
    
35.                                 }
    
36.                         }
    
37.                 }
    
38.         }
    
39. }

复制代码

执行代码后打开456.txt文件，结果如图：

问题：为什么读取数据中文字符会出现乱码，而写入数据却不会呢？哪位高手帮帮忙！

出现乱码的原因是::你记事本的编码格式和你IO流读取的编码格式不一样 ,导致你读取的时候出现乱码,
你可以这样解决::在你的读取流当中指定编码格式::  fin=new FileInputStream("D:\\java\\123.txt","UTF-8");
避免乱码的情况发生 应该把::
1.源字符串编码
2.传输过程中的编码
3.结果字符串编码
只要这三种做到一致，一般就不会有问题了。
在从流中读数据时，最好使用byte数组，这样的好处是可以支持任何编码格式。

出现乱码的原因是这样的：
FileOutputStream  中的 read 方法 读取数据是一个字节一个字节读取的
当你读取中文的时候 因为中文是两个字节 所以会出现乱码
读取文件数据 你可以选择其他的方式 比如：InputStreamReader等等

import java.io.*;

class FileInputStreamTest {

        
        public static void main(String[] args) {
               
                FileInputStream fin=null;
                try {
                        fin=new FileInputStream("x.txt");
                        System.out.println("可读取的字节数："+fin.available());

                                byte[] buf=new byte[1024];                                    int i=0;
                        while((i=fin.read(buf))!=-1)
                        {       
                                System.out.print(new String(buf,0,i));
                               i=fin.read();
                        }               
                } catch (FileNotFoundException e) {
                        
                        e.printStackTrace();
                }
                catch (IOException e) {
                        
                e.printStackTrace();
                }
                finally
                {
                        try {
                                if (null!=fin) {
                                        fin.close();
                                }


程序已经改好，运行良好 改动位置在红色部分
                        } catch (IOException e) {
                                
                                e.printStackTrace();
                        }
                }
        }
}