头晕晕的了，不知道客户端为什么得不到数据 猜测就是在流的写入写出被阻塞，出了问题了！太累了怎么都看不出来
import java.io.*;
import java.net.*;

class PicClien
{   
          public static void main(String []  args)throws Exception
          {
                  Socket s=new Socket("192.168.1.254",1007);
                  FileInputStream fis=new FileInputStream("c:\\1.bmp");
                  OutputStream  out=s.getOutputStream();
                  byte[] buf=new byte[1024];
                  int len=0;
                  while((len=fis.read(buf))!=-1)
                  {
                          out.write(buf,0,len);
                  }
                  InputStream in=s.getInputStream();
                  byte[] bufIn= new byte[1024];
                  int num=in.read(bufIn);
                  System.out.println(new String(bufIn,0,num));
                  fis.close();
                  s.close();
          }
}


class  PicServer
{
        public static void main(String[] args)throws Exception
        {
                ServerSocket ss= new ServerSocket(1007);
                Socket s=ss.accept();
                InputStream in=s.getInputStream();
                FileOutputStream fos= new FileOutputStream("server.bmp");
                byte[] buf= new byte[1024];
                 
                int len=0;
                while((len=in.read(buf))!=-1)
                {
       fos.write(buf,0,len);               
                }
                OutputStream out= s.getOutputStream();
                out.write("上传成功".getBytes());
                fos.close();
                s.close();
                ss.close();
        }

}

客户端传完图片后，但是并没有发送结束标记，所以服务端并不知道已经传完了，一直在等着接收文件，只有给服务端发送结束标记才行，可以约定一个结束标记，比如在最后发送个“over”之类的，这样服务端接到之后就知道接收完成了，才会给客户端回馈信息，但是这样不专业也容易出问题，比如如果文件内有“over”内容就会出错，所以Socket有自定一个shundownOutput方法，传完文件后调用该方法关闭其输出流，实际就是在向服务端发送文件上传结束标记，看图：

还有，最好把刷新流，因为用到了字节数组缓冲，凡是有缓冲的都要刷新，免得数据丢失。

1. public class PicServer {
   
2.         public static void main(String[] args) throws Exception {
   
3.                 ServerSocket ss = new ServerSocket(1007);
   
4.                 Socket s = ss.accept();
   
5.                 InputStream in = s.getInputStream();
   
6.                 FileOutputStream fos = new FileOutputStream("e:/server.jpg");
   
7.                 byte[] buf = new byte[1024];
   
8.                 OutputStream out = s.getOutputStream();
   
9.                 int len = 0;
   
10.                 while ((len = in.read(buf)) ==1024) {//只有当客户端的输出流close后，此处的len才会为-1，但客户端若将输出流关掉，连接也会关掉。所以这里以读出的是否是1024个字节判断，不是1024就表示这是最后一组数据了
    
11.                         fos.write(buf, 0, len);
    
12.                 }
    
13.                 fos.write(buf, 0, len);//将最后一组数据写入到文件
    
14.                 fos.flush();
    
15.                 fos.close();//文件流可以关掉了
    
16.                 out.write("上传成功".getBytes());
    
17.                 out.flush();//写后一定要flush一下，强制将输出缓冲区中数据清空，写入流中
    
18.                 in.close();//此时才可以关输入流，提早关会导致连接关闭
    
19.                 s.close();
    
20.                 ss.close();
    
21.         }
    
22. }

复制代码

1. public class PicClient {
   
2.         public static void main(String []  args)throws Exception
   
3.     {
   
4.             Socket s=new Socket("127.0.0.1",1007);
   
5.             FileInputStream fis=new FileInputStream("e:/1.jpg");
   
6.             OutputStream  out=s.getOutputStream();
   
7.             byte[] buf=new byte[1024];
   
8.             int len=0;
   
9.             while((len=fis.read(buf))!=-1)
   
10.             {               
    
11.                     out.write(buf,0,len);
    
12.             }
    
13.             out.flush();//一定要有这步，保证数据都传过去了
    
14.             fis.close();//文件流这时可以关了
    
15.             InputStream in=s.getInputStream();//在此之前一定不能关闭out，不然连接也会关闭，这里就会报错
    
16.             byte[] bufIn= new byte[1024];
    
17.             int num=in.read(bufIn);
    
18.             System.out.println(new String(bufIn,0,num));
    
19.             out.close();//此时才可以关闭流
    
20.             s.close();
    
21.     }
    
22. }

复制代码

上面那位兄弟已经说的很明白了，没有结束标记，服务端会一直等客户端传数据。
给你一个我写的加入缓冲区，及时刷新的，可以有效的防止数据丢失。

1. import java.io.*;
   
2. import java.net.*;
   
3. 
   
4. 
   
5. class TcpServer {
   
6. 
   
7.         /**
   
8.          * @param args
   
9.          */
   
10.         private static BufferedOutputStream bw;
    
11.         private static BufferedInputStream brIn;
    
12. 
    
13.         public static void main(String[] args) {
    
14.                 // TODO Auto-generated method stub
    
15.                 try {
    
16.                         ServerSocket ss = new ServerSocket(11000);
    
17. 
    
18.                         Socket sk = ss.accept();
    
19. 
    
20.                         brIn = new BufferedInputStream(sk.getInputStream());
    
21. 
    
22.                         bw = new BufferedOutputStream(new FileOutputStream("d:\\1.jpg"));
    
23.                        
    
24.                         byte[] buf = new byte[1024];
    
25.                         int len = 0;
    
26.                         while((len = brIn.read(buf))!=-1){
    
27.                                 bw.write(buf,0,len);
    
28.                                 bw.flush();
    
29.                         }
    
30.                         OutputStream out = sk.getOutputStream();
    
31.                         out.write("上传成功".getBytes());
    
32. 
    
33.                 } catch (IOException e) {
    
34.                         // TODO Auto-generated catch block
    
35.                         e.printStackTrace();
    
36.                 }
    
37.         }
    
38. 
    
39. }
    
40. 
    
41. 
    
42. 
    
43. 
    
44. class TcpClient {
    
45. 
    
46.         /**
    
47.          * @param args
    
48.          */
    
49.         private static BufferedInputStream br;
    
50.         private static BufferedOutputStream bfout;
    
51.         private static Socket sk;
    
52. 
    
53.         public static void main(String[] args) {
    
54.                 // TODO Auto-generated method stub
    
55.                
    
56. 
    
57.                 try {
    
58.                         sk = new Socket("192.168.1.254",11000);
    
59.                        
    
60.                         br = new BufferedInputStream(new FileInputStream("c:\\1.jpg"));
    
61.                         bfout = new BufferedOutputStream(sk.getOutputStream());
    
62. 
    
63.                         byte[] buf = new byte[1024];
    
64.                        
    
65.                         int len = 0;
    
66.                        
    
67.                         while((len=br.read(buf))!= -1){
    
68.                                 bfout.write(buf,0,len);
    
69.                                 bfout.flush();
    
70.                         }
    
71.                        
    
72.                         sk.shutdownOutput();
    
73.                         InputStream in = sk.getInputStream();
    
74.                         byte[] bufIn = new byte[1024];
    
75. 
    
76.                         int num = in.read(bufIn);
    
77.                         System.out.println(new String(bufIn,0,num));
    
78. 
    
79. 
    
80. 
    
81.                 } catch (IOException e) {
    
82.                         // TODO Auto-generated catch block
    
83.                         e.printStackTrace();
    
84.                 } finally {
    
85.                         try {
    
86.                                 if (br != null)
    
87.                                         br.close();
    
88.                         } catch (IOException e) {
    
89.                                 e.printStackTrace();
    
90.                         }
    
91.                         try {
    
92.                                 if (bfout != null)
    
93.                                         bfout.close();
    
94.                         } catch (IOException e) {
    
95.                                 e.printStackTrace();
    
96.                         }
    
97.                         try {
    
98.                                 if (sk != null)
    
99.                                         sk.close();
    
100.                         } catch (IOException e) {
     
101.                                 e.printStackTrace();
     
102.                         }
     
103.                 }
     
104.         }
     
105. }

复制代码