Java基础---网络编程
来源：互联网 发布：瑞易物管软件 官网 编辑：程序博客网 时间：2024/06/06 15:07
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
网络编程目录：
一、网络编程
1、网络编程三要素
二、UDP通信
1、UDP发送数据
2、UDP练习_发送端的数据来自于键盘录入案例
三、TCP通信
1、TCP协议_发送数据
2、TCP练习_服务器给客户端一个反馈案例
3、TCP练习_客户端键盘录入服务器控制台输出
4、TCP练习_客户端键盘录入服务器写到文本文件
5、TCP练习_客户端读取文本文件服务器控制台输出
6、TCP练习_TCP协议上传文本文件
7、TCP练习_TCP上传文本文件并给出反馈
8、TCP练习_TCP协议上传图片并给出反馈
9、TCP练习_关于多个客户端上传到一个服务器的思考
网络编程知识详解：
一、网络编程
1、网络编程三要素
* 网络编程三要素：
* 写信：
* 1.地址：精确到班级
* 2.收件人：
* 3.双方一定要是能看得懂的语言；
* 网络编程三要素：
* 1.IP:计算机在互联网上的唯一的地址；
* 2.端口:
* 3.协议:
* 一.IP：
* 1.概念：
* 所谓IP地址就是给每个连接在Internet上的主机分配的一个32bit地址。
* 按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，比特换算成字节，就是4个字节。
* 例如一个采用二进制形式的IP地址是"11000000101010000000000101100100"，这么长的地址，人们处理起来也太费劲了。
* 为了方便人们的使用，IP地址经常被写成十进制的形式，中间使用符号"."分开不同的字节。
* 于是，上面的IP地址可以表示为“10.0.0.1”。IP地址的这种表示法叫做"点分十进制表示法"，这显然比1和0容易记忆得多。
* 最小IP:00000000.00000000.00000000.00000000:十进制：0.0.0.0
* 最大IP:11111111.11111111.11111111.11111111:十进制：255.255.255.255
* 2.IP地址的组成
IP地址 = 网络号码+主机地址
A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码
B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码
C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码
局域网内的电脑在什么情况下可以互相访问：在同一网段；
怎么来区分同一网段：
"子网掩码"：
例如：有如下IP：
1).192.168.1.10
2).192.168.1.20
3).192.168.2.30
1.子网掩码：为:255.255.255.0(二进制：11111111.11111111.11111111.00000000)
(注意：子网掩码中全部表示为1的作为"网络号码")
1和2可以互访；
2.子网掩码：255.255.0.0(二进制：11111111.11111111.00000000.00000000)
1和2和3都可以互访；
特殊地址:
127.0.0.1 回环地址,可用于测试本机的网络是否有问题. ping 127.0.0.1
DOS命令 ipconfig:查看本机IP地址
xxx.xxx.xxx.0 网络地址
xxx.xxx.xxx.255 广播地址
A类 1.0.0.1---127.255.255.254(1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)(2)127.X.X.X是保留地址，用做循环测试用的。
B类 128.0.0.1---191.255.255.254172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。
C类 192.0.0.1---223.255.255.254192.168.X.X是私有地址
D类 224.0.0.1---239.255.255.254
E类 240.0.0.1---247.255.255.254
2.端口：
1).物理端口：网卡口；
2).逻辑端口：由操作系统管理的，在一个"物理端口"的情况下，为了能同时运行多个"网络应用程序"
这时操作系统提供了"逻辑端口"；
A.我们讲的"端口"就是"逻辑端口"；
B.逻辑端口的范围：0--65535;
C.一个应用程序可以同时占用多个端口；
D.一个端口，在某一时刻，只能由一个应用程序占用；
E.0--1024:是由操作系统使用的，我们最好不要用；
3.协议：
1).TCP,UDP,FTP,HTTP.......
2).UDP协议：
1.面向无连接：类似于"广播"，"有线电视"
2.数据需要打包发送；
3.数据大小有限制：64K以内；
4.因为无连接，所以属于不可靠的协议，但速度快；
3).TCP协议：
1.面向连接：类似于"打电话"
2.可以进行大量数据的传输；
* 3.由于需要连接，建立连接就要双方确认，所有速度慢；
2、InetAddress类
* java.net.InetAddress(类)：此类表示互联网协议 (IP) 地址。
* 获取任意主机：getByName(静态方法)
* 机名：getHostName
* 主机Ip地址：getHostAddress
public class Demo {public static void main(String[] args) {try {InetAddress address = InetAddress.getByName("WAK-20150115SMD");String hostName = address.getHostName();String ip = address.getHostAddress();System.out.println("计算机名：" + hostName + " IP：" + ip);} catch (UnknownHostException e) {e.printStackTrace();}}}二、UDP通信1、UDP发送数据
* UDP的接收端：
* 1.构造一个DatagramSocket(端口号):
* 2.准备一个空的byte[]数组，准备接受数据；
* 3.准备一个空的数据包：DatagramPacket，用来接受数据；
* 4.等待数据的到来：DatagramSocket的receive(DatagramPacket)
* 如果数据到达，那么receive()方法将返回，并将数据封装到数据包对象中；
* 5.从数据包中读取数据
public class Receive {public static void main(String[] args) throws IOException{DatagramSocket socket = new DatagramSocket(8888);byte[] byteArray = new byte[1024];DatagramPacket pck = new DatagramPacket(byteArray,byteArray.length);//等待数据到达System.out.println("正在等待信息到达......");socket.receive(pck);//程序在此处会阻塞System.out.println("有信息达到！");//获取数据byte[] byteInfo = pck.getData();String str = new String(byteInfo,0,pck.getLength());String ip = pck.getAddress().getHostAddress();System.out.println("接收到信息：IP：" + ip + " 内容：" + str);socket.close();}} * UDP协议发送数据：* 1.实例化一个:DatagramSocket对象；
* 2.准备数据：
* 1).目标机器的IP:InetAddress对象；
* 2).目标机器的端口号；
* 3).信息内容：byte[]数组
* 3.准备数据包：DatagramPacket对象；需要封装：IP、端口、信息内容；
* 4.发送数据：DatagramSocket对象的send(DatagramPacket p)方法，
public class Send {public static void main(String[] args) throws IOException {//1.准备SocketDatagramSocket socket = new DatagramSocket();//2.准备数据InetAddress add = InetAddress.getByName("WAK-20150115SMD");int port = 8888;byte[] byteArray = "你好，这里是使用UDP发送的数据！".getBytes();//3.准备数据包：DatagramPacket pck = new DatagramPacket(byteArray,byteArray.length,add,port);//4.发送数据socket.send(pck);//5.释放资源socket.close();System.out.println("信息已发出！");}}2、UDP练习_发送端的数据来自于键盘录入案例 * 发送端的数据来自于键盘录入案例
* 1.发送端：键盘录入数据，向接收端发送，直到发送端收到886,程序结束；
public class Send {public static void main(String[] args) throws IOException {Scanner sc = new Scanner(System.in);DatagramSocket socket = new DatagramSocket();InetAddress add = InetAddress.getByName("WAK-20150115SMD");int port = 8888;while(true){System.out.println("请输入：");String info = sc.next();byte[] byteArray = info.getBytes();//实例化一个数据包DatagramPacket pck = new DatagramPacket(byteArray,byteArray.length,add,port);socket.send(pck);if(info.equals("886")){System.out.println("发送端结束了，拜拜......");break;}}//释放资源socket.close();}}public class Receive {public static void main(String[] args) throws IOException {DatagramSocket socket = new DatagramSocket(8888);byte[] byteArray = new byte[1024];DatagramPacket pck = new DatagramPacket(byteArray,byteArray.length);while(true){socket.receive(pck);String str = new String(pck.getData(),0,pck.getLength());System.out.println("接收到信息：" + str);if(str.equals("886")){System.out.println("发送端结束了，我也不玩儿了，拜拜......");break;}}//释放资源socket.close();}}三、TCP通信
1、TCP协议_发送数据
* TCP协议发送数据：
* 1.实例化一个Socket对象（指定目标计算机的IP和端口号）；
* 2.从Socket对象中，获取一个"输出流(字节流)"；
* 3.使用字节流，输出一个byte[]数组；
* 4.关闭流；
public class Send {public static void main(String[] args) throws IOException {//1.实例化一个SocketSocket socket = new Socket("192.168.30.241",8888);//2.获取输出流OutputStream out = socket.getOutputStream();//3.输出一个byte[]数组out.write("你好，这是使用TCP协议发送的数据......".getBytes());//4.关闭流out.close();socket.close();System.out.println("发送端发送完毕！");}} * TCP接收数据：* 1.实例化一个ServerSocket(指定端口)：
* 2.等待连接：ServerSocket的accept()方法
* 3.如果有发送端连接成功，accept()方法将返回，并返回一个Socket对象；
* 4.通过Socket对象获取一个"输入流(字节流)";
* 5.通过字节流一次读取一个字节数组；将字节数组转换为一个String即可；
* 6.释放资源；
public class Receive {public static void main(String[] args) throws IOException {//1.实例化一个ServerSocketServerSocket server = new ServerSocket(8888);//2.等待连接System.out.println("等待连接......");Socket socket = server.accept();System.out.println("有客户端连接成功！");//3.获取输入流InputStream in = socket.getInputStream();byte[] byteArray = new byte[1024];int len = in.read(byteArray);String str = new String(byteArray,0,len);System.out.println("接收到信息：" + str);//4.释放资源in.close();server.close();}}2、TCP练习_服务器给客户端一个反馈案例 * 客户端：
* 1.实例化一个Socket;
* 2.通过Socket获取一个"输出流";
* 3.发送数据；
* 4.通过Socket获取一个"输入流";
* 5.接收数据；
* 6.释放资源
public class Client {public static void main(String[] args) throws IOException {//1.实例化一个SocketSocket socket = new Socket("192.168.30.241",8888);//2.获取一个输出流OutputStream out = socket.getOutputStream();//3.发送数据out.write("你好，这是使用TCP发送的数据......".getBytes());//4.等待反馈--获取一个输入流InputStream in = socket.getInputStream();//5.接收数据byte[] byteArray = new byte[1024];int len = in.read(byteArray);String str = new String(byteArray,0,len);System.out.println("发送端接收到反馈：" + str);//6.释放资源in.close();out.close();socket.close();System.out.println("客户端结束！");}} * 接收端：* 1.实例化一个ServerSocket;
* 2.等待连接，一旦有连接，会返回一个Socket对象；
* 3.获取输入流；
* 4.读取数据；
* 5.获取输出流；
* 6.发送反馈；
* 7.释放资源
public class Server {public static void main(String[] args) throws IOException {ServerSocket server = new ServerSocket(8888);//等待连接Socket socket = server.accept();//获取输入流InputStream in = socket.getInputStream();byte[] byteArray = new byte[1024];int len = in.read(byteArray);String str = new String(byteArray,0,len);System.out.println("服务器端接收到数据：" + str);//获取输出流OutputStream out = socket.getOutputStream();out.write("连接成功！已收到你的信息!".getBytes());//释放资源out.close();in.close();socket.close();server.close();}}3、TCP练习_客户端键盘录入服务器控制台输出 * 客户端键盘录入服务器控制台输出
* 客户端代码：
* 1.实例化一个Socket;
* 2.获取一个输出流；
* 3.实例化一个Scanner接收控制台数据；
* 4.循环，接收控制台数据，每接收一条，就发送一条
* 直到接收到886为止；
* 5.释放资源
public class Client {public static void main(String[] args) throws IOException{Socket socket = new Socket("192.168.30.241",9999);OutputStream out = socket.getOutputStream();Scanner sc = new Scanner(System.in);while(true){System.out.println("请输入信息：");String s = sc.next();out.write(s.getBytes());//判断是否是886if(s.equals("886")){break;}}//释放资源out.close();socket.close();System.out.println("客户端结束！");}} * 服务器端：* 1.实例化一个ServerSocket;
* 2.获取输入流；
* 3.循环读取，一次读取一个字节数组；
* 并将信息显示到控制台；
* 判断是否是886，是：结束；
* 4.释放资源
public class Server {public static void main(String[] args) throws IOException{ServerSocket server = new ServerSocket(9999);Socket socket = server.accept();InputStream in = socket.getInputStream();byte[] byteArray = new byte[1024];int len = 0;while(true){len = in.read(byteArray);String s = new String(byteArray,0,len);System.out.println("服务器端接收到数据：" + s);if(s.equals("886")){System.out.println("客户端结束，我也结束了，拜拜......");break;}}in.close();socket.close();server.close();System.out.println("服务器端结束！");}}4、TCP练习_客户端键盘录入服务器写到文本文件 * 客户端代码：
* 1.实例化一个Socket;
* 2.获取一个输出流；
* 3.实例化一个Scanner接收控制台数据；
* 4.循环，接收控制台数据，每接收一条，就发送一条
* 直到接收到886为止；
* 5.释放资源
public class Client {public static void main(String[] args) throws IOException {Socket socket = new Socket("192.168.30.241",9999);OutputStream out = socket.getOutputStream();Scanner sc = new Scanner(System.in);while(true){System.out.println("请输入信息：");String str = sc.next();out.write(str.getBytes());if(str.equals("886")){break;}}System.out.println("客户端结束！");out.close();socket.close();}} * 接收端：* 1.实例化一个ServerSocket;
* 2.等待连接，获取Socket对象；
* 3.获取"网络输入流"；
* 4.实例化一个"文件输出流(字节流)"
* 5.循环读取网络数据，并写入到文件；
* 遇到886，结束；
* 6.释放资源
public class Server {public static void main(String[] args) throws IOException{ServerSocket server = new ServerSocket(9999);Socket socket = server.accept();//网络输入流InputStream netIn = socket.getInputStream();//文件输出流FileOutputStream fileOut = new FileOutputStream("demo08.txt");//读取网络数据byte[] byteArray = new byte[1024];int len = 0;while(true){len = netIn.read(byteArray);if(len == -1){break;}fileOut.write(byteArray,0,len);fileOut.write("\r\n".getBytes());String str = new String(byteArray,0,len);if(str.equals("886")){break;}}System.out.println("服务器端结束！");fileOut.close();netIn.close();socket.close();server.close();}}5、TCP练习_客户端读取文本文件服务器控制台输出 * 客户端读取文本文件服务器控制台输出
* 客户端代码：
* 1.实例化一个Socket对象；
* 2.获取一个网络输出流；
* 3.实例化一个文件输入流(带缓冲的字符流)；
* 4.循环读取文件，发送数据；
* 读取到文件结尾，循环结束；
* 5.释放资源；
public class Client {public static void main(String[] args) throws IOException {Socket socket = new Socket("192.168.30.241",8888);//网络输出流OutputStream netOut = socket.getOutputStream();//文件输入流BufferedReader fileIn = new BufferedReader(new FileReader("demo09.txt"));String row = null;while((row = fileIn.readLine()) != null){netOut.write(row.getBytes());netOut.write("\r\n".getBytes());}//释放资源fileIn.close();netOut.close();socket.close();System.out.println("客户端结束！");}} * 服务器端：* 1.实例化一个ServerSocket;
* 2.获取网络输入流(字节流)--》转换为字符流
* 3.循环读取，一次读取一行
* 4.释放资源
public class Server {public static void main(String[] args) throws IOException {ServerSocket server = new ServerSocket(8888);// 等待连接Socket socket = server.accept();// 获取网络输入流InputStream netIn = socket.getInputStream();// 转换为带缓冲的字符流BufferedReader netBufIn = new BufferedReader(new InputStreamReader(netIn));//一次读取一行数据String row = null;while((row = netBufIn.readLine()) !=null){System.out.println("读取到信息：" + row);}//释放资源netIn.close();socket.close();server.close();System.out.println("服务器端结束！");}}6、TCP练习_TCP协议上传文本文件 * TCP协议上传文本文件
* 客户端：
* 1.实例化一个Socket；
* 2.获取网络输出流；
* 3.实例化一个文件输入流(字节流)；
* 4.循环读取文件内容，一次读取一个字节数组；
* 一次发送一个字节数组；
* 5.释放资源；
public class Client {public static void main(String[] args) throws IOException{Socket socket = new Socket("192.168.30.241",8888);OutputStream netOut = socket.getOutputStream();FileInputStream fileIn = new FileInputStream("demo10.txt");byte[] byteArray = new byte[1024];int len = 0;while((len = fileIn.read(byteArray)) != -1){netOut.write(byteArray,0,len);}fileIn.close();netOut.close();socket.close();System.out.println("客户端上传完毕！");}} * 服务器端代码：* 1.实例化一个ServerSocket;
* 2.获取一个网络输入流；
* 3.实例化一个文件输出流；
* 4.循环读取，一次读取一个字节数组；
* 一次写入一个字节数组；
* 5.释放资源；
public class Server {public static void main(String[] args) throws IOException{ServerSocket server = new ServerSocket(8888);Socket socket = server.accept();//网络输入流InputStream netIn = socket.getInputStream();//文件输出流FileOutputStream fileOut = new FileOutputStream("demo10_upload.txt");//一次读取一个字节数组byte[] byteArray = new byte[1024];int len = 0;while((len = netIn.read(byteArray)) != -1){fileOut.write(byteArray,0,len);}//释放资源fileOut.close();netIn.close();socket.close();server.close();System.out.println("服务器端完毕！");}}7、TCP练习_TCP上传文本文件并给出反馈 * TCP上传文本文件并给出反馈
* 客户端：
public class Client {public static void main(String[] args) throws IOException {Socket socket = new Socket("192.168.30.241",8888);OutputStream netOut = socket.getOutputStream();FileInputStream fileIn = new FileInputStream("demo11.txt");byte[] byteArray = new byte[1024];int len = 0;while((len = fileIn.read(byteArray)) != -1){netOut.write(byteArray,0,len);}//告诉服务器端，我这边已经发送完毕，不再发送了socket.shutdownOutput();//将会发送一个-1给服务器System.out.println("客户端上传完毕，等待反馈......");//***********接收反馈信息*************//InputStream netIn = socket.getInputStream();byte[] byteInfo = new byte[1024];len = netIn.read(byteInfo);String str = new String(byteInfo,0,len);System.out.println("客户端接收到反馈：" + str);//释放资源fileIn.close();netOut.close();socket.close();System.out.println("客户端上传完毕！");}} * 服务器端代码：* 1.实例化一个ServerSocket;
* 2.获取一个网络输入流；
* 3.实例化一个文件输出流；
* 4.循环读取，一次读取一个字节数组；
* 一次写入一个字节数组；
* 5.释放资源；
public class Server {public static void main(String[] args) throws IOException{ServerSocket server = new ServerSocket(8888);Socket socket = server.accept();//网络输入流InputStream netIn = socket.getInputStream();//文件输出流FileOutputStream fileOut = new FileOutputStream("demo11_upload.txt");//一次读取一个字节数组byte[] byteArray = new byte[1024];int len = 0;System.out.println("服务器端开始接收数据......");while((len = netIn.read(byteArray)) != -1){fileOut.write(byteArray,0,len);}//**************给出反馈*************//System.out.println("服务器端接收完毕，发送反馈信息......");OutputStream netOut = socket.getOutputStream();netOut.write("接收完毕！".getBytes());//释放资源netOut.close();fileOut.close();netIn.close();socket.close();server.close();System.out.println("服务器端完毕！");}}8、TCP练习_TCP协议上传图片并给出反馈 * TCP协议上传图片并给出反馈
* 客户端：
* 1.实例化一个Socket；
* 2.获取网络输出流；
* 3.实例化一个文件输入流(字节流(必须))；
* 4.循环读取文件内容，一次读取一个字节数组；
* 一次发送一个字节数组；
* 5.释放资源；
public class Client {public static void main(String[] args) throws IOException{Socket socket = new Socket("192.168.30.241",8888);OutputStream netOut = socket.getOutputStream();FileInputStream fileIn = new FileInputStream("C:\\aaa\\cxy.bmp");byte[] byteArray = new byte[1024];int len = 0;while((len = fileIn.read(byteArray)) != -1){netOut.write(byteArray,0,len);}//结束输出流socket.shutdownOutput();//***************接收反馈***************//InputStream netIn = socket.getInputStream();byte[] byteInfo = new byte[1024];len = netIn.read(byteInfo);String str = new String(byteInfo,0,len);System.out.println("客户端接收到反馈：" + str);//释放资源netIn.close();netOut.close();fileIn.close();socket.close();System.out.println("客户端结束！");}}public class Server {public static void main(String[] args) throws IOException{ServerSocket server = new ServerSocket(8888);Socket socket = server.accept();//网络输入流InputStream netIn = socket.getInputStream();//文件输出流FileOutputStream fileOut = new FileOutputStream("demo12_cxy_copy.bmp");//一次读取一个字节数组byte[] byteArray = new byte[1024];int len = 0;System.out.println("服务器端开始接收数据......");while((len = netIn.read(byteArray)) != -1){fileOut.write(byteArray,0,len);}//**************给出反馈*************//System.out.println("服务器端接收完毕，发送反馈信息......");OutputStream netOut = socket.getOutputStream();netOut.write("接收完毕！".getBytes());//释放资源netOut.close();fileOut.close();netIn.close();socket.close();server.close();System.out.println("服务器端完毕！");}}9、TCP练习_关于多个客户端上传到一个服务器的思考
public class Client {public static void main(String[] args) {//模拟10个客户端同时连接服务器for(int i = 1 ; i <= 10 ;i ++){new ClientThread(i).start();}}}public class ClientThread extends Thread {private int index;public ClientThread(int index){this.index = index;}@Overridepublic void run() {//连接服务器try {Socket socket = new Socket("192.168.30.241",8888);//网络输出流OutputStream netOut = socket.getOutputStream();//文件输入流FileInputStream fileIn = new FileInputStream("C:\\ccc\\" + index + ".png");//一次读取一个字节数组byte[] byteArray = new byte[1024];int len = 0;while((len = fileIn.read(byteArray)) != -1){netOut.write(byteArray,0,len);}//释放资源fileIn.close();netOut.close();socket.close();System.out.println("文件：" + index + ".png 上传完毕！");} catch (IOException e) {e.printStackTrace();} }}public class Server {public static void main(String[] args) throws IOException{ServerSocket server = new ServerSocket(8888);int index = 1;while(true){Socket socket = server.accept();//启动线程；new ServerThread(index++,socket).start();}}}public class ServerThread extends Thread {public int index ;private Socket socket ;//此索引，跟客户端的索引不是一一对应的；public ServerThread(int index,Socket socket){this.index = index;this.socket = socket;}@Overridepublic void run() {//获取网络输入流try {InputStream netIn = socket.getInputStream();FileOutputStream fileOut = new FileOutputStream(index + ".png");byte[] byteArray = new byte[1024];int len = 0;while((len = netIn.read(byteArray)) != -1){fileOut.write(byteArray,0,len);}fileOut.close();netIn.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}//文件的输出流}}总结：一.网络编程三要素：
1.IP:
二进制：四段8位的二进制表示；
十进制：四段3位的0--255的数字；
2.端口：
1).物理端口：网卡口
2).逻辑端口：由操作系统维护，Windows下0--65535
0-1024由系统内部使用，我们尽量不要使用；
我们讲的端口：逻辑端口：
3.协议：
1).UDP协议：
A.将数据源和目的封装成数据包中，
B.不需要建立连接；
C.每个数据报的大小在限制在64k；
D.因无连接，是不可靠协议；但速度快
2).TCP协议：
A.需要建立连接；
B.在连接中进行大数据量传输；
C.通过三次握手完成连接，是可靠协议；
D.必须建立连接，效率会稍低
二.UDP协议编程：
1.发送端：
1.实例化DatagramSocket();
DatagramSocketsocket = new DatagramSocket();
2.准备数据：
IP: InetAddress add =InetAddress("Lenovo-PC");
端口： int port = 8888;
数据： byte[] byteArray = "你好".getBytes();
3.准备数据报：
DatagramPacketpacket = new DatagramPacket(byteArray,
byteArray.length,
add,port);
4.发送：
socket.send(packet);
5.释放资源：
socket.close();
2.接收端：
//1.实例化DatagramSocket
DatagramSocketsocket = new DatagramSocket(8888);
//2.准备一个空的byte[]数组
byte[]byteArray = new byte[1024];
//3.准备一个空的DatagramPacket
DatagramPacketpacket = new DatagramPacket(byteArray,byteArray.length);
//4.等待信息
socket.receive(packet);
//5.获取信息
byte[]infoArray = packet.getData();
Stringinfo = new String(infoArray,0,packet.getLength());
System.out.println("获取的信息："+ info);
//6.释放资源
socket.close();
三.TCP协议编程：
1.发送端：
//1.实例化一个Socket
Socketsocket = new Socket("192.168.38.91",8888);
//2.获取输出流
OutputStreamout = socket.getOutputStream();
//3.输出，一次输出一个字节数组
out.write("你好".getBytes());
//4.释放资源
out.close();
socket.close();
2.接收端：
//1.实例化一个ServerSocket
ServerSocketserver = new ServerSocket(8888);
//2.获取输入流
InputStreamin = socket.getInputStream();
//3.一次读取一个字节数组
byte[]byteArray = new byte[1024];
intlen = in.read(byteArray);
Strings = new String(byteArray,0,len);
System.out.println("接收到的数据："+ s);
//4.释放资源
in.close();
sever.close();
- JAVA网络编程基础
- Java网络编程基础
- java网络编程基础
- Java网络编程基础
- Java基础网络编程
- Java网络编程基础
- java基础<网络编程>
- java网络编程基础
- Java网络编程基础
- java基础：网络编程
- Java基础：网络编程
- 【java】网络编程基础
- java网络编程基础
- java网络编程基础
- Java基础--网络编程
- Java 网络编程基础
- Java基础：网络编程
- java基础--网络编程
- c语言入门——printf函数
- MySQL关键字（保留字）汇总
- 如何选择安全可靠质量好的移动电源
- 最大费用最大流 hdu4322 Candy
- 简单动画的正反播放
- Java基础---网络编程
- android studio编译较大项目时出现问题createDebugMainDexClassList....finished with non-zero exit value x
- 安卓自定义控件初探---仿web验证码的实现
- 秒变专家，三招教你选高品质移动电源
- 从伪随机数的产生到高大上的蒙特卡洛算法（C语言实现）
- IOS-11-关于AFNetworking访问网络超时的设置
- c调用lua函数
- 怎样设置一个适合自己的终端(shell)->zsh 终极cell ->装逼神器
- C#实现对SQL数据库中的表的查询、添加、修改、删除数据
