一、网络通信概念

实现不同计算机上进行数据传输的程序。

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）地址

*

   目标:学习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中getInputStream和getOutputStream

• 可以转变为转换流 new InputStreamRead（ InputStream ）
• 转换流可以转变为字符流： new BufferRead （Read ）
• 可以直接变为打印流 new PrintStream （InputStream）

——详细可以常考作业。

网络编程作业-参考答案.pdf

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包

常用方法：

/*

   目标：了解 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);

       }

   }

}