UDP与TCP是网络传输数据的两种方式。这两种方式各自的特点是：        UDP的特点：
        把数据、源、目的封装在包中，不需要建立连接，

每个包的大小控制在64k之内

是无连接的，是不可靠的协议

不需要建立连接，因而传输速度快

TCP的特点：

建立连接，形成数据传输的通道

在连接中进行大量数据的传递

通过三次握手完成连接，是可靠的传输协议

必须建立连接，效率相对比较低

打一个比方，UDP之间的通信就像是邮寄包裹，只有找到当地的邮局才能邮寄出去，这个邮局就是DatagramSocket，而邮寄的包裹 就是DatagramPacket。它只管寄，至于寄出去成功还是不成功，它是不管的。

而TCP通信则像是打电话，必须A方先打出去，B方拿起电话，告诉A已经接收到了，A再告诉B说是已经知道B接收到了，才能进行通信，一旦这个信息通道建立，就可以不断的进行传递数据。

UDP适合高效率的传输，而TCP适合大数据和稳定的传输。

网络编程的实质是Socket编程，Socket是网络编程的一种机制，而TCP和UDP只是建立了两种连接主机的方式，而两个主机要完成通信，还是需要用IO流进行的。因而在进行Socket通信的时候，如果已经导入了.net.*包，一般伴随而来的还要导入.IO.*包。

再打一个比方，两地之间进行数据通信就像是两地之间运送石油。UDP通信是把石油装进集装箱（DatagramPacket），然后装进油轮（DatagramSocket），最后告诉油轮去哪里，油轮出去之后是否能够 运送到，就不管了。

TCP通信则是在两地之间建立一条石油管道，只有通过建立管道（connect），再接收 （accept），再对得到的石油进行提炼（getInputStream），再向外发送需要的石油（getOutputStream），这样才能完成石油的传送 ，管道一旦建立，就确定 了，也就是两台主机的信息通道建立了，就可以进行信息通信了。

使用UDP进行信息传输的示例代码（以本机为例）：

import java.io.IOException;
import java.net.*;

public class UDPDemo {
        public static void main(String[] args) throws IOException, InterruptedException {
                // TODO Auto-generated method stub               
                Thread.sleep(1000);
                ReceiveData rd=new ReceiveData();
                Thread t2=new Thread(rd);
                t2.start();

                SendData sd=new SendData();
                Thread t1=new Thread(sd);
                t1.start();
        }
}

class SendData implements Runnable{

        @Override
        public void run() {
                // TODO Auto-generated method stub
                try {
                        DatagramSocket ds = null;
                        ds = new DatagramSocket();//建立带发送端口的DatagramSocket       
                       
                        byte[] data="djaosifdaio".getBytes();//确立要发送的信息
                       
                        DatagramPacket dp=new DatagramPacket(data,data.length,InetAddress.getByName("192.168.1.106"),20005);//打包要发送的数据、IP地址和端口号
                       
                        ds.send(dp);//发送
                       
                        ds.close();//关闭流资源
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
       
}

class ReceiveData implements Runnable{

        @Override
        public void run() {
                try {
                        DatagramSocket ds=new DatagramSocket(20005);
                       
                        byte[] buf=new byte[1024];
                        DatagramPacket dp=new DatagramPacket(buf,buf.length);
                       
                        ds.receive(dp);//监听指定端口的信息
                        String ip=dp.getAddress().getHostAddress().toString();//获取信息的IP地址
                        String data=new String(dp.getData(),dp.getData().length);//获取信息
                        int port=dp.getPort();//获取发送信息的端口号
                       
                        System.out.println("ip="+ip);
                        System.out.println("data="+data);
                        System.out.println("port="+port);
                        ds.close();
                       
                       
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
       
}

运行结果：

ip=192.168.1.106
data=how are you

port=64605

注：端口号是在发送线程创建DatagramSocket的时候指定的，如果在创建的时候不加端口号，那么会随机的选择一个空闲的端口号发送。

TCP使用的具体示例：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

class Client implements Runnable{
        public void run() {
                // TODO Auto-generated method stub
                try {
                        Socket s=new Socket("192.168.1.106",10057);
                       
                        OutputStream os=s.getOutputStream();
                       
                        os.write("how are you ".getBytes());
                       
                        InputStream is=s.getInputStream();
                        byte[] buf=new byte[1024];
                        int k=is.read(buf);
                        System.out.println(new String(buf,0,k));
                       
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }       
}


class Server implements Runnable{

        public void run() {
                // TODO Auto-generated method stub
                ServerSocket ss;
                try {
                        ss = new ServerSocket(10057);               
                       
                        Socket s=ss.accept();
                       
                        InputStream is=s.getInputStream();
                        String line=null;
                        byte[] buf=new byte[1024];
                        int len;
                        while((len=is.read(buf))!=-1){
                                System.out.println(new String(buf,0,len));
                        }
                        OutputStream os=s.getOutputStream();
                        os.write("hao are you too!".getBytes());
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
               
        }
       
}

public class SocketDemo {
        public static void main(String[] args) throws InterruptedException {
                // TODO Auto-generated method stub
                new Thread(new Client()).start();
                Thread.sleep(1000);
                new Thread(new Server()).start();               
        }

}

运行的结果是：

how are you

注意：一定要先运行Server，再运行Client。

赞一个!

支持总结。