1. 为什么使用PrintWriter，上传的文本文件中汉字乱码，图片失效。换成OutputStream就好了？？
   
2. 
   
3. import java.io.*;
   
4. import java.io.BufferedReader;
   
5. import java.io.FileInputStream;
   
6. import java.io.FileNotFoundException;
   
7. import java.io.FileOutputStream;
   
8. import java.io.IOException;
   
9. import java.io.InputStreamReader;
   
10. import java.io.PrintWriter;
    
11. import java.net.ServerSocket;
    
12. import java.net.Socket;
    
13. import java.net.UnknownHostException;
    
14. 
    
15. /**
    
16. * 第9题：使用TCP协议写一个可以上传文件的服务器和客户端。
    
17. * @author
    
18. *//*
    
19. 思路：
    
20.         1.写一个客户端，用于读取文件信息
    
21.         2.写一个服务器，用于接收上传的文件
    
22.         3.保证服务器和客户端相互通讯
    
23. 步骤：
    
24. 客户端：
    
25.         1.创建socket服务，并指定要连接的主机和端口
    
26.         2.客户端读取文件数据，并写到输出流
    
27.         3.关闭客户端输出流
    
28.         4.读取服务器返回信息
    
29. 服务器：
    
30.         1.创建ServerSocket服务，并设置指定端口
    
31.         2.读取输入流，存储上传的文件数据
    
32.         3.给客户端反馈信息
    
33.         *
    
34.         */
    
35. //客户端
    
36. class Client{
    
37.         public static void main(String[] args){
    
38.                 //创建服务
    
39.                 Socket s=null;
    
40.                 BufferedInputStream bufis = null;
    
41.                 BufferedOutputStream out = null;
    
42.                 //通过主函数传递上载文件的路径
    
43.                 String srcPath=args[0];
    
44.                 try {
    
45.                         s = new Socket("192.168.1.102",9090);                                                
    
46.                         //因为要上传的文件类型不确定，所以使用字节流
    
47.                         bufis = new BufferedInputStream(new FileInputStream(srcPath));
    
48.                         out = new BufferedOutputStream(s.getOutputStream());//为什么使用PrintWriter，上传的文本文件中汉字乱码，图片失效。换成OutputStream就好了？？
    
49.           int by =0;
    
50.                         while((by=bufis.read())!=-1){
    
51.                                 out.write(by);
    
52.                         }
    
53.                         out.flush();
    
54.                 } catch (UnknownHostException e) {
    
55.                         e.printStackTrace();
    
56.                 } catch (FileNotFoundException e) {
    
57.                         e.printStackTrace();
    
58.                 } catch (IOException e) {
    
59.                         e.printStackTrace();
    
60.                 }
    
61.                 finally
    
62.                 {
    
63.                         try {
    
64.                                 if(s!=null)
    
65.                                         s.shutdownOutput();//关闭客户端的输出流。相当于给流中加一个结束标记-1                                
    
66.                         } catch (IOException e) {
    
67.                                 e.printStackTrace();
    
68.                         }
    
69.                 }        
    
70.                 //读取服务器返回的数据信息
    
71.                 BufferedReader bufIn=null;
    
72.                 try {
    
73.                         bufIn = null;
    
74.                         bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
    
75.                         String str = bufIn.readLine();
    
76.                         System.out.println(str);
    
77.                 } catch (IOException e) {
    
78.                         e.printStackTrace();
    
79.                 }
    
80.                 finally{
    
81.                         try {
    
82.                                 if(bufis!= null)
    
83.                                         bufis.close();                                
    
84.                         } catch (IOException e) {
    
85.                                 e.printStackTrace();
    
86.                         }
    
87.                         try {
    
88.                                 if(s!=null)
    
89.                                         s.close();                                
    
90.                         } catch (IOException e) {
    
91.                                 e.printStackTrace();
    
92.                         }
    
93.                 }                                
    
94.         }
    
95. }
    
96. //服务端
    
97. class Server{
    
98.         public static void main(String[] args) throws Exception{
    
99.                 String destPath=args[0];               
    
100.                 ServerSocket ss = new ServerSocket(9090);
     
101.                 Socket s = ss.accept();
     
102.                 //获取客户端的主机地址
     
103.                 String ip = s.getInetAddress().getHostAddress();
     
104.                 System.out.println(ip+"...connected");
     
105.                
     
106.                 //创建读取流，用于读取上载的文件信息
     
107.                 BufferedInputStream bufIn = null;
     
108.                 BufferedOutputStream out = null;
     
109.                 //字节输入流
     
110.                 bufIn = new BufferedInputStream(s.getInputStream());
     
111.                 //指定上载文件的存放路径
     
112.                 out= new BufferedOutputStream(new FileOutputStream(destPath));//为什么使用PrintWriter，上传的文本文件中汉字乱码，图片失效。换成OutputStream就好了？？
     
113.   
     
114.          int by = 0;
     
115.                 while((by=bufIn.read())!=-1){
     
116.                         out.write(by);                        
     
117.                 }
     
118.                 //out.flush();
     
119.                
     
120.                 //给客户端返回信息
     
121.                 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
     
122.                 pw.println("上传成功");
     
123.                 out.close();
     
124.                 s.close();
     
125.                 ss.close();               
     
126.         }
     
127. }

复制代码

大概看了下源码。我的理解是这样的，
PrintWriter是writer结尾的字符流，一般用于处理文本类文件的复制。如果用来复制媒体文件，可以复制成功，但是因为编码问题，不一定可以看或者听，比如图片或者mp3.
而outputStream是字节流类，专门用于处理媒体文件。

希望可以帮助到你。

PrintWriter 是Writer的子类，属于字符流。此类只处理纯文本文件，字节码文件是处理不了的。
OutputStream是Stream的子类，属于字节流，一般处理字节码(二进制)文件。
图片肯定不是文本文件吧，它是字节码文件，你用字符流，它处理出来的数据通过编码表翻译过来肯定是乱码咯

xuluheng718 发表于 2013-5-5 12:26
PrintWriter 是Writer的子类，属于字符流。此类只处理纯文本文件，字节码文件是处理不了的。
OutputStream ...

PrintWriter是可以接受字节流的，另外，按照你说的，使用PrintWriter处理字符应该没问题吧？那为什么我处理文本也乱码呢？

我自己的理解，不是因为PrintWriter只能处理字符流的原因，应该是需要配套使用，我读用的是Inputstream，属于字节流，而写用了PrintWriter，应该不配套，
我试验了一下，当我读用FileReader的时候，写用printWriter没问题，不知道对与不对

gerenvip 发表于 2013-5-5 15:04
我自己的理解，不是因为PrintWriter只能处理字符流的原因，应该是需要配套使用，我读用的是Inputstream，属 ...

字符流是处理文本文件的，用字节流处理文本文件一样可以，但是字符流为什么能处理字符是因为它根据了编码表把你要处理的字符经过编码存入文件中，而字节流它里面只写入或读取文件里面的原始字节，它并没有使用编码处理，所以假如你处理文本文件时候用字符流，他是可以在编码表里面找到相对应的编码进行写入和读取的，
，而字节码文件本身里面的数据没有经过编码表处理过的数据，你用字符流进行处理，它根据读取的数据在编码表里面找相对应字符，结果肯定就是乱码或者其它不符合你文件的数据咯

gerenvip 发表于 2013-5-5 15:04
我自己的理解，不是因为PrintWriter只能处理字符流的原因，应该是需要配套使用，我读用的是Inputstream，属 ...

这是没错的，PrintWriter本身就是字符流，他是处理经过编码后的文件，而字节流只处理原始文件，一个是处理原始文件，一个是处理编码后的文件，结果肯定会出问题
要么两个都用字节流或字符流，要么经过转换流进行处理