我的基础测试题，多多指导！

1. package com.itheima;
   
2. 
   
3. import java.io.*;
   
4. import java.net.*;
   
5. 
   
6. /**
   
7. * 第十题：使用TCP协议完成一个客户端一个服务器。
   
8. *                 客户端从键盘输入读取一个字符串，发送到服务器。
   
9. *                 服务器接收客户端发送的字符串，反转之后发回客户端。客户端接收并打印。
   
10. *
    
11. * @author JuJiaojie
    
12. *
    
13. */
    
14. 
    
15. /*
    
16. *思路：
    
17. *1.客户端：源-键盘录入     目的-网络输出流      操作字符串-选择字符流
    
18. *2.服务器端：源-输入流     目的-输出流
    
19. *3.为提高效率，加入缓冲
    
20. *
    
21. *客户端步骤：
    
22. *1.建立socket服务
    
23. *2.获取键盘录入
    
24. *3.将数据发送给服务器。
    
25. *4.获取服务端返回的数据，并打印
    
26. *5.关闭客户端资源
    
27. *
    
28. * 服务器端步骤：
    
29. *1.建立服务器socket服务
    
30. *2.获取客户端对象
    
31. *3.读取客户端发送过来的数据
    
32. *4.将读取到的字符串反转
    
33. *5.获取Socket流中的输出流，将反转后的字符串写到该输出流
    
34. *6.关闭客户端资源，关闭服务器端资源
    
35. *
    
36. */
    
37. 
    
38. //服务器端
    
39. class TcpServer
    
40. {
    
41.         public static void main(String[] args)throws Exception
    
42.         {               
    
43.                         //建立服务器端Socket服务，并监听一个端口
    
44.                         ServerSocket ss=new ServerSocket(8089);
    
45.                        
    
46.                         //通过accept方法获取连接过来的客户端对象
    
47.                         Socket s1=ss.accept();
    
48.                        
    
49.                         //获取IP,打印IP连接上的标志
    
50.                         String ip=s1.getInetAddress().getHostAddress();
    
51.                        
    
52.                         System.out.println(ip+"......connected");
    
53.                        
    
54.                         //读取socket读取流中的数据
    
55.                         BufferedReader server_bufIn=
    
56.                                         new BufferedReader(new InputStreamReader(s1.getInputStream()));
    
57.                                        
    
58.                         //将数据写入socket输出流，并发送给客户端
    
59.                         BufferedWriter server_bufOut=
    
60.                                         new BufferedWriter(new OutputStreamWriter(s1.getOutputStream()));
    
61.                        
    
62.                         //定义读取的一行数据
    
63.                         String str2=null;
    
64.                                
    
65.                         //当读取的数据不为空时
    
66.                         while((str2=server_bufIn.readLine())!=null)
    
67.                         {
    
68.                                
    
69.                                 //以字符串形式打印读取到的数据
    
70.                                 System.out.println("客户端："+str2);
    
71.                                
    
72.                                 //调用reverse，对字符串进行反转,打印
    
73.                                 System.out.println("反转后的："+reverse(str2));
    
74.                                
    
75.                                 //将反转后的字符串写到该输出流
    
76.                                 server_bufOut.write(reverse(str2));
    
77.                                
    
78.                                 //server_bufOut.write(str2.toUpperCase());
    
79.                                                
    
80.                                 //换行。因为字符存储在缓冲区，所以要刷新
    
81.                                 server_bufOut.newLine();
    
82.                                 server_bufOut.flush();       
    
83.                         }       
    
84.        
    
85.                                 s1.close();
    
86.                                 ss.close();
    
87.                        
    
88.                        
    
89.         }
    
90.        
    
91.         //字符串反转
    
92.         public static String reverse(String str)
    
93.         {
    
94.                 if(str !=null && str !="")
    
95.                 {
    
96.                         StringBuffer buf=new StringBuffer(str);
    
97.                         buf.reverse();
    
98.                         return buf.toString();
    
99.                 }
    
100.                 else
     
101.                 {
     
102.                         return "";
     
103.                 }
     
104.         }
     
105. }
     
106. 
     
107. //客户端
     
108. class TcpClient
     
109. {
     
110.         public static void main(String[] args)throws Exception
     
111.         {       
     
112.                         //建立客户端Socket服务
     
113.                         Socket s=new Socket("127.0.0.1",8089);
     
114.                        
     
115.                         //定义读取键盘数据的流对象
     
116.                         BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
     
117.                        
     
118.                         //定义目的：将数据写入到socket输出流，发给服务端
     
119.                         BufferedWriter client_bufOut=
     
120.                                         new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
     
121.                                        
     
122.                        
     
123.                         //定义一个socket读取流，读取服务端返回的反转字符串
     
124.                         BufferedReader client_bufIn=
     
125.                                         new BufferedReader(new InputStreamReader(s.getInputStream()));
     
126.        
     
127.                        
     
128.                         String strkey=null;
     
129.                        
     
130.                         //读取键盘录入数据
     
131.                         while((strkey=bufr.readLine())!=null)
     
132.                         {
     
133.                                 if("over".equals(strkey))
     
134.                                         break;
     
135.                                
     
136.                                 //将键盘录入数据写入输出流输出
     
137.                                 client_bufOut.write(strkey);
     
138.                                 client_bufOut.newLine();
     
139.                                 client_bufOut.flush();
     
140.                                
     
141.                                 //读取服务端返回的数据
     
142.                                 String str1=client_bufIn.readLine();
     
143.                        
     
144.                                 //打印读取到的服务器返回数据
     
145.                                 System.out.println("Server:"+str1);
     
146.                         }
     
147.                                                        
     
148.                                 //关闭键盘录入
     
149.                                 bufr.close();
     
150.                                
     
151.                                 //关闭客户端资源
     
152.                                 s.close();
     
153.                        
     
154.                
     
155.         }
     
156. 
     
157.        
     
158. }

复制代码

炫？还是让人检查？

新人贴，必须顶

可以的啊，这应该可以通过的

谢谢分享