java写的Socket客户端和服务端通信，经验证可以执行的代码，并添加了很多注释

    复杂的不是Socket本身，他的结构不复杂，主要是输入、输出流的加入，由于io类练习的少，所以理解上费了些事，这就是java基础薄弱的表现哦，缺乏java基础类的练习

服务端：

 //package com.socket;

import java.net.*;
import java.io.*;
import java.lang.*;

public class TestSocketServer{
 
  public static void main(String args[])
  {
    try
    {
     boolean flag = true;
    
     Socket clientSocket = null;   
      //定义客户端套接字
     //JavaAPI 包java.net，找到Socket类，查看其包含的方法
     //Socket()
     //通过系统默认类型的 SocketImpl 创建未连接套接字
   
     String inputLine;
     int c;
    
     ServerSocket sSocket = new ServerSocket(8018);   
     // 创建绑定端口的服务端socket
     //JavaAPI 包java.net，找到ServerSocket类，查看其包含的方法
     //ServerSocket(int port)
     // 创建绑定到特定端口的服务器套接字。
        
     System.out.println("Server listen on :"+sSocket.getLocalPort());
       // int getLocalPort()  返回此套接字在其上侦听的端口。
   
   
   
    
     while(flag)
     {
      clientSocket = sSocket.accept();
      //Socket accept()
            // 侦听并接受到此套接字的连接。
     
      DataInputStream dataIn = new DataInputStream(new BufferedInputStream(clientSocket.getInputStream()));
      //InputStream getInputStream()
             //返回此套接字的输入流。
     
      OutputStream dataOut = clientSocket.getOutputStream();

      //OutputStream getOutputStream()
            //返回此套接字的输出流。
          
            while((inputLine = dataIn.readLine())!= null)
            {
             //当客户端输入stop的时候，服务器停止运行
             if(inputLine.equals("stop"))
                { flag = false;
                  break;
                
                 }
              else
                 {
                  System.out.println(inputLine);
                 
                   while((c = System.in.read())!=-1)       //System.in.read()   当返回   -1   时，表示流的结束
                
                 //java.lang 类 System
                 //     in
                 //    public static final InputStream in“标准”输入流。
                 //    此流已打开并准备提供输入数据。
                 //    通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
                
                
                  // java.io 类 InputStream                      
                  // abstract  int read()
                   // 从输入流读取下一个数据字节。
                  
                   {
                      dataOut.write((byte)c);     
                     
                     
                     
                      if(c=='\n')       ////   如果读到的c是换行符    这里 '\n' 是字符，转换成整型数值后与c进行比较
                      {
                       dataOut.flush();  ////将c转成字节型写入输出流，将信息发送到客户端
                       break;
                       //类 OutputStream
                       //方法  flush
                       //public void flush()
                      //throws IOException刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。
                     //如果此流的预期目标是由基础操作系统提供的一个抽象（如一个文件），则刷新此流只能保证将以前写入到流的字节传递给操作系统进行写入，但不保证能将这些字节实际写入到物理设备（如磁盘驱动器）。
                     //OutputStream 的 flush 方法不执行任何操作。

                       }
                    }
                  }
             }
            
             dataIn.close();
             dataOut.close();
             clientSocket.close();
     
     }
    
     sSocket.close();
    
    
    }
   
    catch(Exception e)
    {
     System.out.println("Exception :"+e.getMessage());
     }
    
   }
 
 
 
 
}

客户端：

//package com.socket;
import java.lang.*;
import java.net.*;
import java.io.*;

public class TestSocketClient{
 
 public static void main(String args[])
 {
    try
    {
         //创建通讯并且和服务端主机连接
         Socket cSocket = new Socket("192.168.1.102",8018);
         //JavaAPI 包java.net，找到Socket类，查看其包含的方法
         // Socket(InetAddress address, int port)  构造方法
            // 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
       
         //打开这个Socket的输入/输出流
         OutputStream dataOut = cSocket.getOutputStream();
         DataInputStream dataIn = new DataInputStream(cSocket.getInputStream());
       
         int c;
         boolean flag = true;
       
         String responseline;
         responseline = null;
       
         while(flag)
         {
          //从标准输入输出接收字符并且写入系统
            while((c=System.in.read())!=-1)
            {
             dataOut.write((byte)c);
             if(c=='\n')
               {
                dataOut.flush();
                //将程序阻塞，直到回答信息被接收到后将他们显示在标准输出上
               
                responseline = dataIn.readLine();
                System.out.println("Message is:"+responseline);
               
                }
            
             }
         
          }
          dataOut.close();
          dataIn.close();
          cSocket.close();
     }
     catch(Exception e)
     {
         System.out.println("Exception :"+e.getMessage());
      }
  
  }
}

--------------------------------------------------------------

服务端的关键代码

  ServerSocket sSocket = new ServerSocket(8018);  

      while(flag)
     { 
       Socket clientSocket = sSocket.accept();
       DataInputStream dataIn = new DataInputStream(new BufferedInputStream(clientSocket.getInputStream()));
       OutputStream dataOut = clientSocket.getOutputStream();
       String inputLine = dataIn.readLine();
    
    
    
        while(inputLine != null)
            {
             if(inputLine.equals("stop"))
                { flag = false;
                  break;
                
                 }
              else
                 {
                  System.out.println(inputLine);
                 
                   while((c = System.in.read())!=-1)                
                   {
                      dataOut.write((byte)c);     
                      if(c=='\n')      
                      {
                       dataOut.flush();  
                       break;
                       }
                    }
                  }
             }
             dataIn.close();
             dataOut.close();
             clientSocket.close();  
       }
       sSocket.close();
      

帖子参考；

http://topic.csdn.net/u/20070518/09/5bfb2de8-8ab1-4c26-abfd-5d28fc410761.html?1410589227

上午又写了一遍，需要注意的地方还很多哦

客户端与服务端，需要交替输入数据来进行交互

服务端:

import java.net.*;
import java.lang.*;
import java.io.*;

public class MySocketServer
  {
 
    public static void main(String args[])     //throws IOException
     {
        try{
         ServerSocket myServer = new ServerSocket(8018);
         System.out.println("正在监听端口："+myServer.getLocalPort());
         Socket myClient = null;
        
         boolean flag = true;
         String InputMessage = null;
         int c;
      
     
         while(flag)
         {
           myClient = myServer.accept();
           //接收客户端的信息，如果不是Stop就继续监听，加个if判断
           DataInputStream dataIn = new DataInputStream(myClient.getInputStream());
           //DataInputStream dataIn = new DataInputStream(new BufferedInputStream(myClient.getInputStream()));       
           OutputStream dataOut = myClient.getOutputStream();
          
          while( (InputMessage = dataIn.readLine()) != null )
            {
             if( InputMessage.equals("stop"))
             {
                 flag = false;
                 break;
              }
             else
             {               
                  System.out.println("从客户端接收到的信息是："+InputMessage);
                  //输入：读取至 末尾-1结束，遇到回车'\n'结束：
                  while((c=System.in.read())!= -1)
                    {
                      dataOut.write((byte)c);
                       if(  c== '\n')
                       {
                         dataOut.flush();
                         break;
                       }
                     
                     }
  
              }
          }
          dataIn.close();    
           dataOut.close();
           myClient.close();
          }
         myServer.close(); 
         }
       catch(Exception e)
          {
             System.out.println(e.getMessage());
           } 
     
     } 
 
 }

客户端：

import java.io.*;
import java.lang.*;
import java.net.*;

public class MySocketClient
{
 public static void main(String args[])
 {
   try{   
     
       Socket myClient = new Socket("192.168.1.25",8018);
                          
       DataInputStream dataIn = new DataInputStream(myClient.getInputStream());
       OutputStream dataOut = myClient.getOutputStream();
      
       boolean flag = true;
       int c;
       String serverResponse = null ;
      
       while(flag)
       {
          while( (c=System.in.read())!= -1 )
            {
              dataOut.write((byte)c);
              if(c=='\n')
                 {
                    dataOut.flush();
                    serverResponse = dataIn.readLine();
                    System.out.println("服务器的返回信息是："+serverResponse);
                  
                  }
             }
        
        }
       dataIn.close();
       dataOut.close();
       myClient.close(); 
      }
    
   catch(Exception e)
   {
     System.out.println("Exception :"+e.getMessage());
    } 
 }  
}