package text;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SandDemo implements Runnable {
//发送端
   private         DatagramSocket s;
   SandDemo(DatagramSocket s){
           this.s=s;
   }
        @Override
        public void run() {
                BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                String line=null;
                try {
                        while((line=br.readLine())!=null){
                                if(line.equals("886"))
                                {
                                        break;
                                }
                                byte[]by=line.getBytes();
                                DatagramPacket dp=new DatagramPacket(by, by.length,InetAddress.getByName("lenovo-PC"),10088);
                                s.send(dp);
                        }
                } catch (IOException e) {
                       
                        e.printStackTrace();
                }finally{
                        try {
                                br.close();
                                s.close();
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                       
                }
        }

}

package text;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
//接收端
public class JIeShouDEmo implements Runnable {
        private DatagramSocket s;
       
        JIeShouDEmo(DatagramSocket s){
                this.s=s;
        }
        public void run() {
                while(true){
                byte[]by=new byte[1024];
                DatagramPacket dp=new DatagramPacket(by, by.length);
                try {
                        s.receive(dp);
                        String IP=dp.getAddress().getHostAddress();
                        int pro=dp.getPort();
                        byte[]bys=dp.getData();
                       
                        String text=new String(bys,0,dp.getLength());
                        System.out.println(IP+"--"+pro+"--"+text);
                       
                        PrintWriter pw=new PrintWriter(new FileWriter("fendo.txt"));
                        pw.println(text);
                        pw.flush();
                       
                } catch (IOException e) {
                       
                        e.printStackTrace();
                }
               
                }
        }

}

package text;

import java.net.DatagramSocket;
import java.net.SocketException;

public class Threshold {
        public static void main(String[] args) throws SocketException {
                DatagramSocket d=new DatagramSocket();
                DatagramSocket d1=new DatagramSocket(10088);
                SandDemo s=new SandDemo(d);
                JIeShouDEmo j=new JIeShouDEmo(d1);
               
                Thread t=new Thread(s);
                Thread t1=new Thread(j);
               
                t.start();
                t1.start();
        }

}
从控制台输入的语句，保存在fendo.txt中，每次运行后之前保存的都被覆盖了，怎么样才能不覆盖

/接收端
public class JIeShouDEmo implements Runnable {
        private DatagramSocket s;
        
        JIeShouDEmo(DatagramSocket s){
                this.s=s;
        }
        public void run() {
                while(true){
                byte[]by=new byte[1024];
                DatagramPacket dp=new DatagramPacket(by, by.length);//把接收数据包放在while外面去                try {
                        s.receive(dp);
                        String IP=dp.getAddress().getHostAddress();
                        int pro=dp.getPort();
                        byte[]bys=dp.getData();

我没有去运行你的代码，但是还是仔细的看了，你用的是      PrintWriter pw=new PrintWriter(new FileWriter("fendo.txt"));
                        pw.println(text);
                        pw.flush();
这段代码来储存接受到的字符串的，PrintWriter类我没有发现可以续写的方法，无论你指定的文件是否存在，都会写入，直到关闭。

如果想要之前写入的数据保留，建议使用FileOutputStream类，这个类中有个构造方法，可以在指定文件的后面续写FileOutputStream(String fileName，boolean append)
只要后面的参数是ture；

看注释：

1. import java.io.FileWriter;
   
2. import java.io.IOException;
   
3. import java.io.PrintWriter;
   
4. import java.net.DatagramPacket;
   
5. import java.net.DatagramSocket;
   
6. 
   
7. //接收端
   
8. public class JIeShouDEmo implements Runnable {
   
9.         private DatagramSocket s;
   
10. 
    
11.         JIeShouDEmo(DatagramSocket s) {
    
12.                 this.s = s;
    
13.         }
    
14. 
    
15.         public void run() {
    
16.                 String text = "";//再声明一个字符串，用于保存所有接收过来的字符串，
    
17.                                         //然后把这个字符串写进文件中就行了
    
18.                 while (true) {
    
19.                         byte[] by = new byte[1024];
    
20.                         DatagramPacket dp = new DatagramPacket(by, by.length);
    
21.                         try {
    
22.                                 s.receive(dp);
    
23.                                 String IP = dp.getAddress().getHostAddress();
    
24.                                 int pro = dp.getPort();
    
25.                                 byte[] bys = dp.getData();
    
26. 
    
27.                                 String text1 = new String(bys, 0, dp.getLength());
    
28.                                
    
29.                                 text += text1;//把接收到的字符串进行累加从而达到保存起来的目的
    
30.                                 System.out.println(IP + "--" + pro + "--" + text);
    
31.                                
    
32.                                
    
33.                                 PrintWriter pw = new PrintWriter(new FileWriter("fendo.txt"));
    
34.                                 pw.println(text);
    
35.                                 pw.flush();
    
36. 
    
37.                         } catch (IOException e) {
    
38. 
    
39.                                 e.printStackTrace();
    
40.                         }
    
41. 
    
42.                 }
    
43.         }
    
44. 
    
45. }

复制代码

问题在这段代码上：
public void run() {
                 while(true){
                 byte[]by=new byte[1024];
                 DatagramPacket dp=new DatagramPacket(by, by.length);
                 try {
                         s.receive(dp);
                         String IP=dp.getAddress().getHostAddress();
                         int pro=dp.getPort();
                         byte[]bys=dp.getData();
                        
                        String text=new String(bys,0,dp.getLength());
                         System.out.println(IP+"--"+pro+"--"+text);
                        
                        PrintWriter pw=new PrintWriter(new FileWriter("fendo.txt"));
//每次执行都会创建一个fendo.txt文件，将上次创建的文件覆盖。也就是说每次在控制台输入一行，回车后，都要新创建一个文件。
//你将上面这行代码换成这行   PrintWriter pw=new PrintWriter(new FileWriter(System.currentTimeMillis()+".txt"));
//在执行，就会发现每次输入后回车都会生成一个不同的文件保存你输入的内容了。
                         pw.println(text);
                         pw.flush();
                        
                } catch (IOException e) {
                        
                        e.printStackTrace();
                 }
                 
                }
         }