黑马程序员-网络编程概述-网络模型-UDP-TCP

最新推荐文章于 2025-08-09 15:58:26 发布
原创 最新推荐文章于 2025-08-09 15:58:26 发布 · 506 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #黑马程序员

本文介绍了网络编程的基本概念，包括网络模型、通讯要素、TCP/IP协议、Socket编程等内容，并提供了基于Java的UDP和TCP编程实例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

---------------------- android培训、java培训、期待与您交流！ ---------------------- 
网络编程（概述）
网络模型
  • OSI参考模型
  • TCP/IP参考模型
网络通讯要素
  • IP地址
  • 端口号
  • 传输协议
实现通讯的步骤
  1. 通过IP地址找到对方
  2. 通过指定的端口号连接到应用程序，实现数据传输。（为了将数据发送到指定的程序上，用来标识应用程序的的数字，为了方便称呼这些数字，命名它们为端口。这些端口是虚拟的，所以是逻辑端口。）
  3. 定义通讯规则，这个通讯规则称为协议。国际组织定义了通用协议Tcp/IP
网络模型
网络通讯要素
IP地址：
  • 网络中设备的标识
  • 不易记忆，可用主机名
  • 本地回环地址：127.0.0.1 主机名：localhost
端口号
  • 用于标识进程的逻辑地址，不同进程的标识
  • 有效端口：0-65535，其中0-1024系统使用或保留端口
传输协议
  • 通讯的规则
  • 常见的协议：TCP,UDP
UDP
  • 将数据源和目的封装成数据包中，不需要建立连接
  • 每个数据报的大小限制在64k内
  • 因为无连接，是不可靠协议
  • 不需要建立连接，速度快
TCP
  • 建立连接，形成传输数据的通道。
  • 在连接中进行大数据量传输。
  • 通过三次握手完成连接，是可靠协议。
  • 必须建立连接。效率会稍低。
Socket
  • Socket就是为网络服务提供的一种机制。
  • 通信的两端都有Socket。
  • 网络通信其实就是Socket间的通信。
  • 数据在两个Socket间通过IO传输。
UDP发送
public class DatagramSocket
extends Object
此类表示用来发送和接收数据报包的套接字。
数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。
在 DatagramSocket 上总是启用 UDP 广播发送。为了接收广播包，应该将 DatagramSocket 绑定到通配符地址。在某些实现中，将 DatagramSocket 绑定到一个更加具体的地址时广播包也可以被接收。
练习代码:
/*
 * 需求：通过UDP传输方式，将一段文字数据发送出去。
 * 思路：
 * 1，建立UdpSocket服务。
 * 2，提供数据，并将数据封装到数据包中。
 * 3，通过Socket服务的发送功能，将数据包发出去。
 * 4，关闭资源。
 */
public class DataGramSocketSendDemo {

	public static void main(String[] args) {
		//创建udp socket，建立端点
		DatagramSocket ds = null;
		//定义数据包，用于接收数据。
		byte[] value = "hello this is test data".getBytes();
		try {
			DatagramPacket dap = new DatagramPacket(value,value.length,InetAddress.getByName("192.168.1.110"),6666);
			ds = new DatagramSocket();
			ds.send(dap);
		} catch (Exception e) {
			throw new RuntimeException("udp数据发送异常");
		}finally{
			ds.close();
		}
	}
}

接收端：

/*
 * 需求：
 * 定义一应用程序，用于接收UDP协议传输的数据并处理。
 * 定义UDP的接收端。
 * 思路：
 * 1，定义UDPSocket服务，通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。方便于明确哪些数据
 * 		来过该应用程序可以处理。
 * 2，定义一个数据包，因为要存储接收到字节数据。
 * 		因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
 * 3，通过Socket服务的Receive方法将收到的数据存入已定义好的数据包中。
 * 4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
 * 5，关闭资源。
 */
public class DatagramSocketReceDemo {

	public static void main(String[] args) {
		DatagramSocket das = null;
			try {
				das = new DatagramSocket(6666);
				while(true){
				byte[] value = new byte[1024];
				DatagramPacket dap = new DatagramPacket(value,value.length);
				 das.receive(dap);
				 String str = new String(dap.getData(),0,dap.getLength());
				 int port = dap.getPort();
				 String ip = new String(dap.getAddress().getHostAddress());
				 System.out.println(str + "::" + ip + "::" + port);
			}
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
}

UDP聊天：
public class UdpChat {

	public static void main(String[] args) {
		try {
			DatagramSocket send = new DatagramSocket();
			DatagramSocket rece = new DatagramSocket(10002);
			new Thread(new SendClient(send)).start();
			new Thread(new ReceClient(rece)).start();
		} catch (Exception e) {
			throw new RuntimeException("接口创建失败");
		}
	}
}
class ReceClient implements Runnable{
	DatagramSocket das;
	public ReceClient(DatagramSocket das){
		this.das = das;
	}
	@Override
	public void run() {
		try {
			byte[] value = new byte[1024];
			DatagramPacket dap = new DatagramPacket(value, value.length);
			while(true){
				das.receive(dap);
				String ip = dap.getAddress().getHostAddress();
				String data = new String(dap.getData(),0,dap.getLength());
				System.out.println(ip + "::" + data);
			}
			
		} catch (Exception e) {
			throw new RuntimeException("接收端异常");
		}
		
	}
}

class SendClient implements Runnable{
	DatagramSocket das;
	public SendClient(DatagramSocket das){
		this.das = das;
	}
	@Override
	public void run() {
		try {
			byte[] value = new byte[1024];
			BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
			String len = null;
			while((len = buf.readLine()) != null){
				if(len.equals("over")){
					break;
				}
				value = len.getBytes();
				//如果想群聊可以把ip地址换成广播地址，接收端地址使用同样的接收端口
				DatagramPacket dap = new DatagramPacket(value, value.length,InetAddress.getByName("192.168.1.106"),10002);
				das.send(dap);
			}
		} catch (Exception e) {
			throw new RuntimeException("发送端异常");
		}
		
	}
	
}


TCP传输
  1. Socket和ServerSocket
  2. 建立客户端和服务器端
  3. 建立连接后，通过Socket中的IO流进行数据的传输
  4. 关闭Socket
  5. 同样，客户端与服务器端是两个独立的应用程序
练习代码：
/**
 * 需求：给服务端发送一个文本数据
 * 步骤：
 * 1.创建Socket服务，并指定要连接的主机和端口
 * @author onlin_000
 *
 */
public class TcpSend {

	public static void main(String[] args) {
		try {
			//创建客户端的socket服务。指定目的主机和端口
			Socket s = new Socket(InetAddress.getByName("192.168.1.106"),10003);
			//为了发送数据，应该获取socket流中的输出流。
			OutputStream os = s.getOutputStream();
			os.write("Hello this is test data!".getBytes());
			s.close();
		} catch (IOException e) {
			throw new RuntimeException("客户端异常");
		}
	}
}
TCP服务端：
/**
 * 需求：定义端点接收数据并打印在控制台上。
 * 服务端：
 * 1.建立服务端的socket服务。ServerSocket(); 并监听一个端口
 * 2.获取连接过来的客户端对象。通过ServerSocket的accept方法。没有连接就会等，所以这个方法是阻塞式的	
 * 3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流，来读取发过来的数据，并打印在控制台上。
 * 4.关闭（可选）
 * @author onlin_000
 *
 */
public class TcpServer {

	public static void main(String[] args) {
		ServerSocket ss = null;
		try {
			ss = new ServerSocket(10003);
			Socket s = ss.accept();
			InputStream ins = s.getInputStream();
			byte[] data = new byte[1024];
			int len = ins.read(data);
			System.out.println(new String(data,0,len));
			//关闭客户端连接
			s.close();
		} catch (Exception e) {
			throw new RuntimeException("服务端异常");
			}finally{
				if(ss != null){
					try {
						ss.close();
					} catch (IOException e1) {
						throw new RuntimeException("服务器关闭失败");
					}
				}
		}
	}
}

练习2：
/**
 * 客户端通过键盘录入用户名。
 * 服务端对这个用户名进行校验。
 * 
 * 如果该用户名存在，在服务器端显示xxx已登录。
 * 并在客户端显示xxx欢迎光临。
 * 
 * 如果该用户不存在，正在服务器端显示xxx尝试登录。
 * 并在客户端显示xxx用户不存在
 * @author onlin_000
 *
 */
public class TcpLoadServer {

	public static void main(String[] args) {
		ServerSocket ss = null;
		try {
			ss = new ServerSocket(10006);
			while(true){
				Socket s = ss.accept();
				new Thread(new LoadServer(s)).start();
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}
class LoadServer implements Runnable{
	Socket s;
	LoadServer( Socket s){
		this.s = s;
	}
	@Override
	public void run() {
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip + "..............connected");
		BufferedReader bufin = null;
		try {
			bufin = new BufferedReader(new FileReader(new File("User.txt")));
			BufferedReader buf = 
					new BufferedReader(new InputStreamReader(s.getInputStream()));
			PrintWriter pw = 
					new PrintWriter(s.getOutputStream(),true);
			for(int i = 0; i < 3; i++){
				boolean flag = false;
				String name = buf.readLine();
				if(name == null)
					return;
				String data = null;
				while((data = bufin.readLine()) != null){
					if(name.equals(data))
						flag = true;
				}
				if(flag){
					System.out.println(name + "登录成功");
					pw.println("欢迎" + name + "登录成功");
				}else{
					System.out.println(name + "尝试登录");
				}
			}
			buf.close();
			pw.close();
			bufin.close();
		} catch (Exception e) {
			throw new RuntimeException(ip + "登录失败");
		}
	}
	
}
发送端：
public class TcpLoadClient {

	public static void main(String[] args) {
		BufferedReader bufin = null;
		try {
			bufin = new BufferedReader( new InputStreamReader(System.in));
			Socket s = new Socket(InetAddress.getByName("192.168.1.111"),10006);
			BufferedReader buf = 
					new BufferedReader(new InputStreamReader(s.getInputStream()));
			PrintWriter pw =
					new PrintWriter(s.getOutputStream(),true);
			String name = null;
			while((name = bufin.readLine())!= null){
				
				if(name.equals("over"))
					return;
				pw.println(name);
				String re = buf.readLine();
				if(re.contains("欢迎"))
					System.out.println(re);
				pw.close();
				buf.close();
				s.close();
			}
		} catch (Exception e) {
			throw new RuntimeException("客户端异常");
		}
	}
}
Tcp练习3：
/**
 * 让多个客户端用户能够同时并发上传文件
 * 那么服务端最好就将每个客户端封装到一个单独的线程中，这样就可以同时处理对个客户端的请求。
 * 
 *如何定义线程呢？
 *只要明确了每一个客户端要在服务端执行的代码。
 * @author onlin_000
 *
 */
public class TcpUploadingByThreadServer {

	public static void main(String[] args) {
		while(true){
			ServerSocket ss = null;
			try {
				ss = new ServerSocket(10006);
				Socket s = ss.accept();
				new Thread(new clientByThread(s)).start();
			} catch (IOException e) {
				throw new RuntimeException("服务器启动失败！");
			}finally{
				try {
					ss.close();
				} catch (IOException e) {
					throw new RuntimeException("服务器关闭失败！");
				}
			}
		}
		
	}
}
class clientByThread implements Runnable{

	Socket s;
	clientByThread(Socket s){
		this.s = s;
	}
	@Override
	public void run() {
		String ip = s.getInetAddress().getHostAddress();
		int count = 0;
		try {
			File file = new File("server\\"+ ip + "(" + count + ")"+".bmp");
			while(file.exists()){
				file = new File("server\\"+ ip + "(" + (++count) + ")"+".bmp");
			}
			FileOutputStream fos = new FileOutputStream(file);
			InputStream ins = s.getInputStream();
			byte[] data = new byte[1024];
			int len = 0;
			while((len = ins.read(data)) != -1){
				fos.write(data,  0, len);
			}
			OutputStream outs = s.getOutputStream();
			outs.write("上传成功！".getBytes());
			fos.close();
			ins.close();
			outs.close();
			s.close();
		} catch (Exception e) {
			throw new RuntimeException(ip +"上传失败!");
		}
	}
客户端：
public class TcpUploadingByThreadClient {

	public static void main(String[] args) {
		try {
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入图片路径,请用\\\\代替\\");
			String path = sc.nextLine();
			sc.close();
			File file = new File(path);
			if(!file.exists()){
				System.out.println("请输入正确的路径");
				return;
			}
			if(!file.getName().endsWith(".bmp")||file.getName().endsWith(".BMP")){
				System.out.println("请选择正确的文件");
				return;
			}
			if(file.length()>1024*1024*5){
				System.out.println("文件太大！");
				return;
			}
			Socket s = new Socket(InetAddress.getByName("192.168.1.111"),10006);
			FileInputStream fis = new FileInputStream(file);
			OutputStream ous = s.getOutputStream();
			byte[] buf =new byte[1024];
			int len = 0;
			while((len = fis.read(buf)) != -1){
				ous.write(buf, 0, len);
			}
			s.shutdownOutput();
			InputStream ins = s.getInputStream();
			int i =ins.read(buf);
			System.out.println(new String(buf,0,i));
			ous.close();
			fis.close();
			s.close();
			ins.close();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

练习3：
TCP上传图片
public class TcpUploadingPiceServer {

	public static void main(String[] args) throws Exception {
		ServerSocket ss = new ServerSocket(10005);
		Socket s = ss.accept();
		FileOutputStream fos = new FileOutputStream(new File("Server.bmp"));
		InputStream ins = s.getInputStream();
		byte[] data = new byte[1024];
		int len = 0;
		while((len = ins.read(data)) != -1){
			fos.write(data,  0, len);
		}
		OutputStream outs = s.getOutputStream();
		outs.write("上传成功！".getBytes());
		fos.close();
		ins.close();
		outs.close();
		s.close();
		ss.close();
		
	}
}
TCP客户端：

/**
 * 上传图片
 * 客户端
 * 1.服务端点
 * 2.读取客户端已有的图片数据。
 * 3.通过socket输出流将数据发给服务端。
 * 4.读取服务端反馈信息。
 * 5.关闭。
 * @author onlin_000
 *
 */
public class TcpUploadingPiceClient {

	public static void main(String[] args) throws Exception {
		Socket s = new Socket(InetAddress.getByName("192.168.1.111"),10005);
		FileInputStream fis = new FileInputStream(new File("test.bmp"));
		OutputStream ous = s.getOutputStream();
		byte[] buf =new byte[1024];
		int len = 0;
		while((len = fis.read(buf)) != -1){
			ous.write(buf, 0, len);
		}
		s.shutdownOutput();
		InputStream ins = s.getInputStream();
		int i =ins.read(buf);
		System.out.println(new String(buf,0,i));
		ous.close();
		fis.close();
		s.close();
		ins.close();
	}
}
TCP练习4：
/**
 * 需求：建立一个文本转换服务器。
 * 客户端给服务端发送文本，服务端会将文本转换成大写载返回给客户端。
 * 而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束	
 * 分析：
 * 客户端：既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
 * 源：键盘录入。
 * 目的：网络设备，网络输出流。
 * 而且操作的是文本数据，可以选择字符流。
 * 步骤：
 * 1.建立服务。
 * 2.获取键盘录入。
 * 3.将数据发给服务端。
 * 4.获取服务端返回的大写数据。
 * 5.结束，关闭资源。
 * 
 * 改例出现的问题。
 * 现象：客户端和服务端都在莫名的等待。
 * 原因：客户端和服务端都有阻塞式的方法。这些方法没有读到结束标记，那么就一直等待，而导致两端都在等待。
 * 现象：第一次能正常运行，第二次报错
 * 原因：使用过的端口没有被释放，第二次再次使用此端口会报错。
 * @author onlin_000
 *
 */
public class TransServer {

	public static void main(String[] args) {
		new Thread(new Server()).start();
		new Thread(new Sender()).start();
	}
}
class Sender implements Runnable{
	
	@Override
	public void run() {
		Socket s = null;
		try {
			s = new Socket(InetAddress.getByName("192.168.1.106"),10008);
			//读取客户端输入的数据
			BufferedReader bufin = 
					new BufferedReader(new InputStreamReader(System.in));
			//用于向流中写入数据
			BufferedWriter buw = 
					new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			//用于读取服务器返回的大写数据
			BufferedReader buf = 
					new BufferedReader(new InputStreamReader(s.getInputStream()));
			String len = null;
			System.out.println("请输入");
			while((len = bufin.readLine()) != null){
				if(len.equals("over")){
					break;
				}
				buw.write(len);
				buw.newLine();
				buw.flush();
				System.out.println(buf.readLine());
			}
		} catch (Exception e) {
			throw new RuntimeException("发送端异常");
		}finally{
			if(s != null){
				try {
					s.close();
				} catch (IOException e) {
					throw new RuntimeException("客户端流关闭异常");
				}
			}
		}
	}
}
class Server implements Runnable{

	@Override
	public void run() {
		ServerSocket ss = null;
		try {
			ss = new ServerSocket(10008);
			Socket s = ss.accept();
			//读取客户端发来的数据
			BufferedReader bur = 
					new BufferedReader(new InputStreamReader(s.getInputStream()));
			//写入处理后的数据
			BufferedWriter buw =
					new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			String len = null;
			while((len = bur.readLine()) != null){
				buw.write(len.toUpperCase());
				buw.newLine();
				buw.flush();
			}
			s.close();
			ss.close();
		} catch (Exception e) {
			throw new RuntimeException("服务端异常");
		}
	}
	
}
浏览器客户端-自定义服务端（severdemo.java) 
public class ServerDemo {

	public static void main(String[] args) {
		ServerSocket ss;
		try {
			ss = new ServerSocket(10010);
			Socket s = ss.accept();
			System.out.println(s.getInetAddress().getHostAddress() + "...............connected");
			PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
			pw.println("<font color = blue size = 5>Hello celient!</font>");
			ss.close();
			s.close();
		} catch (IOException e) {
			throw new RuntimeException("服务端创建失败");
		}
	}
}



自定义浏览器-Tomcat服务器

---------------------- android培训、java培训、期待与您交流！ ---------------------- 
qq_20172629
关注
python编程案例教程答案-Python程序开发案例教程
weixin_37988176的博客
11-01 5207
内容简介Python是近年来最流行的编程语言之一，其清晰的语法和可读性使其成为初学者的完美编码语言，并且深受编程人员的喜好和追捧。本书从入门者角度出发，以简洁有趣、通俗易懂的语言讲解了全新的Python3.x。本书共17章，内容包括Python环境搭建、数字类型与字符串、流程控制、列表与元组、集合和字典、函数、面向对象程序设计、模块开发、文件操作、错误和异常、正则表达式、图形用户界面、进程和线程、...
python神经网络编程 豆瓣,用python构建神经网络
jiefu6666的博客
08-31 920
3、Flask微框架，可以说是Python代码写得最好的项目之一，它的灵活性也是把双刃剑，能使用好Flask框架，即可以做成Pinterest，用不好就是灾难，它是一个微框架，但也可以做成规模化的Flask，加上它可以自由选择自己的数据库交互组件，而且加上celery+redis等异步特性之后，Flask的性能相对Tornado也不相上下，也许Flask的灵活性可能是某些团队更需要的。Theano很好地整合了Numpy，可以直接使用Numpy的Ndarray，使得API接口学习成本大为降低;...
黑马程序员--自学笔记--网络编程
u013085919的专栏
11-24 918
网络编程 -------- android培训、java培训、期待与您交流！ --------- 一.概述 1.定义     计算机网络，是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。而网络编程则是通过使用套接字来达到进程间通信目的的编程。
黑马程序员--网络编程
MR_BLACKLOVELY的博客
06-22 797
------- android培训、java培训、期待与您交流！ ----------
黑马程序员----网络编程
armstrong0825的博客
09-11 398
第一部分:基础知识的学习 概述： 网络模型：OS参考I模型 TCP/IP模型         OSI 应用层 表示层 会话层 传输层 网络层 数据链路层 物理层        TCP/IP 应用层 传输层 网际层 主机至网络层        在每一层往下数据封包 相同层之间可以看层透明传输 常用协议：         传输层TCP UDP         网际层 IP
黑马程序员-网络编程基础知识
u010962965的专栏
06-08 600
ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ 第一节概述 一、网络编程 a)         OSI参考模型 b)        TCP/IP参考模型 二、网络通讯要素 a)         IP地址                         i.              网络中设备的标识
黑马程序员-java基础（九）-网络编程
doubleuuu92的博客
10-25 886
------- android培训、java培训、期待与您交流！ ---------- 网络编程 1 网络编程概述 UDP: 1、将数据及源和目的封装成数据包，不需要建立链接 2、每个数据包的大小限制在64k内 3、因无连接，是不可靠协议，但是速度快 应用于：QQ、FeiQ聊天、在线视频用的都是UDP传输协议。 TCP: 1、建立连接，形成传输数据的通道 2、在连接中进行大量的数据传输 3、通过三次握手（在？在！好）完成链接，是可靠协议 4、必须建立链接，因此效率低 应用于：文件下载
黑马程序员-java语言进阶-11网络编程
笨鸟贤妃的博客
01-13 313
day11【网络编程】 主要内容 软件架构CS／BS 网络通信三要素 TCP通信 Socket套接字 ServerSocket 教学目标 能够辨别UDP和TCP协议特点 能够说出TCP协议下两个常用类名称 能够编写TCP协议下字符串数据传输程序 能够理解TCP协议下文件上传案例 能够理解TCP协议下案例2 第一章 网络编程入门 1.1软件结构 C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。 [外链图片转存失败,源站可能有防盗链机
黑马程序员--Java学习日记之网络编程
Memor_的博客
06-27 850
                                                             ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一、网络编程概述 1、计算机网络 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网
Linux网络编程——黑马程序员笔记
zhuguanlin121的博客
12-09 3176
01P-复习-Linux网络编程 02P-信号量生产者复习 03P-协议 协议： 一组规则。 04P-7层模型和4层模型及代表协议 分层模型结构： OSI七层模型： 物、数、网、传、会、表、应 TCP/IP 4层模型：网（链路层/网络接口层）、网、传、应 应用层：http、ftp、nfs、ssh、telnet。。。 传输层：TCP、UDP 网络层：IP、ICMP、IGMP 链路层：以太网帧协议、ARP 05P-网络传输数据封装流程 网络传输流程： 数据没有封装之前，是不能在网络中传递。
黑马程序员-网络编程篇
xinchi500的博客
09-25 499
网络编程 一、概述 1、网络模型：OSI参考模型和TCP/IP参考模型 2、网络通信三要素：IP地址，端口号，传输协议 A、IP地址         a、它是网络中的设备标识         b、不易记忆，可用主机名表示，两者存在映射关系         c、本机回环地址：127.0.0.1，主机名为：localhost。 IP地址：java中对应的是InetAddress类，存在
Qt学习笔记整理：黑马程序员网课精华
学习笔记可能会包含网络编程的基础知识，以及如何使用Qt进行TCP和UDP通信。 8. 数据库操作：Qt支持与多种数据库的交互，包括SQLite、MySQL等。学习笔记可能会教授如何使用Qt的SQL模块进行数据库的连接、查询、更新...
黑马程序员入学Java知识——精华总结
u014563778的专栏
04-17 3835
黑马程序员入学Java知识——精华总结   J2SE部分，Java高新技术部分，7K面试题部分等黑马入学要求的知识点总结！   一、黑马程序员—java概述与基础知识 6 1、何为编程？ 6 2、Java语言概述，历史、特点 6 3、什么是跨平台性？原理是什么？JVM 7 4、Jre和Jdk的区别? 7 5、java虚拟机JVM 8 6、 Java程序运行机制 8 7
Ubuntu16.04 ROS 深度学习_黑马程序员 智能机器人软件开发 学习路线图出炉
weixin_39577422的博客
11-20 846
智能机器人软件工程师学习计划很多朋友对机器人软件开发和人工智能感兴趣，不知道怎么学习，黑马程序员武汉校区在今年3月份开设了一期智能机器人软件开发工程师就业班， 在这里我把就业班的学习曲线给大家介绍一下!1python基础不管有没有编程基础的童鞋， 都推荐大家先去学Python ，Python像一把瑞士军刀， 你可以用他干很多东西，比如自动回复邮件、自动收集信息。 Python又非常简单容易理解。只...
Java集合中的链表
Y409001的博客
08-08 525
本文详细介绍了Java中LinkedList的实现原理及其应用。首先分析了ArrayList在插入删除操作上的效率问题，引出链表结构的必要性。文章详细讲解了单向链表的基本概念、8种链表结构分类，以及不带头单向链表的具体实现，包括节点定义、接口设计和基本操作方法（增删改查）。重点说明了头插法、尾插法和任意位置插入的实现细节与注意事项。最后提供了9个链表相关的经典面试题及其解决方案，包括链表反转、中间节点查找、回文判断、环检测等。
需求EAV模型的优化与思考
HAN_789的博客
08-06 730
针对EAV（Entity-Attribute-Value）存储模型及Elasticsearch集成需求，以下是详细方案设计和实现建议。
Java中的RabbitMQ完全指南
H1658554092的博客
07-31 1165
Java中的RabbitMQ完全指南
SpringMvc的原理深度剖析及源码解读
gonghua0502的专栏
08-07 758
文章主要讲解了SpringServletContainerInitializer类初始化的过程。拦截器与过滤器区别及应用场景。DispatcherServlet处理流程。控制器初始化涉及文件解析器、本地化解析器等组件配置。适配器模式支持多种handler类型，包括Controller继承、HTTP请求和注解方式。异步实现可通过@Async注解或Callable类，需在配置类中开启异步支持。
【32】C#实战篇——两个文件夹下 相同名字的文件 进行配对（两个文件夹下的文件数量和文件类型不一定相同，所以要过滤掉我们不要的文件）
最新发布
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
08-09 277
该代码实现了一个文件配对功能，用于匹配两个文件夹下具有相同文件名且符合指定后缀条件的CSV文件。通过正则表达式过滤出符合"Wide.csv"、"Tele.csv"或"Mid.csv"后缀的文件，将匹配成功的文件路径分别存储在StandardDataPath和CurrentDataPath两个数组中，保持一一对应关系，并返回匹配成功的文件对数。输入为标准数据和当前数据文件夹路径及后缀过滤条件，输出为匹配的文件路径数组和匹配总数。
RT-Thread网络编程示例：TCP和UDP客户端实现
以上为从文件标题、描述和压缩包文件的名称列表中提取的相关知识点，这些知识点围绕着 RT-Thread 的网络编程，特别是 TCP 和 UDP 客户端的实现。掌握了这些知识，可以为进一步深入研究 RT-Thread 的网络编程打下坚实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值