一、网络通信概念
实现不同计算机上进行数据传输的程序。
1.1 网络通信三要素
1、确定发给哪个接收端（IP地址）
2、确定发给接收端中的哪个应用程序（端口号）
3、确定网络中传输数据的规则（协议）
1.1.1 IP地址的介绍
IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。
IP地址是设备在网络中的地址，是唯一的标识。
假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”
IPv4：是一个32位的二进制数，通常被分为4个字节，表示成 a.b.c.d 的形式，例如 192.168.65.100。其中
a、 b、 c、 d都是0~255之间的十进制整数，那么最多可以表示42亿个。
IPv6：由于互联网的蓬勃发展， IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。有资料显示，全球IPv4地址在2011年2月分配完毕。
IPv6：为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制
数，表示成 ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，
这样就解决了网络地址资源数量不够的问题。
- 查看本机IP地址
➢ 在DOS命令行输入: ipconfig
检查网络是否连通
➢ 在DOS命令行输入: ping IP地址
特殊IP地址
➢ 127.0.0.1：是回送地址也称本地回环地址，可以代表本机的IP地址，一般用来测试使用
1.1.2 端口号的介绍
端口号：应用程序在设备中唯一的标识。
端口号：用两个字节表示的整数，它的取值范围是0~65535。其中0~1023之间的端口号用于一些知名的网络服务或者应用。我们自己使用1024以上的端口号就可以了。
注意：一个端口号只能被一个应用程序使用
1.1.3 协议介绍
协议：计算机网络中，连接和通信的规则被称为网络通信协议
UDP协议: 用户数据报协议(User Datagram Protocol)
➢不需要连接
➢速度快
➢有大小限制一次最多发送64K
➢易丢失数据。
TCP协议: 传输控制协议 (Transmission Control Protocol)
➢需要连接
➢速度慢
➢没有大小限制
➢不易丢失数据
二、UDP通信程序
2.1 InetAddress使用
为了方便我们对IP地址的获取和操作， Java提供了一个类InetAddress供我们使用，InetAddress：此类表示Internet协议（IP）地址
static InetAddress getLocalhost() |
静态方法，获取本机的IP地址对象 |
static InetAddress getByName(String host) |
静态方法，通过主机名或IP地址得到InetAddress对象 |
String getHostName() |
获取此IP地址的主机名 |
String getHostAddress() |
返回IP地址字符串 |
*
目标:学习InetAddress类的使用
小结:
1.InetAddress的作用?
表示IP地址
2.如何得到InetAddress对象?
static InetAddress getLocalHost() ：获取本机的IP地址对象
static InetAddress getByName(String host) ：通过 IP地址/主机名/域名, 获取IP地址对象
3.InetAddress类中的方法
String getHostName(): 获取主机名
String getHostAddress() ：返回IP地址字符串
*/
public class Demo1 {
public static void main(String[] args) throws UnknownHostException {
//获取本机的IP地址对象
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost); //dee/10.254.3.50
System.out.println("主机名"+localHost.getHostName());
System.out.println("主机IP地址："+localHost.getHostAddress());
//通过 IP地址/主机名/域名, 获取IP地址对象
InetAddress ip1 = InetAddress.getByName("www.baidu.com");
System.out.println(ip1); //www.baidu.com/182.61.200.6
InetAddress ip2 = InetAddress.getByName("192.168.90.102");
System.out.println(ip2);//192.168.90.102
}
}
2.2 UDP的介绍
UDP协议通信是不需要连接的，相当于我们生活中的寄快递，直接寄出即可。 
实现流程
- 发送数据
DatagramSocket
- 此类表示用于发送和接收数据报数据包的套接字。数据报套接字是分组传送服务的发送或接收点。在数据报套接字上发送或接收的每个数据包都被单独寻址和路由。从一个机器发送到另一个机器的多个分组可以不同地路由，并且可以以任何顺序到达。在可能的情况下，新构建的DatagramSocket启用了SO_BROADCAST套接字选项，以允许传输广播数据报。为了接收广播数据包，DatagramSocket应该绑定到通配符地址。在一些实现中，当DatagramSocket绑定到更具体的地址时，也可以接收广播分组。
DatagramPacket发送数据的构造方法：
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)
*
目标：编写UDP发送端
发送数据的步骤：
1.创建发送端。 DatagramSocket s = new DatagramSocket();
2.创建数据包，并指定IP和端口。DatagramPacket
3.发送数据。send(DatagramPacket p)方法
4.关闭资源。
DatagramPacket发送数据的构造方法：
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)
buf ：要发送的字节数据
offset：从数组的哪个位置开始发送
length：发送数据的长度
address：接收端的IP
port：接收端的端口号
*/
import java.io.IOException;
import java.net.*;
//数据发送端
public class UDPSender {
public static void main(String[] args) throws IOException {
//1.创建发送端
DatagramSocket socket = new DatagramSocket();
//2.创建数据包，并指定IP和端口
//DatagramPacket(发送数据, 开始索引, 长度, ip对象, 端口)
byte[] bytes = "你好".getBytes();
//定义IP
InetAddress ip = InetAddress.getByName("127.0.0.1");//发送给自己
DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length,ip,12345);
//3.发送数据
socket.send(packet);
//4.关闭资源。
socket.close();
System.out.println("发送成功");
}
}
- 接收数据
DatagramPacket接收数据的构造方法：
DatagramPacket(byte[] buf, int length)
*
目标：编写UDP接收端
接收数据的步骤：
1.创建接收端。 DatagramSocket s = new DatagramSocket(int port);
2.创建空的数据包，用于装数据。DatagramPacket
3.接收数据。receive(DatagramPacket p)方法
4.解析数据。（从数组中获取有效内容）
5.关闭资源。close
DatagramPacket接收数据的构造方法：
DatagramPacket(byte[] buf, int length)
buf: 用来保存接收到的数据
length: 指定接收数据的长度
*/
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
//数据接收端
public class UDPReceiver {
public static void main(String[] args) throws IOException {
System.out.println("启动接收端");
//1.创建接收端（需要设置一个端口）
DatagramSocket socket = new DatagramSocket(6666);
// 2.创建空的数据包，用于装数据
//DatagramPacket(新建的字节数组, 数组的长度)
byte[] array = new byte[1024];
//用于装数据的
DatagramPacket packet = new DatagramPacket(array,array.length);
//3.接收数据（等待）
socket.receive(packet);
//4.解析数据。（从数组中获取有效内容的长度）
int length = packet.getLength();
//输出接收到的内容
System.out.println( "收到的消息："+new String(array,0,length) );
//5.关闭资源。close
socket.close();
}
}
三、TCP通信
3.1 Tcp通信原理
3.1.1 TCP通信原理
传输控制协议 (Transmission Control Protocol)
TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象。
通信之前要保证连接已经建立。 (TCP三次握手)
通过Socket产生IO流来进行网络通信。 
3.2 Tcp通信流程
常用API
客户端
Socket socket = new Socket("127.0.0.1",6666); |
socket.shutdownOutput(); //结束标记，相当于returen -1 |
服务端
ServerSocket ss = new ServerSocket(6666); |
Socket socket = ss.accept(); |
//input和output |
客户端Socket中getInputStream和getOutputStream
- 可以转变为转换流 new InputStreamRead（ InputStream ）
- 转换流可以转变为字符流： new BufferRead （Read ）
- 可以直接变为打印流 new PrintStream （InputStream）
——详细可以常考作业。
3.2.1 Tcp客户端步骤
TCP客户端步骤
1. 创建客户端Socke对象，与指定服务端连接
Socket(String host, int port)
2. 得到输出流写数据
OutputStream getOutputStream()
3. 得到输入流读取数据
InputStream getInputStream()
4. 关闭资源
void close()
/*
目标：编写TCP客户端程序
步骤：
1. 创建客户端Socke对象，与指定服务端连接
Socket(String host, int port)
host ：服务端IP地址
port ：服务端端口号
2. 得到输出流写数据
OutputStream getOutputStream()
3. 得到输入流读取数据
InputStream getInputStream()
4. 关闭资源
void close()
*/
//客户端
public class TCPClient {
public static void main(String[] args) throws IOException {
//1.创建客户端Socke对象，与指定服务端连接
//指定要连接的ip，端口
Socket socket = new Socket("127.0.0.1",6666);
//2. 得到输出流发送消息
OutputStream out = socket.getOutputStream();
out.write("你好".getBytes());
//给出结束标记，相当于写出-1的标记
socket.shutdownOutput();
//3. 得到输入流读取回复信息
InputStream in = socket.getInputStream();
byte[] bys = new byte[1024];
int len = in.read(bys); //等待服务端消息
System.out.println("服务端回复："+new String(bys,0,len));
// 4. 关闭资源
socket.close();
}
}
3.2.2 Tcp服务端步骤
1. 创建TCP服务端ServerSocket对象。
ServerSocket(int port)
2. 监听客户端的连接，连接成功返回一个Socket对象。
Socket accept()
3.得到输入流读取数据。
InputStream getInputStream()
4.得到输出流写数据。
OutputStream getOutputStream()
5.关闭资源
void close()
/*
目标：编写TCP服务端程序
步骤：
1. 创建TCP服务端ServerSocket对象。
ServerSocket(int port)
2. 监听客户端的连接，连接成功返回一个Socket对象。
Socket accept()
3.得到输入流读取数据。
InputStream getInputStream()
4.得到输出流写数据。
OutputStream getOutputStream()
5.关闭资源
void close()
*/
//服务端
public class TCPServer {
public static void main(String[] args) throws IOException {
System.out.println("服务端启动");
//1. 创建TCP服务端ServerSocket对象
ServerSocket ss = new ServerSocket(6666);
//2. 监听客户端的连接，连接成功返回一个Socket对象。
Socket socket = ss.accept();
//3.得到输入流读取数据。
InputStream in = socket.getInputStream();
byte[] bys = new byte[1024];
int len ;
while ((len=in.read(bys))!=-1){
System.out.println("客户端消息："+new String(bys,0,len));
}
//4.得到输出流写数据。
OutputStream out = socket.getOutputStream();
out.write("大家好".getBytes());
//5.关闭资源
socket.close();//关闭对应的客户端连接
ss.close(); //关闭服务，通常不关闭
}
}
3.3 文件上传案例
- TCP通信
- 解决文件重名——UUID
//生成随机的不重复的文件名
String id = UUID.randomUUID().toString();
String name = id + ".jpg";
fos = new FileOutputStream("t_day12\\upload\\" + name);
- 支持多人上传——while循环（注意循环的位置）
多次接收
1.创建ServerSocket服务端
whlie(true){
2.监听客户端连接
3.获取Socket输入流，用于接收客户端文件
4.创建文件输出流，循环读写数据
5.获取Socket输出流，向客户端写出上传结果
6.关闭资源
}
- 支持多人“同时上传”——线程，线程池
客户端
socket.shutdownOutput();
该方法用于在循环写入文件时候（getInputStream），要通知服务关闭，否则会保持：connection reset
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
//客户端
public class UploadClient {
public static void main(String[] args) throws IOException {
//1.创建Socket客户端
Socket socket = new Socket("127.0.0.1",8888);
OutputStream out = socket.getOutputStream();
//2.创建输入流读取文件(从磁盘去读取)
FileInputStream fis = new FileInputStream("D:\\MyTest\\test.jpg");
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys))!=-1){
//写到服务器
out.write(bys,0,len);
}
//重要！！！（告诉服务器，文件传输完毕）,文件写的时候需要shutDownOutPut
socket.shutdownOutput();
System.out.println("传输完成");
//接收服务器响应信息
InputStream in = socket.getInputStream();
len = in.read(bys);
System.out.println("服务器回复："+new String(bys,0,len));
//5.关闭资源
in.close();
fis.close();
out.close();
socket.close();
}
}
服务端
//服务端
public class UploadServer {
public static void main(String[] args) throws IOException {
System.out.println("服务端启动");
//1.创建ServerSocket服务端
ServerSocket ss = new ServerSocket(8888);
//创建线程池
ExecutorService pool = Executors.newFixedThreadPool(30);
//2.监听客户端连接，一个客户端对应一个socket
while (true) {
//循环等待客户的连接
Socket socket = ss.accept();
//启动线程，处理文件传输任务，一个用户对应一个socket
//缺陷：每个用户创建一个线程，开销大，性能较低
//UploadThread thread = new UploadThread(socket);
//thread.start();
pool.submit(new UploadRunnable(socket));
}
}
}
线程池
- 利用try-catch可以捕捉异常
- 使用UUID生成不重复文件名
public class UploadRunnable implements Runnable {
private Socket socket;
public UploadRunnable(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
System.out.println("用户连接：" + socket.getInetAddress());
FileOutputStream fos = null;
OutputStream out = null;
InputStream in = null;
try {
//3.获取Socket输入流，用于接收客户端文件
in = socket.getInputStream();
//4.创建文件输出流，循环读写数据
//生成随机的不重复的文件名
String id = UUID.randomUUID().toString();
String name = id + ".jpg";
fos = new FileOutputStream("t_day12\\upload\\" + name);
byte[] bys = new byte[1024];
int len;
while ((len = in.read(bys)) != -1) {
//保存到服务器
fos.write(bys, 0, len);
}
System.out.println("保存成功");
//回复消息
out = socket.getOutputStream();
out.write("图片上传成功".getBytes());
} catch (Exception e) {
System.out.println("未知错误");
} finally {
//6.关闭资源
try {
out.close();
fos.close();
in.close();
socket.close();
} catch (Exception e) {
System.out.println("未知错误");
}
}
}
}
四、模拟B\S服务器
B/S结构（Browser/Server，浏览器/服务器模式），是WEB兴起后的一种网络结构模式，WEB浏览器是客户端最主要的应用软件。这种模式统一了客户端，将系统功能实现的核心部分集中到服务器上，简化了系统的开发、维护和使用。客户机上只要安装一个浏览器，如Chrome、Safari、Microsoft Edge、Netscape Navigator或Internet Explorer，服务器安装SQL Server、Oracle、MYSQL等数据库。浏览器通过Web Server 同数据库进行数据交互
4.1 B\S服务器
客户端变为——浏览器！
/*
目标:模拟网站服务器
网站服务器的核心?
网站服务器底层使用TCP服务端,浏览器访问服务器,服务器就给浏览器返回数据
原理：
1.浏览器 (TCP客户端)
在浏览器的地址栏中输入: http://服务器域名或IP:端口号
我们现在输入: http://192.168.90.110:8888
http:// 是超文本传输协议,可以传输文字图片,视频等等资源
127.0.0.1: 服务器的IP地址（访问本机自己）
8888: 服务器的端口号
2.服务器 (TCP服务端)
网站服务器相当于TCP服务端，网站服务器要将数据传输给浏览器，本质就是TCP传输数据。
*/
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class WebServer {
public static void main(String[] args) throws IOException {
System.out.println("服务器启动");
//创建服务端，绑定端口
ServerSocket ss = new ServerSocket(8888);
while (true) {
//获取和客户端的连接
Socket socket = ss.accept();
OutputStream out = socket.getOutputStream();
//封装响应头格式
out.write("HTTP/1.1 200 OK\r\n".getBytes());
out.write("Content-Type:text/html\r\n".getBytes());
out.write("\r\n".getBytes());
FileInputStream fis = new FileInputStream("t_day12\\web\\index.html");
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys))!=-1){
//写到客户端（浏览器）
out.write(bys,0,len);
}
fis.close();
out.close();
socket.close();
}
}
}
五、NIO
非阻塞系统是指在不能立刻得到调用结果之前，函数不会阻塞当前线程，而会立刻返回的I/O系统。
5.1 NIO概述
JDK1.4以前:InputStream/OutputStream称为BIO(Blocking IO) 阻塞式IO BIO
JDK1.4推出了一套新的IO体系称为NIO (New IO/ Not Blocking IO) 非阻塞式IO
阻塞,非阻塞概念
阻塞和非阻塞都是处理IO数据的方式
阻塞：如果没有数据就一直等待
（如TCP通信中的：Socket read（）、write（）和 SocketSever accept（））
非阻塞：如果没有数据,不会一直等待,可以做其他事情
非阻塞的好处，不需要一直等待，当有数据来才需要处理，没有数据可以做其他操作
5.2 BIO模型
BIO阻塞
BIO是同步阻塞模型，一个客户端连接对应一个处理线程。
在BIO中，accept和read方法都是阻塞操作，如果没有连接请求， accept方法阻塞；如果无数据可读取， read方法阻塞。
如：BIO的网络模型中创建的BS模型，当客户端首先得和浏览器进行连接：如果连续不上则会导致堵塞（三次握手）中的serverSocket中的accpet方法（一般只要在客户端中new 一个socket）；还有当传送数据时候，如果客户端发送的数据庞大，服务端中没有读取到数据时候，比如说10个G，只要服务端没有读取到数据：（输入流中的read）那么也会堵塞。当其他的客户端访问时候，也会堵塞。
5.3 NIO模型
5.3.1 NIO 3个角色
Buffer缓存
用于存储数据，底层基于数组实现，针对8种基本类型提供了对应的缓冲区类。
Buffer相当于之前BIO的byte[]，但效率更高，功能更强大。
Channel通道
用于进行数据传输，面向缓冲区进行操作，支持双向传输。
数据可以从Channel读取到Buffer中，也可以从Buffer写到Channel中。
Selector选择器
Selector也叫多路复用器，使用一个线程高效地管理多个Channel（即多个客户连接）。当向一个Selector中注册Channel后， Selector内部就可以自动不断地查询这些注册的Channel是否有已就绪的 I/O 事件。当某个Channel上面发生了读或写事件，这个Channel就会被Selector监听到，然后通过SelectionKeys可以获取就绪Channel的集合，进行后续的I/O操作。
5.3.2 NIO特点
- BIO以流的方式处理数据， BIO的流是单向的，读取数据和写出数据的流是不同的。
- NIO
1）Channel（通道）可以双向传输数据。
2）Buffer（缓冲区） 可以保存要发送和接收的各种数据，操作灵活，效率较高
3）Selector 选择器(相等于门卫大爷),可以管理多个连接使用了多路复用，只需要一个线程就可以处理多个通道，降低内存占用率，减少CPU切换时间，在高并发、高频段业务环境下有非常重要的优势 。
5.3.3 NIO的实现
/*
NIO客户端：
1.创建客户端,连接服务器
2.通过通道发数据
3.关闭资源
*/
public class Client1 {
public static void main(String[] args) throws IOException {
// 1.创建客户端，连接服务器，相当于Socket s = new Socket("127.0.0.1", 6666)
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("127.0.0.1", 6666));
// 2.创建缓冲数组，并存储数据，相当于new byte[]数组
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("你好,我是客户端1".getBytes());
buffer.flip();//根据数据长度切换成写模式
//3.往通道写出数据到服务器，相当于 socket.getOutputStream().write()
socketChannel.write(buffer);
//4.关闭资源
socketChannel.close();
System.out.println("客户端1发送完毕");
}
}
package _09扩展NIO.heima02_NIO多路复用;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
/*
NIO服务端：
1.使用Selector多路复用器，监听每个客户端的请求事件。
2.服务端不会阻塞等待某个客户端。
NIO 有对应的框架netty
tomcat服务器底层也是NIO
*/
public class Server {
public static void main(String[] args) throws Exception {
System.out.println("服务端启动");
// 创建服务端，相当于 ServerSocket ss = new ServerSocket(6666);
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(6666));
// 设置为非阻塞式
serverChannel.configureBlocking(false);
// 创建选择器
Selector selector = Selector.open();
// 将通道注册到选择器上，监听客户端的连接事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
//选择器阻塞等待，直到有客户请求
selector.select();
// 获取所有注册到选择器的客户端请求（连接，读写等事件）
Set<SelectionKey> selectionKeys = selector.selectedKeys();
//遍历取出每个SelectionKey，处理客户端请求
Iterator<SelectionKey> itr = selectionKeys.iterator();
while (itr.hasNext()) {
SelectionKey key = itr.next();
//处理客户端请求
process(key, selector);
//请求事件处理完之后需要删除，否则会重复获取
itr.remove();
}
}
}
//解析客户端请求的方法
private static void process(SelectionKey key, Selector selector) throws Exception {
if (key.isAcceptable()) { //有客户端接入
ServerSocketChannel server = (ServerSocketChannel) key.channel();
//获取连接进来的客户端通道
SocketChannel socketChannel = server.accept(); //非阻塞
System.out.println("有客户端访问：" + socketChannel);
//设置为非阻塞
socketChannel.configureBlocking(false);
//监听是否有客户端的数据可以读取
socketChannel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {//有可读数据
SocketChannel socket = (SocketChannel) key.channel();
//创建Buffer缓存，用于接收数据
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 读取客户端通道过来的数据，存到Buffer缓存
int len ;
while ((len=socket.read(buffer))>0) {
System.out.println("服务端收到: " + new String(buffer.array(), 0, len));
buffer.clear();
}
}
}
}
六、commons-io工具包
commons-io是apache开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发的效率。
commons-io工具包提供了很多有关io操作的类。有两个主要的类FileUtils, IOUtils
需要导入commons-jar包
String readFileToString(File file, String encoding) |
读取文件中的数据, 返回字符串 |
void copyFile(File srcFile, File destFile) |
复制文件 |
void copyDirectoryToDirectory(File srcDir, File destDir) |
复制文件夹 |
void deleteDirectory(File directory) |
删除文件夹 |
/*
目标：了解 Commons-io的常用功能
1.FileUtils操作文件或文件夹
拷贝文件：copyFile(File srcFile, File destFile)
拷贝文件夹：copyDirectoryToDirectory(File srcDir, File destDir) 文件夹里面的子文件夹也会一起拷贝
删除文件夹: deleteDirectory(File directory) 注意：整个文件夹都会直接删除，不管里面是否有内容
获取文件或文件夹大小：long sizeOf(File file)
2.FileUtils读取文件
读取文件内容为字符串：String readFileToString(File file, String encoding)
将文件内容按行读取成字符串集合：List<String> readLines(File file, String encoding)
*/
public class Demo10 {
public static void main(String[] args) throws IOException {
//拷贝文件：copyFile(源文件, 目的地)
//FileUtils.copyFile(new File("t_day12\\upload\\test.jpg"), new File("D:\\MyTest\\test.jpg"));
//拷贝文件夹：copyDirectoryToDirectory(原文件夹, 目的地) 文件夹里面的子文件夹也会一起拷贝
//FileUtils.copyDirectoryToDirectory(new File("t_day12"), new File("D:\\MyTest"));
//删除文件夹: deleteDirectory(File directory) 注意：整个文件夹都会直接删除，不管里面是否有内容!!!!!
//FileUtils.deleteDirectory(new File("D:\\MyTest\\t_day12"));
//获取文件或文件夹大小：long sizeOf(File file)
//long size = FileUtils.sizeOf(new File("D:\\MyTest"));
//System.out.println(size);
//读取文件内容为字符串：String readFileToString(File file, String encoding)
//以GBK的格式读取文件内容为字符串
String s = FileUtils.readFileToString(new File("t_day12\\upload\\gbk_file.txt"), "GBK");
System.out.println(s);
//将文件内容按行读取成字符串集合：List<String> readLines(File file, String encoding)
List<String> list = FileUtils.readLines(new File("t_day12\\upload\\utf8_file.txt"), "UTF-8");
for (String s1 : list) {
System.out.println(s1);
}
}
}
