1. import java.net.*;
   
2. import java.io.*;
   
3. class UpperCaseClient
   
4. {
   
5.         public static void main(String[] args) throws Exception
   
6.         {
   
7.                 Socket s = new Socket(InetAddress.getLocalHost(), 10000);
   
8.                 //定义源，读取键盘数据的流对象
   
9.                 BufferedReader bufR =
   
10.                                 new BufferedReader(new InputStreamReader(System.in));
    
11.                
    
12.                 //定义目的，将数据写入到socket输出流，发给服务端。
    
13.                 //BufferedWriter bufOut =
    
14.                 //                new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
    
15.                 PrintStream out = new PrintStream(s.getOutputStream());
    
16.                
    
17.                 //定义一个socket读取流，读取服务端返回的大写信息
    
18.                 BufferedReader bufIn =
    
19.                                 new BufferedReader(new InputStreamReader(s.getInputStream()));
    
20.                 String line = null;
    
21.                 String str = null;
    
22.                 while((line = bufR.readLine()) != null)
    
23.                 {
    
24.                         //当客户端输入over时，循环结束，就会调用s.close()关闭客户端socket，这时服务端也会关闭，因为当关闭客户
    
25.                         //端的socket时，会发送一个-1过去给服务端，服务端读到-1时循环也结束了，所以会执行s.close()和ss.close()
    
26.                         if("over".equals(line))
    
27.                                 break;
    
28.                        
    
29.                         //用到了缓冲流,write后数据是写到缓冲中，应该把数据flush出去
    
30.                         //.bufOut.write(line);
    
31.                         //bufOut.newLine();//要加一个换行，不然服务端用readLine方法会一直等待结束标记
    
32.                         //bufOut.flush();//要把数据刷出去，不然服务端读不到数据
    
33.                         out.println(line);
    
34.                        
    
35.                         //读服务端的返回大写信息
    
36.                         //readLine()是阻塞方法，它要等到一个回车标记才会结束。
    
37.                         //用缓冲流写过来的时候，要加一个换行。newLine();而且要flush缓冲区，不然接收不到数据
    
38.                         str = bufIn.readLine();
    
39.                         System.out.println(str);
    
40.                 }
    
41.                 bufR.close();
    
42.                 s.close();
    
43.                
    
44.                
    
45.         }
    
46. }
    
47. 
    
48. /*
    
49. * 服务端
    
50. * 源:socket读取流
    
51. * 目的：socekt输出流
    
52. * 都是文本，装饰
    
53. */
    
54. class UpperCaseServer
    
55. {
    
56.         public static void main(String[] args) throws Exception
    
57.         {
    
58.                 ServerSocket ss = new ServerSocket(10000);
    
59.                
    
60.                 Socket s = ss.accept();
    
61.                 String ip = s.getInetAddress().getHostAddress();
    
62.                 System.out.println(ip + "....connect");
    
63.                 //源，读取socket读取流中的数据
    
64.                 BufferedReader bufIn =
    
65.                                 new BufferedReader(new InputStreamReader(s.getInputStream()));
    
66.                
    
67.                 //目的，socket输出流，将大写数据写入到socket输出流，并发送给客户端
    
68.                 //BufferedWriter bufOut =
    
69.                 //                new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
    
70.                 PrintStream out = new PrintStream(s.getOutputStream());
    
71.                
    
72.                 String line = null;
    
73.                 //readLine()是阻塞方法，它要等到一个回车标记才会结束。
    
74.                 //用缓冲流写过来的时候，要加一个换行。newLine();而且要flush缓冲区，不然接收不到数据
    
75.                 while((line = bufIn.readLine()) != null)
    
76.                 {
    
77.                         //bufOut.write(line.toUpperCase());
    
78.                         //bufOut.newLine();//要加一个换行，不然客户端用readLine方法会一直等待结束标记
    
79.                         //bufOut.flush();//要把数据刷出去，不然客户端读不到数据
    
80.                         out.println(line.toUpperCase());
    
81.                 }
    
82.                 s.close();
    
83.                 ss.close();
    
84.         }
    
85. }

复制代码

问题，不是说PrintStream要设置成自动刷新，也就是new PrintStream(***, true)这种形式才会自动刷新吗，为什么没有设置还是能自动刷呢

值得学习ing!