Java---两台电脑互相通信

以下是Java读取文本文件内容的代码示例：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadFileExample {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("filename.txt"));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) br.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

以上代码首先创建一个BufferedReader对象，并指定要读取的文件路径。然后使用readLine()方法逐行读取文件，并将每行内容输出到控制台。最后要记得在程序结束时关闭BufferedReader对象。

以下是Java使用Socket发送数据的代码示例：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class Client {
    public static void main(String[] args) {
        try (
            Socket socket = new Socket("localhost", 8080);
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))
        ) {
            String userInput;
            while ((userInput = stdIn.readLine()) != null) {
                out.println(userInput);
                System.out.println("Server response: " + in.readLine());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码创建一个Socket对象，并将其连接到指定的主机和端口。然后使用BufferedReader和PrintWriter对象分别从Socket的输入流和输出流中读写数据。程序使用循环结构读取用户输入，并将其发送到服务器端。在接收到服务器端的响应后，程序将该响应输出到控制台。最后需要注意的是，程序必须在用完Socket对象后关闭该对象。

文字通信：

这是服务器端：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketService {
    //搭建服务器端
    public static void main(String[] args) throws IOException{
        SocketService socketService = new SocketService();
        //1、a)创建一个服务器端Socket，即SocketService 
        socketService.oneServer();
    }
    public  void oneServer(){
        try{
            ServerSocket server=null;
            try{
            //下面是端口，端口可以和客户端代码里面的端口一样
                server=new ServerSocket(5209);
                //b)指定绑定的端口，并监听此端口。
                System.out.println("服务器启动成功");
                //创建一个ServerSocket在端口5209监听客户请求
            }catch(Exception e) {
                    System.out.println("没有启动监听："+e);
                    //出错，打印出错信息
            }
            Socket socket=null;
            try{
                socket=server.accept();
                //2、调用accept()方法开始监听，等待客户端的连接 
                //使用accept()阻塞等待客户请求，有客户
                //请求到来则产生一个Socket对象，并继续执行
            }catch(Exception e) {
                System.out.println("Error."+e);
                //出错，打印出错信息
            }
            //3、获取输入流，并读取客户端信息 
            String line;
            BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //由Socket对象得到输入流，并构造相应的BufferedReader对象
            PrintWriter writer=new PrintWriter(socket.getOutputStream());
            //由Socket对象得到输出流，并构造PrintWriter对象
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            //由系统标准输入设备构造BufferedReader对象
            System.out.println("Client:"+in.readLine());
            //在标准输出上打印从客户端读入的字符串
            line=br.readLine();
            //从标准输入读入一字符串
            //4、获取输出流，响应客户端的请求 
            while(!line.equals("end")){
            //如果该字符串为 "bye"，则停止循环
                writer.println(line);
                //向客户端输出该字符串
                writer.flush();
                //刷新输出流，使Client马上收到该字符串
                System.out.println("服务:"+line);
                //在系统标准输出上打印读入的字符串
                System.out.println("客户:"+in.readLine());
                //从Client读入一字符串，并打印到标准输出上
                line=br.readLine();
                //从系统标准输入读入一字符串
            } //继续循环

​        //5、关闭资源 
​        writer.close(); //关闭Socket输出流
​        in.close(); //关闭Socket输入流
​        socket.close(); //关闭Socket
​        server.close(); //关闭ServerSocket
​    }catch(Exception e) {//出错，打印出错信息
​        System.out.println("Error."+e);
​    }
}

}

下面是客户端：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.URL;

public class SocketClient {
    // 搭建客户端
    public static void main(String[] args) throws IOException {
        try {
            // 1、创建客户端Socket，指定服务器地址和端口

​        //下面是你要传输到另一台电脑的IP地址和端口
​        Socket socket = new Socket("192.168.168.143", 5209);
​        System.out.println("客户端启动成功");
​        // 2、获取输出流，向服务器端发送信息
​        // 向本机的52000端口发出客户请求
​        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
​        // 由系统标准输入设备构造BufferedReader对象
​        PrintWriter write = new PrintWriter(socket.getOutputStream());
​        // 由Socket对象得到输出流，并构造PrintWriter对象
​        //3、获取输入流，并读取服务器端的响应信息 
​        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
​        // 由Socket对象得到输入流，并构造相应的BufferedReader对象
​        String readline;
​        readline = br.readLine(); // 从系统标准输入读入一字符串
​        while (!readline.equals("end")) {
​            // 若从标准输入读入的字符串为 "end"则停止循环
​            write.println(readline);
​            // 将从系统标准输入读入的字符串输出到Server
​            write.flush();
​            // 刷新输出流，使Server马上收到该字符串
​            System.out.println("客户:" + readline);
​            // 在系统标准输出上打印读入的字符串
​            System.out.println("服务:" + in.readLine());
​            // 从Server读入一字符串，并打印到标准输出上
​            readline = br.readLine(); // 从系统标准输入读入一字符串
​        } // 继续循环
​        //4、关闭资源 
​        write.close(); // 关闭Socket输出流
​        in.close(); // 关闭Socket输入流
​        socket.close(); // 关闭Socket
​    } catch (Exception e) {
​        System.out.println("can not listen to:" + e);// 出错，打印出错信息
​    }
}

}

所有的代码就在上面，下面说明一下这两段代码的应用：

1.先启动服务端，后启动客户端
2.服务端是接收数据，客户端是发送数据
3.（1）PC1的服务端启动
（2）PC2的服务端启动
（3）PC1的客户端启动
（4）PC2的客户端启动
（5）进行PC1与PC2的文字通讯
4.这个可以自己与自己通讯

与前一篇的文章类似，前一篇传输文字，这一篇传输文件(亲测可用)

下面是客户端的代码：

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;

public class BxClient {  

​    /** 

   * 程序main方法 
      @param args 
        * @throws IOException 
          /  
              public static void main(String[] args) throws IOException {  
          int length = 0;  
          double sumL = 0 ;  
          byte[] sendBytes = null;  
          Socket socket = null;  
          DataOutputStream dos = null;  
          FileInputStream fis = null;  
          boolean bool = false;  
          try {  
              File file = new File("E:/a.txt"); //你要传输的文件路径  
              long l = file.length();   
              socket = new Socket();    
              //下面是对方电脑的IP地址和端口，你必须和对方的PC在同一个网内
              socket.connect(new InetSocketAddress("192.168.168.143",5209));  
              dos = new DataOutputStream(socket.getOutputStream());  
              fis = new FileInputStream(file);        
              sendBytes = new byte[1024];    
              while ((length = fis.read(sendBytes, 0, sendBytes.length)) > 0) {  
          sumL += length;    
          System.out.println("已传输："+((sumL/l)*100)+"%");  
          dos.write(sendBytes, 0, length);  
          dos.flush();  
              }   
              //虽然数据类型不同，但JAVA会自动转换成相同数据类型后在做比较  
              if(sumL==l){  
          bool = true;  
              }  
          }catch (Exception e) {  
              System.out.println("客户端文件传输异常");  
              bool = false;  
              e.printStackTrace();    
          } finally{    
              if (dos != null)  
          dos.close();  
              if (fis != null)  
          fis.close();     
              if (socket != null)  
          socket.close();      
          }  
          System.out.println(bool?"成功":"失败");  
              }  

}

下面是服务器的代码：

import java.io.DataInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

public class BxServerSocket {  

/** 

 * 工程main方法 

 * @param args 
   */  
   public static void main(String[] args) {  
   try {  
   //下面的端口可以和客户端一致
       final ServerSocket server = new ServerSocket(5209);
       Thread th = new Thread(new Runnable() {  
           public void run() {  
               while (true) {  
                   try {    
                       System.out.println("开始监听...");  
                       /* 

      * 如果没有访问它会自动等待 

        ​                    Socket socket = server.accept();  
        ​                    System.out.println("有链接");  
        ​                    receiveFile(socket);  
        ​                } catch (Exception e) {  
        ​                    System.out.println("服务器异常");  
        ​                    e.printStackTrace();  
        ​                }  
        ​            }  
        ​        }  
        ​    });  
        ​    th.run(); //启动线程运行  
        } catch (Exception e) {  
        ​    e.printStackTrace();  
        }       
        }  

public void run() {  
}  

/** 

 * 接收文件方法 

 * @param socket 

 * @throws IOException 
   */  
   public static void receiveFile(Socket socket) throws IOException {  
   byte[] inputByte = null;  
   int length = 0;  
   DataInputStream dis = null;  
   FileOutputStream fos = null;  
   //这里是给你的文件的名字定义
   String filePath = "G:/"+GetDate.getDate()+"SJ"+new Random().nextInt(10000)+".txt";  
   try {  
       try {  
           dis = new DataInputStream(socket.getInputStream());  
           //文件储存位置就是下面
           File f = new File("G:/");  
           if(!f.exists()){  
               f.mkdir();    
           }  
           /*   

      * 文件存储位置

        ​        fos = new FileOutputStream(new File(filePath));      
        ​        inputByte = new byte[1024];     
        ​        System.out.println("开始接收数据...");    
        ​        while ((length = dis.read(inputByte, 0, inputByte.length)) > 0) {  
        fos.write(inputByte, 0, length);  
        fos.flush();      
        ​        }  
        ​        System.out.println("完成接收："+filePath);  
        ​    } finally {  
        ​        if (fos != null)  
        fos.close();  
        ​        if (dis != null)  
        dis.close();  
        ​        if (socket != null)  
        socket.close();   
        ​    }  
        } catch (Exception e) {  
        ​    e.printStackTrace();  
        }  
        }  

}  

下面的是服务器的时间代码：

• import java.text.SimpleDateFormat;
  import java.util.Date;
  
  public class GetDate {
        /** 
  
     * 时间格式到毫秒 
       /  
           private static SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmssSSS");  
           public static String getDate(){  
       return df.format(new Date());  
           }    
       }
       
  

  下面是传输的规则：
  1.首先在PC1打开服务端。
  2.在PC2打开客户端，就会传输过去。