使用TCP协议完成一个客户端一个服务器。客户端从键盘输入读取一个字符串，发送到服务器。
服务器接收客户端发送的字符串，反转之后发回客户端。客户端接收并打印。

谢谢米娜

服务端
class  TransServer{
        public static void main(String[] args) throws Exception{
                ServerSocket ss = new ServerSocket(10005);
                Socket s = ss.accept();
                String ip = s.getInetAddress().getHostAddress();
                System.out.println(ip+".....connected");

                //读取socket读取流中的数据
                BufferedReader bufIn =
                        new BufferedReader(new InputStreamReader(s.getInputStream()));
               
                //目的，socket输出流，将大写数据写入到socket输出流，并发送给客户端
                BufferedWriter bufOut =
                        new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
               
                String line = null;
                while((line=bufIn.readLine())!=null){
                        System.out.println(line);
                        bufOut.write(line.toUpperCase());
                        bufOut.newLine();
                        bufOut.flush();
                }
                s.close();
                ss.close();
        }
}

客户端
import java.io.*;
import java.net.*;
class  TransClient{
        public static void main(String[] args) throws Exception{
                Socket s = new Socket("192.168.1.100",10005);
               
                //定义读取键盘数据的流对象
                BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
               
                //定义目的，将数据写入到socket输出流，发给服务端
        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

                //定义一个socket读取流，读取服务端返回的大写信息
                BufferedReader bufIn =
                        new BufferedReader(new InputStreamReader(s.getInputStream()));

                String line = null;
                while((line=bufr.readLine())!=null){
                        if("over".equals(line))
                                break;
                        bufOut.write(line);
                        bufOut.newLine();
                        bufOut.flush();

                        String str = bufIn.readLine();
                        System.out.println("Server:"+str);
                }
                bufr.close();
                s.close();
        }       
}

这应该是黑马基础测试题里面的吧?我记得之前做过~客户端：

1. import java.io.DataInputStream;
   
2. import java.io.DataOutputStream;
   
3. import java.io.IOException;
   
4. import java.net.Socket;
   
5. import java.util.Scanner;
   
6. 
   
7. public class Client {
   
8.        public static void main(String[] args) {
   
9.               launchClient();
   
10.        }
    
11. 
    
12.        private static void launchClient() {
    
13.              Socket s = null;
    
14.              DataOutputStream dos = null;
    
15.              DataInputStream dis = null;
    
16.              Scanner sc = null;
    
17.                
    
18.       try {
    
19.            while(true) {
    
20.                      s = new Socket("127.0.0.1", 9999); //创建请求指定服务器的Socket对象
    
21.                      dos = new DataOutputStream(s.getOutputStream()); //创建数据输出流
    
22.                                 
    
23.                      System.out.println("请输入:");
    
24.                      sc = new Scanner(System.in);
    
25.                      String str = sc.next();   //得到键盘输入的数据
    
26.                     dos.writeUTF(str);    //将数据写入
    
27.                                 
    
28.                    dis = new DataInputStream(s.getInputStream());//创建输入流
    
29.                    System.out.println("反转之后：" + dis.readUTF()); //接受并打印经服务器反转之后的字符串
    
30.              }
    
31.        } catch (IOException e) {
    
32.                   e.printStackTrace();
    
33.        } finally {
    
34.                   try {
    
35.                         dos.close();
    
36.                   } catch (IOException e) {
    
37.                         e.printStackTrace();
    
38.                   }
    
39.                         
    
40.                  sc.close();
    
41.                         
    
42.                 try {
    
43.                         s.close();
    
44.                 } catch (IOException e) {
    
45.                         e.printStackTrace();
    
46.                       }
    
47.                }
    
48.          }
    
49. }
    

复制代码

服务器端：

1. import java.io.DataInputStream;
   
2. import java.io.DataOutputStream;
   
3. import java.io.IOException;
   
4. import java.net.ServerSocket;
   
5. import java.net.Socket;
   
6. 
   
7. public class Server {
   
8.         public static void main(String[] args) {
   
9.                 launchServer();
   
10.         }
    
11. 
    
12.         private static void launchServer() {
    
13.                 ServerSocket server = null;
    
14.                 Socket s = null;
    
15.                 DataInputStream dis = null;
    
16.                 DataOutputStream dos = null;
    
17.                 while(true) {
    
18.                         try {
    
19.                                 server = new ServerSocket(9999);     //创建绑定端口9999的ServerSocket对象
    
20.                                 
    
21.                                 System.out.println("服务器已启动！");
    
22.                                 
    
23.                                 s = server.accept();              //接收客户端请求，得到Socket
    
24.                                 dis = new DataInputStream(s.getInputStream()); //创建数据输入流
    
25.                                 String m = dis.readUTF();         //读取客户端发送的数据并返回一个String类型的对象
    
26.                                 
    
27.                                 StringBuffer sb = new StringBuffer(m);   //将String类型转换成StringBuffer类型便已反转
    
28.                                 m = sb.reverse().toString();                        //将从客服端接受的字符串反转
    
29.                                 
    
30.                                 dos = new DataOutputStream(s.getOutputStream()); //穿件数据输出流
    
31.                                 dos.writeUTF(m);       //将反转之后的字符串写入内存让客户端读取
    
32.                                 
    
33.                         } catch (IOException e) {
    
34.                                 e.printStackTrace();
    
35.                         } finally {
    
36.                                 try {
    
37.                                         dis.close();
    
38.                                         s.close();
    
39.                                         server.close();
    
40.                                 } catch (IOException e) {
    
41.                                         e.printStackTrace();
    
42.                                 }
    
43.                         }
    
44.                         
    
45.                 }
    
46.         }
    
47. }
    

复制代码