一、字节
1.1字节输入流(java.io.InputStream)
此抽象类是表示字节输入流的所有类的超类
1.1.1定义了所有子类共性的方法：
int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
void close() 关闭此输入流并释放与流关联的所有系统资源。
java.io.FileInputStream extends InputStream
1.1.2FileInputStream: 文件字节输入流
作用：把硬盘文件中的数据，读取到内存中使用
构造方法：
FileInputStream(String name)
FileInputStream(File file)
参数：读取文件的数据源
String name:文件的路径
File file：文件
构造方法的作用：
1.会创建一个FileInputStream对象
2.会把FileInputStream对象指定的构造方法中要读取的文件
1.1.3读取数据的原理（硬盘 --> 内存）
java程序 --> JVM -->OS -->OS读取数据的方法 --> 读取文件
1.1.4字节输入流的使用步骤：（重点）
1.创建FileInputStream对象，构造方法中绑定要读取的数据源
2.使用FileInputStream对象的方法read，读取文件
3.释放资源
1.1.5字节输入流一次读取多个字节方法
int read(byte[] b) 从输入流中读取一定数量的姐，并将其存储在缓冲区数组b中。
明确两件事情：
1.方法的参数byte[]的作用？
起到缓冲作用，存储每次读取到的多个字节
数组的长度一把定义为1024（1kb）或者1024的整数倍
2.方法的返回值int是什么？
每次读取的有效字节个数
String类的构造方法:
String(byte[] bytes):把字节数组转换为字符串
String(byte[] bytes, int offset , int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
1.2字节输出流(java.io.OutputStream)
此抽象类是表示输出字节流的所有类的超类
1.2.1子类共性的成员方法
public void close() :关闭此输出流并释放与此流相关联的任何系统资源。
public void flush() :刷新此输出流并强制任何缓冲的输出字节被写出
public void write(byte[] b) :将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off , int len) :从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
public abstract void write(int b): 将指定的字节输出流
java.io.FileoutputStream extends OutputStream
1.2.2 FileOutputStream:文件字节输出流
作用：把内存中的数据写入到硬盘的文件中
1.2.3构造方法
FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流
参数：
String name:目的地是一个文件的路径
File file:目的地是一个文件
构造方法的作用：
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
3.会把FileOutputStream对象指向创建好的文件
1.2.4写入数据的原理（内存 --> 硬盘）
java程序 --> JVM（java虚拟机）--> OS（操作系统）--> OS调用写数据的方法 --> 把数据写入到文件中
1.2.5字节输出流的使用步骤（重点）：
1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
2.调用FileOutputStream对象中的方法write,把数据写入到文件中
3.释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提供程序的效率）
二、字符
2.1字符输入流(java.io.Reader)
字符输入流，是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类。
2.1.1共性的成员方法：
int read() 读取单个字符并返回。
int read(char[] cbuf) 一次读取多个字符，将字符读入数组。
void close() 关闭该流并释放与之关联的所有资源。
java.io.FileReader extends InputStreamReader extends Reader
2.1.2 FileReader:文件字符输入流
作用：把硬盘文件中的数据以字符的方式读取到内存中
2.1.3构造方法
FileReader(String fileName)
FileReader(File file)
参数：读取文件的数据源
String fileName:文件的路径
File file:一个文件
FileReader构造方法的作用：
1.创建一个FileReader对象
2.会把FileReader对象指向要读的文件
2.2字符输出流(java.io.Writer)
字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类
2.2.1共性的成员方法：
void write(int c) 写入单个字符
void write(char[] cbuf) 写入字符数组
abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分，off数组的开始索引，len写的字符个数。
void write(String str) 写入字符串
void write(String str, int off, int len) 写入字符串的某一部分，off字符串的开始索引，len写的字符个数。
void flush() 刷新该流的缓冲
void close() 关闭此流，但要先刷新它。
java.io.FileWriter extends OutputStreamWriter extends Writer
2.2.2 FileWriter:文字字符输出流
作用：把内存中字符数据写入到文件中
2.2.3构造方法
FileWrter(File file) 根据给定的File 对象构造一个 FileWriter 对象。
FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。
参数：写入数据的目的地
String fileName:文件的路径
File file:是一个文件
构造方法的作用：
1.会创建一个FileWriter对象
2.会根据构造方法中传递的文件/文件的路径，创建文件、
3.会把FileWriter对象指向创建好的文件
2.3文件字符输出流（FileWriter）
作用：把内存中字符数据写入到文件中
2.3.1构造方法
FileWriter(File file) 根据给定的File 对象构造一个 FileWriter 对象。
FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。
参数：写入数据的目的地
File file:是一个文件
String fileName:文件的路径
构造方法的作用：
1.会创建一个FileWriter对象
2.会根据构造方法中传递的文件/文件的路径，创建文件
3.会把FileWriter对象指向创建好的文件
2.3.2字符输出流的使用步骤（重点）：
1.创建FileWriter 对象，构造方法中绑定要写入数据的目的地
2.使用FileWriter 中的方法write，把数据写入到内存缓冲区中（字符转换为字节的过程）
3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
4.释放资源（会先把内存缓冲区中的数据刷新到文件中）
三、Properties集合
3.1 使用Properties集合存储数据，遍历取出数据
Properties集合是一个双列集合，key和value默认都是字符串
Properties集合有一些操作字符串的特有方法：
Object setProperty(String key, String value) 调用Hashtable 的方法 put
String getProperty(String key) 通过key找到value值，此方法相当于Map集合中的get(key)方法。
Set
package DemoIO;
import java.util.Properties;
import java.util.Set;
public class Demo01Properties {
public static void main(String[] args) {
show01();
}
private static void show01() {
// 创建Properties集合
Properties prop = new Properties();
// 使用serProperty往集合中添加数据
prop.setProperty("赵丽颖","168");
prop.setProperty("迪丽热巴","165");
prop.setProperty("古力娜扎","163");
// 使用stringPropertyName把Properties集合中的键取出，存储到一个set集合中
Set<String> set = prop.stringPropertyNames();
// 遍历set集合，取出Properties集合中的每一个键
for (String s : set) {
System.out.println("名字："+s+"，年龄："+prop.getProperty(s));
/*
*名字：赵丽颖，年龄：168
名字：古力娜扎，年龄：163
名字：迪丽热巴，年龄：165
* */
}
}
}
3.2 store方法
Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储。
void store(OutputStream out , String comments)
void store(Writer writer , String comments)
参数：
OutputStream out :字节输出流，不能写入中文
Writer writer :字符输出流，可以写中文
String comments: 注释 ，用来解释说明保存的文件是做什么用的
不能使用中文，会产生乱码，默认是Unicode编码
一般使用“ ” 空字符串
3.2.1使用步骤
1.创建Properties集合对象，添加数据
2.创建字节输出流/字输出流对象，构造方法中绑定要输出的目的地
3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘存储
4.释放资源
3.3 load方法
作用：把硬盘中保存的文件（键值对），读取到集合中使用。
void load(InputStream inStream)
void load(Reader reader)
参数：
InputStream inStream:字节输入流，不能读取含有中文的键值对
Reader reader:字符输入流，能读取含有中文的键值对
3.3.1使用步骤
1.创建Properties集合对象
2.使用Properties集对象中的方法load读取保存键值对的文件
3.遍历Properties集合
【注意】：
1.存储键值对的文件中，键与值默认的连接符号可以用=，空格（其他符号）
2.存储键值对的文件中，可以使用#进行注释，备注是的键值对不会再被读取
3.存储键值对的文件中，键与值默认都是字符串，不用再加引号
四、缓冲流
java.io.BufferedOutputStream extends OutputStream
4.1 字节缓冲输出流：
BufferedOutputStream
继承自父类的共性方法：（字节输出流的共性方法）
4.1.1 构造方法：
BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out,int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
参数：
OutputStream out：字节输出流
我们可以传递FileOutputStream，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率
int size：指定缓冲流内部缓冲区的大小，不指定默认。
4.1.2使用步骤：（重点）
1.创建FileOutputStream对象，构造方法中绑定要输出的目的地
2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象效率。
3.使用BufferedOutputStream对象中的方法write，把数据西而入到内部缓冲区中
4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区中的数据，刷新到文件中
5.释放资源（会先调用flush方法刷新数据，第4步可以省略）
4.2字节缓冲输入流
java.io.BufferedInputStream extends InputStream
bufferedInputStream:字节缓冲输入流
4.2.1 继承自父类的成员方法：
int read() 从输入流中读取数据的下一个字节。
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
void close() 关闭此输入流并释放与该流关联的所有系统资源。
4.2.2构造方法：
BufferedInputStream(InputStream in) 创建一个BufferedInputStream 并保存其参数 ， 即输入流 in，以便将来使用
BufferedInputStream(InPutStream in,int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流
参数：
InputStream in:字节输入流
我们可以传递 FileInputStream,缓冲流会给FileInputStream对象，提高FileInputStream的读取效率
int szie:指定缓冲流内部缓冲区的大小，不指定默认
使用步骤（重点）：
1.创建FileInputStream对象，构造方法中绑定要读取的数据流
2.创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的读取效率
3.使用BufferedInputStream对象中的方法read，读取文件
4.释放资源
4.3字符缓冲输出流
java.io.BufferedWriter extends Writer
BufferedWriter:字符缓冲输出流
4.3.1继承自父类的共性成员方法： Writer
4.3.2构造方法：
BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out,int sz) 创建一个使用给定大小输出缓冲区的缓冲字符输出流
参数：
Writer out:字符输出流
我们可以传递 FileWriter，缓冲流给FileWriter 增加一个缓冲区，提高FileWriter的写入效率
int sz:指定缓冲区的大小，不写默认大小
4.3.3特有的成员方法：
void newLine() 写入一个行分隔符。会根据不同的操作系统，获取不同的行分隔符
换行：换行符号
windows:\r\n
linux:/n
mac:/r
4.3.4使用步骤：
1.创建字符缓冲输出流对象，构造方法中传递字符输出流
2.调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中
3.调用字符缓冲输出流中的方法flush，把内存缓冲区中的数据，刷新到文件中
4.释放资源
4.4字符缓冲输入流
java.io.BufferedReader extends Reader
4.4.1继承自父类的共性的成员方法：Reader类
4.4.2构造方法：
BufferedReader(Reader in) 创建一个使用默认大小缓冲输入缓冲区的缓冲字符输入流
BufferedReader(Reader in,int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流
参数：
Reader in:字符输入流
我们可以传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率
4.4.3特有的成员方法：
String readLine() 读取一个文本行。读取一行数据
行的终止符号：通过下列字符之一即可认为某行已终止：换行（'\n'）、回车（'\r'）或回车直接跟着换行（\r\n）
返回值：
包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回null
4.4.4使用步骤：
1.创建字符缓冲输入流对象，构造方法中传递字符输入流
2.使用字符缓冲输入流对象的方法read/readLine读取文本
3.释放资源
五、序列化与反序列化
5.1序列化的概念：
把对象以流的方式，写入到文件中保存，叫写对象，也叫对象的序列化
5.1.1 java.io.ObjectOutputStream extends OutputStream
ObjectOutputStream:对象的序列化流
作用：把对象以流的方式写入到文件中保存
5.1.2构造方法：
ObjectOutputStream(OutputStream out) 创建写入指定OutputStream 的ObjectOutputStream
参数：
OutputStream out:字节输出流
5.1.3特有的成员方法：
void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream
5.1.4使用步骤：
1.创建ObjectOutputStream对象，构造方法中传递字节输出流
2.使用ObjectOutputStream对象的方法writeObject，把对象写入到文件中
3.释放资源
5.2反序列化的概念：
把文件中保存的对象，以流的方式读取出来，叫做读对象，也叫对象的反序列化
5.2.1java.io.ObjectInputStream extends InputStream
ObjectInputStream:对象的反序列化流
作用：把文件中保存的对象，以流的方式读取出来使用
5.2.2构造方法：
ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的ObjectInputStream
参数：
InputStream in:字节输入流
5.2.3特有的成员方法：
Object readObject() 从 ObjectInputStream 读取对象
5.2.4使用步骤：
1.创建 objectInputStream对象，构造方法中传递字节输入流
2.使用objectInputStream对象中的方法readObject读取保存对象的文件
3.释放资源
4.使用读取出来的对象(打印)
5.3 NotSerizalizableException:没有序列异常
引出：序列化和反序列化的时候，会抛出NotSerizalizableException没有序列化异常
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法 使其任何状态序列化或反序列化
Serializable接口也叫标记型接口：
要进行序列化和反序列化的类必须实现 Serializable 接口，就会给类添加一个标记
当我们进行序列化和反序列化的时候，就会检测类上是否有这个标记
有：就可以序列化和反序列化
没有：就会抛出NotSerizalizableException 异常
例如：菜市场卖肉 --> 肉上有蓝色章(检测合格) --> 放心购买 --> 买回来怎么吃随意
六、网络编程
6.1 TCP通信的客户端
TCP的客户端：像服务器发送连接请求，给服务器发送数据，读取服务器回写的数据
6.1.1表示客户端的类
java.net.Socket 此类实现客户端套接字（也可以称为“套接字”）。套接字是两台机器键通信的端点。
套接字：包含了IP地址和端口号的网络单位
6.1.2构造方法
Socket(String host, int port) 创建一个流套接字并将其连接到指定主机上的指定端口号。
参数：
String host :服务器主机的名称/服务器的IP地址
int port :服务器的端口号
6.1.3成员方法
OutputStream getOutputStream() 返回此套接字的输出流
InputStream getInputStream 返回此套接字的输入流
void close() 关闭此套接字
6.1.4实现步骤
1.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口
2.使用Socket对象的方法getOutputStream()获取网络字节输出流OutputStream对象
3.使用网路字节输出流OutputStream对象中的方法write，给服务器发送数据
4.使用Socket独享中的方法getInputStream()获取网络字节输入流InputStream对象
5.使用网络字节输入流InputStream对象中的方法read，读取服务器会写的数据
6.释放资源(Socket)
6.1.5注意
1.客户端和服务器进行交互，必须使用Socket中提供的网络流，不能使用自己创建的流对象
2.当我们创建客户端对象Socket的时候，就回去请求服务器和服务器经过3次握手建立连接通路
这时如果服务器没有启动，那么就会抛出异常
如果服务器已经打开，那么就可以进行交互了
6.1.6 代码
package DemoSocket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) throws IOException {
// 1.创建一个客户端对象Socket，构造方法绑定服务器的IP地址和端口号
Socket socket = new Socket("127.0.0.1",8888);
// 2.使用Socket对象的方法getOutputStream()获取网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
// 3.使用网路字节输出流OutputStream对象中的方法write，给服务器发送数据
outputStream.write("你好服务器".getBytes());
// 4.使用Socket独享中的方法getInputStream()获取网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
// 5.使用网络字节输入流InputStream对象中的方法read，读取服务器会写的数据
byte[] bytes = new byte[1024];
int len = inputStream.read(bytes);
System.out.println(new String(bytes,0,len));
// 6.释放资源(Socket)
socket.close();
}
}
6.2 TCP通信的服务器端
TCP通信的服务器端：接收客户端的请求，读取客户端发送的数据，给客户端回写数据
6.2.1表示服务器的类
java.net.ServerSocket:此类实现服务器套接字。
6.2.2构造方法
ServerSocket(int port) 创建绑定到特定端口的服务器套接字
服务器端必须明确一件事情，必须知道是哪个客户端请求的服务器
所以可以使用accept()方法获取到请求客户端对象Socket
6.2.3成员方法
Socket accept() 侦听并接受到此套接字的连接。
6.2.4服务器的实现步骤
1.创建服务器ServerSocket对象和系统指定的端口号
2.使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
4.使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
5.使用Socket对象的方法getOutputStream()获取网络字节输出流OutputStream对象
6.使用网路字节输出流OutputStream对象中的方法write，给客户端的回写数据
7.释放资源（Socket, ServerSocket）
6.2.5 代码
package DemoSocket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServer {
public static void main(String[] args) throws IOException {
// 1.创建服务器ServerSocket对象和系统指定的端口号
ServerSocket serverSocket = new ServerSocket(8888);
// 2.使用ServerSocket对象中的方法accept，获取到请求的客户端对象Socket
Socket socket = serverSocket.accept();
// 3.使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
// 4.使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
byte[] bytes = new byte[1024];
int len = inputStream.read(bytes);
System.out.println(new String(bytes,0,len));
// 5.使用Socket对象的方法getOutputStream()获取网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
// 6.使用网路字节输出流OutputStream对象中的方法write，给客户端的回写数据
outputStream.write("收到，谢谢".getBytes());
// 7.释放资源（Socket, ServerSocket）
socket.close();
serverSocket.close();
}
}
6.3文件上传案例
原理：
6.3.1文件上传案例的客户端
读取本地文件，上传到服务器，读取服务器回写的数据
明确：
数据源：e:\荷塘.jpg
目的地：服务器
实现步骤：
1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
4.使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
5.使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
6.使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
7.使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
8.释放资源(FileInputStream,Socket)
代码：
package UploadSocketDemo;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class TCPClient {
public static void main(String[] args) throws IOException {
// 1.创建一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
FileInputStream file = new FileInputStream("E:\\photos\\bizhi\\荷塘.jpg");
// 2.创建一个客户端Socket对象，构造方法中绑定服务器的IP地址和端口号
Socket socket = new Socket("127.0.0.1",8888);
// 3.使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
// 4.使用本地字节输入流FileInputStream对象中的方法read，读取本地文件
int len = 0;
byte[] bytes = new byte[1024];
while((len = file.read(bytes))!=-1){
// 5.使用网络字节输出流OutputStream对象中的方法write，把读取到的文件上传到服务器
outputStream.write(bytes,0,len);
}
/*
* 解决：上传完文件，给服务器协议个结束标记
* void shutdownOutput() 禁用此套接字的输出流
* 对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列
* */
socket.shutdownOutput();
// 6.使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
// 7.使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
while((len = inputStream.read(bytes))!=-1){
System.out.println(new String(bytes,0,len));
}
// 8.释放资源(FileInputStream,Socket)
file.close();
socket.close();
}
}
6.3.2文件上传案例的服务器端
读取客户端上传的文件，保存到服务器的硬盘，给客户端回写“上传成功”
明确：
数据源：客户端上传的文件
目的地：服务器的硬盘 d:\upload\荷塘.jpg
实现步骤：
1.创建一个服务器ServerSocket对象，和系统要指定的端口号
2.使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
3.使用Socket独享中的方法getInputStream，获取到网络字节输入流InputStream对象
4.判断e:\upload文件夹是否存在，不存在则创建
5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
7.使用本地的字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
8.使用Socket独享中的方法getOutputStream，获取到网络字节输出流OutputStream对象
9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
10.释放资源（FileOutputStream,Socket,ServerSocket）
代码：
package UploadSocketDemo;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;
public class TCPServer {
public static void main(String[] args) throws IOException {
// 1.创建一个服务器ServerSocket对象，和系统要指定的端口号
ServerSocket server = new ServerSocket(8888);
// 2.使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
/*
* 让服务器一直处于监听状态（死循环accept方法）
* 有一个客户端上传文件，就保存一个文件
* */
while (true) {
Socket socket = server.accept();
// /*
// * 使用多线程技术，提高程序的效率
// * 有一个客户端上传文件，就开启一个线程，完成文件的上传
// * */
// new Thread(new Runnable() {
//// 完成文件的上传
// @Override
// public void run() {
//
// }
// }).start();
// 3.使用Socket独享中的方法getInputStream，获取到网络字节输入流InputStream对象
InputStream inputStream = socket.getInputStream();
// 4.判断e:\\upload文件夹是否存在，不存在则创建
File file = new File("e:\\upload");
if (!file.exists()) {
file.mkdir();
}
/*
自定义一个文件的命名规则：防止同名的文件被覆盖
规则：域名+毫秒值+随机数
*/
String fileName = "king" + System.currentTimeMillis() + new Random().nextInt(99999999) + ".jpg";
// 5.创建一个本地字节输出流FileOutputStream对象，构造方法中绑定要输出的目的地
FileOutputStream fileOutputStream = new FileOutputStream(file + "\\" + fileName);
// 6.使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
int len = 0;
byte[] bytes = new byte[1024];
while ((len = inputStream.read(bytes)) != -1) {
//7.使用本地的字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
fileOutputStream.write(bytes, 0, len);
}
// 8.使用Socket独享中的方法getOutputStream，获取到网络字节输出流OutputStream对象
OutputStream outputStream = socket.getOutputStream();
// 9.使用网络字节输出流OutputStream对象中的方法write，给客户端回写“上传成功”
outputStream.write("上传成功".getBytes());
// 10.释放资源（FileOutputStream,Socket,ServerSocket）
fileOutputStream.close();
socket.close();
}
// server.close();
}
}