完成目标：
知识点：
1.IO流_转换流使用
## 转换流_InputStreamReader
1.字节流读取中文在编码一致的情况,也不要边读边看,因为如果字节读不准,读不全,输出的内容有可能会出现乱码
2.所以,我们学了字符流,字符流读取文本文档中的内容如果编码一致,就不会出现乱码问题了
3.但是如果编码不一致,字符流读取文本文档中的内容也有可能出现乱码
1.概述:是字节流通向字符流的桥梁 -> 读数据
2.构造:
InputStreamReader(InputStream in,String charsetName)
charsetName:指定编码,不区分大小写
3.作用:
可以直接指定编码,按照指定的编码去读内容
4.用法:
基本用法和FileReader一样
public class Demo01InputStreamReader {
public static void main(String[] args)throws Exception {
InputStreamReader isr =
new InputStreamReader(new FileInputStream("E:\\Idea\\io\\1.txt"),"gbk");
int data = isr.read();
System.out.println((char)data);
isr.close();
}
}
=========================================================================================
## 转换流_OutputStreamWriter
1.概述:是字符流通向字节流的桥梁
2.构造:
OutputStreamWriter(OutputStream out,String charsetName)
3.作用:
按照指定的编码规则去存数据
4.用法:
和FileWriter一样
public class Demo02OutputStreamWriter {
public static void main(String[] args)throws Exception {
OutputStreamWriter osw =
new OutputStreamWriter(new FileOutputStream("E:\\Idea\\io\\1.txt"),"gbk");
osw.write("你好");
osw.close();
}
}| 知识点 | 核心内容 | 重点 |
| 转换流的作用 | 字节流与字符流之间的桥梁，可指定编码格式读写数据 | 编码不一致会导致乱码问题 |
| InputStreamReader | 字节流通向字符流的桥梁，读取时可指定编码格式 | 构造参数：InputStream和charsetName; 编码名称不区分大小写 |
| OutputStreamWriter | 字符流通向字节流的桥梁，写入时可指定编码格式 | 构造参数：OutputStream和charsetName |
| 编码一致性重要性 | 读写操作必须使用相同编码格式（如UTF-8/GBK） | 实际案例演示UTF-8与ANSI(GBK)互转乱码 |
| FileReader/Writer与转换流关系 | FileReader继承自InputStreamReader，方法用法相同 | 转换流是父类，具备指定编码的核心优势 |
| 编码验证方法 | 通过文件字节数判断编码类型（UTF-8中文3字节/GBK中文2字节） | 文件另存为功能可查看当前编码 |
2.IO流_序列化流和反序列化流
## 一.序列化流和反序列化流介绍
1.作用:读写对象
2.两个对象:
a.ObjectOutputStream -> 序列化流 -> 写对象
b.ObjectInputStream -> 反序列化流 -> 读对象
3.注意:
我们将对象序列化到文件中,我们打开文件看不懂,这就对了,很多时候,我们操作的数据不能随便让别人看懂,不然别人就随意改动了,我们只需要将这些看不懂的内容成功读回来即可
应用场景:比如玩儿游戏会对英雄存档,那么退出的时候英雄变成对象,将人物的属性变成对象的成员变量值,然后存到文件中,再次打开游戏,直接从文件中将这些人物对象读回来,将对象以及对象中的属性还原
=======================================================================================
## 二.序列化流_ObjectOutputStream
1.作用:写对象
2.构造:
ObjectOutputStream(OutputStream out)
3.方法:
writeObject(Object obj) -> 写对象
4.注意:
想要将对象序列化到文件中,被序列化的对象需要实现Serializable接口
public class Person implements Serializable {
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//序列化
private static void write()throws Exception {
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream("module22\\person.txt"));
Person p1 = new Person("涛哥", 12);
oos.writeObject(p1);
oos.close();
}
========================================================================================
## 三.反序列化_ObjectInputStream
1.作用:读对象
2.构造:
ObjectInputStream(InputStream in)
3.方法:
Object readObject()
private static void read()throws Exception {
ObjectInputStream ois =
new ObjectInputStream(new FileInputStream("module22\\person.txt"));
Person person = (Person) ois.readObject();
System.out.println(person);
ois.close();
}| 知识点 | 核心内容 | 易混淆点 |
| 序列化流 | ObjectOutputStream类用于将对象写入文件，实现对象持久化存储 | 序列化与文件普通写入的区别 |
| 反序列化流 | ObjectInputStream类用于从文件读取对象，恢复对象状态 | 反序列化时的类型转换注意事项 |
| Serializable接口 | 被序列化的对象必须实现该标记接口，否则会抛出NotSerializableException | 接口的空实现特性 |
| transient关键字 | 修饰不需要序列化的成员变量，如private transient int age | 与static变量的序列化区别 |
| 应用场景 | 游戏存档保存角色属性（等级/金币等），保证数据持久化 | 序列化数据的安全性问题 |
| 方法对比 | writeObject() vs readObject() | 方法返回值处理差异 |
| 数据安全 | 序列化文件内容不可读是正常现象，防止数据篡改 | 加密与序列化的关系 |
| 开发规范 | JavaBean建议使用包装类而非基本类型 | 自动生成序列化ID的场景 |
3.IO流_序列号冲突问题&循环反序列化问题
## 反序列化时出现的问题以及分析以及解决
问题描述:
序列化之后,修改源码,修改完之后没有重新序列化,直接反序列化了,就会出现了序列号冲突问题:
InvalidClassException
解决:将序列号定死,后面不管怎么修改源码,序列号都是这一个
在被序列化的对象中加上一个public static final long 的变量,并为其赋值
public class Person implements Serializable {
public static final long serialVersionUID = 42L;
private String name;
public Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
> 将一个对象实现一个序列化接口,我们将来才能让这个对象变成二进制,在网络上传输
====================================================================================
## 经验问题
1.问题:循环读取的次数和存储对象的个数不对应,就会出现EOFException
2.解决:(涛哥说一种方式,其他方式也有,同学们都想一下还有什么方式)
public class Demo02Serializable {
public static void main(String[] args) throws Exception {
//write();
read();
}
//反序列化流
private static void read() throws Exception {
ObjectInputStream ois =
new ObjectInputStream(new FileInputStream("module22\\person.txt"));
/* for (int i = 0; i < 4; i++) {
Person person = (Person) ois.readObject();
System.out.println(person);
}*/
//将集合反序列化出来即可
ArrayList<Person> list = (ArrayList<Person>) ois.readObject();
for (Person person : list) {
System.out.println(person);
}
ois.close();
}
//序列化
private static void write() throws Exception {
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream("module22\\person.txt"));
//创建一个集合,存储多个Person对象
ArrayList<Person> list = new ArrayList<>();
Person p1 = new Person("涛哥", 12);
Person p2 = new Person("三上", 30);
Person p3 = new Person("金莲", 24);
//将对象存储到集合中
list.add(p1);
list.add(p2);
list.add(p3);
oos.writeObject(list);
oos.close();
}
}| 知识点 | 核心内容 | 重点 |
| Java序列化机制 | 实现Serializable接口使对象可序列化，编译时自动生成serialVersionUID | 修改类定义后必须重新序列化，否则会导致反序列化失败 |
| serialVersionUID作用 | 用于验证序列化对象的版本兼容性，必须声明为public static final long | 显式声明可避免类修改导致的序列号冲突 |
| InvalidClassException | 当文件中的序列号与class文件不匹配时抛出 | 典型场景：修改源码后未重新序列化直接反序列化 |
| 集合序列化技巧 | 通过序列化集合对象替代单个对象，解决循环次数不确定问题 | 避免出现EOFException的关键方法 |
| EOFException处理 | 文件意外结束异常，由读取次数与对象数量不匹配引发 | 集合序列化方案可彻底规避此问题 |
4.IO流_打印流
# 打印流_PrintStream
## 1.PrintStream打印流基本使用
1.构造:
PrintStream(String fileName)
2.方法:
a.println(): 原样输出,自带换行效果
b.print(): 原样输出,不带换行效果
public class Demo01PrintStream {
public static void main(String[] args)throws Exception{
PrintStream ps = new PrintStream("module22\\printstream.txt");
ps.println("涛哥是一个大帅哥");
ps.println("涛哥是一个小鲜肉");
ps.println("涛哥和金莲不为人知的故事");
ps.close();
}
}
改变流向:
1.什么叫做改变流向:
System.out.println()-> 本身是输出到控制台上
改变流向:可以让输出语句从控制台上输出改变成往指定文件中输出
2.方法:System中的方法:
static void setOut(PrintStream out) -> 改变流向 ->让输出语句从控制台输出转移到指定文件中
public class Demo02PrintStream {
public static void main(String[] args)throws Exception{
PrintStream ps = new PrintStream("module22\\log.txt");
//改变流向
System.setOut(ps);
System.out.println("这个错误是今天下午2点出现的");
System.out.println("这个错误是文件意外到达结尾异常");
System.out.println("出现的原因是循环反序列化次数不对");
ps.close();
}
}
使用场景:
可以将输出的内容以及详细信息放到日志文件中,永久保存
以后我们希望将输出的内容永久保存,但是输出语句会将结果输出到控制台上,控制台是临时显示,如果有新的程序运行,新程序的运行结果会覆盖之前的结果,这样无法达到永久保存,到时候我们想看看之前的运行结果信息就看不到了,所以我们需要将输出的结果保存到日志文件中,就可以使用setOut改变流向
========================================================================================
## 2.PrintStream打印流完成续写
PrintStream(OutputStream out) -> 可以依靠OutputStream的续写功能完成打印流续写
public class Demo03PrintStream {
public static void main(String[] args)throws Exception{
PrintStream ps = new PrintStream(new FileOutputStream("module22\\log.txt",true));
//改变流向
System.setOut(ps);
System.out.println("这个错误是今天下午2点出现的");
System.out.println("这个错误是文件意外到达结尾异常");
System.out.println("出现的原因是循环反序列化次数不对");
ps.close();
}
}| 知识点 | 核心内容 | 重点 |
| 打印流（PrintStream） | System.out.println 本质是调用 PrintStream 对象的 println 方法，System.out 返回 PrintStream 对象 | System.out 的类型是 PrintStream，方法调用链为对象.方法(参数) |
| 打印流构造方法 | 通过 new PrintStream(文件路径) 创建对象， 将内容输出到指定文件 | 需处理 IOException，构造参数为文件路径或 OutputStream |
| 打印流方法 | print()（原样输出不换行）、 println()（原样输出+换行）、 printf()（格式化输出，类似C语言） | println 与 print 的区别在于换行 |
| 改变输出流向 | System.setOut(PrintStream) 将控制台输出重定向到文件（如日志记录） | 应用场景：永久保存日志信息，避免控制台临时显示被覆盖 |
| 打印流续写功能 | 通过 FileOutputStream 构造方法传 true 实现追加写入（new PrintStream(new FileOutputStream(文件, true))） | 依赖 FileOutputStream 的追加模式，而非 PrintStream 原生支持 |
| 日志文件用途 | 保存程序运行详情或异常信息，便于后续排查问题 | 与控制台输出的对比：日志文件可永久存储，控制台为临时显示 |
5.IO流_Properties结合IO流读取配置文件
### Properties结合IO流使用方法
回顾:
1.概述: Properties extends Hashtable
2.特点:
a.无序,无索引
b.key唯一,value可重复
c.线程安全
d.key和value默认类型都是String
3.特有方法:
setProperty(String key,String value) 存键值对
getProperty(String key) -> 根据key获取value
stringPropertyNames()-> 获取所有的key存放到set集合中
load(InputStream in) -> 将流中的数据加载到Properties集合中
public class Demo01Properties {
public static void main(String[] args) {
Properties properties = new Properties();
properties.setProperty("username","root");
properties.setProperty("password","1234");
Set<String> set = properties.stringPropertyNames();
for (String key : set) {
System.out.println(properties.getProperty(key));
}
}
}
使用场景:配合配置文件使用
注意:
将来我们不能将很多的硬数据放到源码中,比如用户名和密码这些数据,因为将来我们有可能换用户名或者密码,如果一换,我们就需要去源码中修改,将来我们的类和类之间都有联系,有可能牵一发动全身,所以我们需要将这些数据提取出来,放到文件中,改的时候直接去文件中改,源码不需要改动
创建配置文件:
1.在模块下右键 -> file -> 取名为xxx.properties
2.在xxx.properties文件中写配置数据
a.key和value都是key=value形式
b.key和value都是String的,但是不要加双引号
c.每个键值对写完之后,需要换行再写下一对
d.键值对之间最好不要有空格(空格可以有,但是不建议写)
e.键值对中建议不要使用中文(中文可以有,但是直接读取会乱码,需要转换流转码)
```properties
jdbc.username=root
jdbc.password=1234
```
public class Demo02Properties {
public static void main(String[] args)throws Exception {
Properties properties = new Properties();
FileInputStream fis = new FileInputStream("module22\\jdbc.properties");
properties.load(fis);
Set<String> set = properties.stringPropertyNames();
for (String key : set) {
System.out.println(key+"..."+properties.getProperty(key));
}
}
}
| 知识点 | 核心内容 | 重点 |
| Properties集合特点 | 继承自HashTable，无序无索引，键唯一值可重复，线程安全，键值默认均为String类型 | 与普通Map集合的区别（特有方法） |
| Properties特有方法 | setProperty()存键值对、getProperty()取value、stringPropertyNames()获取所有键（返回Set） | load()方法需结合IO流使用 |
| 配置文件规范 | 文件扩展名为.properties，格式为key=value（不加引号），禁止中文，键值间无空格 | 与普通文本文件的区别 |
| IO流结合应用 | load(InputStream)方法加载配置数据，实现动态修改配置（如数据库用户名密码） | 文件修改后无需重新编译源码 |
| 工程化优势 | 解耦硬编码数据，降低耦合度，修改配置不影响源代码 | 与直接写在代码中的对比 |
6.IO流_IO流工具类_CommonsIO
| 知识点 | 核心内容 | 重点 |
| Commons IO工具包作用 | 简化IO开发，减少重复代码，支持文件夹递归操作（如复制目录） | 工具包与原生IO的关系（底层原理仍需掌握） |
| 工具类：IOUtils | copy()方法实现文件复制；closeQuietly()自动处理流关闭异常 | closeQuietly()的异常静默处理机制 |
| 工具类：FileUtils | copyDirectoryToDirectory()递归复制文件夹；readFileToString()一键读取文本内容 | 递归复制与单文件复制的性能差异 |
| 第三方库引入 | 需手动添加JAR包（解压class文件到lib目录，右键Add as Library） | Maven依赖管理与手动导入的区别 |
| 开发实践建议 | 实际开发中优先使用工具类，但需理解底层IO流原理 | 工具类封装与源码学习平衡 |
## 一.介绍
IO技术开发中，代码量很大，而且代码的重复率较高。如果我们要遍历目录，拷贝目录就需要使用方法的递归调用，也增大了程序的复杂度。
Apache软件基金会，开发了IO技术的工具类`commonsIO`，大大简化IO开发。
=========================================================================================
## 二.添加第三方jar包
1.Apache软件基金会属于第三方(Oracle公司是第一方,我们自己是第二方,其他的都是第三方),我们使用第三方开发出来的工具,都需要添加第三方提供给我们的jar包
2.jar包:本身是一个压缩包,里面转的都是class文件,我们想使用jar包中的工具类,就需要将相应的jar包解压到我们的当前项目下
3.怎么引入jar包
a.在当前模块下创建文件夹,取名为lib或者libs
b.将准备好的jar包,放到此文件夹下
c.对着jar包,右键 -> add as library (如果我们想将lib下所有的jar包一起解压,我们就直接对着lib文件夹右键)
d.level可以选择module,此时上面叫做name的输入框会变成空的,不用管
e.直接点ok
========================================================================================
## 三.工具包的使用
IOUtils类
- 静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。
- 静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。
public class Demo01IOUtils {
public static void main(String[] args) /*throws Exception*/{
//- 静态方法：IOUtils.copy(InputStream in,OutputStream out)传递字节流，实现文件复制。
//IOUtils.copy(new FileInputStream("E:\\Idea\\io\\8.jpg"),new FileOutputStream("E:\\Idea\\io\\孝敏.jpg"));
//- 静态方法：IOUtils.closeQuietly(任意流对象)悄悄的释放资源，自动处理close()方法抛出的异常。
FileWriter fw = null;
try{
fw = new FileWriter("module22\\commons.txt");
fw.write("你好");
}catch (Exception e){
e.printStackTrace();
}finally {
if (fw!=null){
IOUtils.closeQuietly(fw);
}
}
}
}
FileUtils类
- 静态方法：FileUtils.copyDirectoryToDirectory(File src,File dest);
传递File类型的目录，进行整个目录的复制，自动进行递归遍历。
参数:
src:要复制的文件夹路径
dest:要将文件夹粘贴到哪里去
- 静态方法：writeStringToFile(File file,String str)写字符串到文本文件中。
- 静态方法：String readFileToString(File file)读取文本文件，返回字符串。
public class Demo02FileUtils {
public static void main(String[] args)throws Exception {
/* - 静态方法：FileUtils.copyDirectoryToDirectory(File src,File dest);
传递File类型的目录，进行整个目录的复制，自动进行递归遍历。
参数:
src:要复制的文件夹路径
dest:要将文件夹粘贴到哪里去*/
//FileUtils.copyDirectoryToDirectory(new File("E:\\Idea\\io\\aa"),new File("E:\\Idea\\io\\cc"));
//- 静态方法：writeStringToFile(File file,String str)写字符串到文本文件中。
//FileUtils.writeStringToFile(new File("module22\\commons.txt"),"haha");
//- 静态方法：String readFileToString(File file)读取文本文件，返回字符串。
String s = FileUtils.readFileToString(new File("module22\\commons.txt"));
System.out.println(s);
}
}7.IO流_如何快速记忆IO流对象
| 知识点 | 核心内容 | 重点 |
| IO流基本概念 | 设备间数据传输技术，SE部分主要学习硬盘读写 | 流向判断（输入/输出定义） |
| 输出流分类 | 包含OutputStream/Writer后缀的类： • FileOutputStream; • BufferedWriter; • ObjectOutputStream | 方法共性：write()为主; 特殊方法： - newLine()(BufferedWriter); - writeObject()(ObjectOutputStream) |
| 输入流分类 | 包含InputStream/Reader后缀的类： • FileReader; • BufferedReader; • ObjectInputStream | 方法共性：read()为主; 特殊方法： - readLine()(BufferedReader); - readObject()(ObjectInputStream) |
| 流向记忆技巧 | 内存→硬盘=输出；硬盘→内存=输入 | 方向判断标准：以内存为参照系 |
| 数据类型差异 | 字节流用byte[]；字符流用char[] | 缓冲区选择依据： 文本数据vs二进制数据 |
| 转换流特性 | 构造时指定编码格式 | 编码一致性要求：输入/输出流需匹配 |
8.IO流_小结
9.网络编程_介绍&三要素&三次握手四次挥手
## 1.软件结构
- **C/S结构** ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、红蜘蛛、飞秋等软件。
**B/S结构** ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有IE、谷歌、火狐等。
两种架构各有优势，但是无论哪种架构，都离不开网络的支持。**网络编程**，就是在一定的协议下，实现两台计算机的通信的程序。
========================================================================================
## 2.服务器概念
1.概述:安装了服务器软件的计算机
2.后面马上要见到的服务器软件:tomcat
网络通信协议:两台计算机在做数据交互时要遵守的规则,协议会对数据的格式,速率等进行规定,只有都遵守了这个协议,才能完成数据交互
两台计算机想完成数据交互,需要遵守网络通信协议
========================================================================================
## 3.通信三要素
[IP地址]:计算机的唯一标识,用于两台计算机之间的连接
a.概述:指互联网协议地址（Internet Protocol Address），俗称IP
计算机的唯一标识
b.作用:可用于计算机和计算机之间的连接
c.IPV4
32位的二进制数，通常被分为4个字节，表示成a.b.c.d 的形式，例如192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。
IPV6
为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789->号称能给地球上的每一粒沙子分配一个IP地址
d.查看ip的命令:ipconfig
测试是否能连接其他计算机的命令:ping ip地址
e:特殊的网址:代表的是本机地址,到了哪里都不会变,代表自己
127.0.0.1 -> 固定不变
localhost
localhost(主机名,写的是服务器的IP):端口号/应用名称/资源
localhost:8080/应用名称/index.html
[协议]
TCP:面向连接协议
需要先确认连接,才能进行数据交互
三次握手:
- 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
- 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
- 第三次握手，客户端再次向服务器端发送确认信息，确认连接。
好处:数据安全,能给数据的传输提供一个安全的传输环境
坏处:效率低
UDP:面向无连接协议
好处:效率高
坏处:传输的数据不安全,容易丢失数据包
[端口号]
每一个应用程序的唯一标识
用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。
TCP协议中的三次握手和四次挥手
三次握手:
- 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
- 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
- 第三次握手，客户端再次向服务器端发送确认信息，确认连接。
四次挥手:
- 第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
- 第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
- 第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
- 第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待2MSL后，没有收到，那么彻底断开。| 知识点 | 核心内容 | 重点 |
| 网络编程定义 | 在网络通信协议下不同计算机上运行程序进行数据传输 | 区分网络编程与本地编程的本质差异 |
| 软件架构类型 | CS架构(客户端-服务端) vs BS架构(浏览器-服务端) | CS需要安装客户端/BS直接浏览器访问 |
| CS架构特点 | 客户端存储部分数据减轻服务器压力，但维护需双端更新 | 典型案例：QQ/飞秋等桌面应用 |
| BS架构特点 | 只需维护服务端，数据全在服务器但并发压力大 | 典型案例：电商网站（可通过浏览器直接访问） |
| 服务器定义 | 安装了服务器软件的计算机（如Tomcat） | 区分裸机与服务器的关键差异 |
| 通信三要素 | IP地址（计算机标识）/协议/端口号（应用标识） | 三要素缺一不可的协同关系 |
| IP地址类型 | IPv4（42亿限制） vs IPv6（近乎无限） | 特殊地址127.0.0.1和localhost的永久性 |
| 协议类型 | TCP（三次握手/四次挥手） vs UDP（无连接） | TCP安全但效率低/UDP高效但易丢包 |
| TCP三次握手 | 1.客户端请求→2.服务端确认→3.客户端再确认 | 面试高频考点：连接建立的可靠性机制 |
| TCP四次挥手 | 1.客户端终止→2.服务端响应→3.服务端释放→4.客户端确认 | 断开连接时的完整流程 |
| 端口号作用 | 0-65535范围，前1024为系统保留，标识具体应用程序 | 微信/QQ等应用通过端口号精准定位 |
10.网络编程_UDP编程
## 4.UDP协议编程
```java
1.DatagramSocket -> 好比寄快递找的快递公司
2.DatagramPacket -> 好比快递公司打包
```
### 1.客户端(发送端)
1.创建DatagramSocket对象(快递公司)
a.空参:端口号从可用的端口号中随机一个使用
b.有参:自己指定
2.创建DatagramPacket对象,将数据进行打包
a.要发送的数据-> byte[]
b.指定接收端的IP
c.指定接收端的端口号
3.发送数据
4.释放资源
public class Send {
public static void main(String[] args) throws Exception{
/*1.创建DatagramSocket对象(快递公司)
a.空参:端口号从可用的端口号中随机一个使用
b.有参:自己指定*/
DatagramSocket socket = new DatagramSocket();
/* 2.创建DatagramPacket对象,将数据进行打包
a.要发送的数据-> byte[]
b.指定接收端的IP
c.指定接收端的端口号*/
byte[] bytes = "你好呀".getBytes();
InetAddress ip = InetAddress.getByName("127.0.0.1");
int port = 6666;
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, ip, port);
//3.发送数据
socket.send(dp);
//4.释放资源
socket.close();
}
}
> 直接执行发现,发送端在没有接收端的情况下,不会报错,因为UDP协议是面向无连接协议,不管有没有接收端,照发不误
=========================================================================================
### 2.服务端(接收端)
1.创建DatagramSocket对象,指定服务端的端口号
2.接收数据包
3.解析数据包
4.释放资源
public class Receive {
public static void main(String[] args) throws Exception{
//1.创建DatagramSocket对象,指定服务端的端口号
DatagramSocket socket = new DatagramSocket(6666);
//2.接收数据包
byte[] bytes = new byte[1024];//用于保存接收过来的数据
DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
socket.receive(dp);
//3.解析数据包
byte[] data = dp.getData();//接收的数据
int len = dp.getLength();//从数据包中获取多少个数据
InetAddress address = dp.getAddress();//获取发送端的主机
int port = dp.getPort();//发送端的端口号
System.out.println(new String(data,0,len));
System.out.println(address+"..."+port);
//4.释放资源
socket.close();
}
}| 知识点 | 核心内容 | 易混淆点 |
| UDP协议编程基础 | DatagramSocket类比快递公司， DatagramPacket类比快递包裹 | 面向无连接协议与TCP协议的区别 |
| 发送端实现步骤 | 1. 创建DatagramSocket; 2. 创建DatagramPacket打包数据; 3. 指定接收端IP和端口; 4. 发送数据; 5. 释放资源 | 端口号空参随机分配与指定端口的区别 |
| 接收端实现步骤 | 1. 创建DatagramSocket并绑定端口; 2. 准备接收缓冲区; 3. 接收数据包; 4. 解析数据(内容/长度/发送方IP和端口); 5. 释放资源 | receive()方法会阻塞直到收到数据 |
| UDP协议特性 | 无连接协议：发送端无需确认接收端是否存在 | 与TCP可靠性机制对比 |
| 关键API方法 | send()/receive()数据传输; getAddress()/getPort()获取通信信息; getData()/getLength()解析内容 | 字节数组与字符串转换处理 |
