- 一、IO简介*
- 1、什么是IO
- 2、什么是数据源（Data Source）
- 3、什么是流
- 4、java中四大IO抽象类
- 5、java中流的概念细分
- 6、java中IO流类的体系
- 二、IO流入门案例*
- 三、File类的使用
- 1、File简介
- 2、File操作方法：
- 四、常用流对象
- 1、文件字节流（节点流）
- 1、1文件字节输入流
- 1、2文件字节输出流
- 1、3通过缓冲区提高读写效率
- 1、4通过字节缓冲流提高读写效率
- 1、5定义文件拷贝工具类
- 2、文件字符流（节点流）
- 2、1文件字符输入流
- 2、2文件字符输出流
- 2、3使用字符流拷贝文本文件
- 3、字符缓冲流（处理流）
- 3、1字符输入缓冲流
- 3、2字符输出缓冲流
- 3、3定义文本拷贝工具类
- 4、转换流（处理流）
- 4、1键盘输入，屏幕输出
- 5、字符输出流（处理流）
- 6、字节数组流（节点流）
- 6、1字节数组输入流
- 6、2字节数组输出流
- 7、数据流（处理流）
- 7、1数据输出流
- 7、2数据输入流
- 8、对象流
- 8、1java对象的序列号和反序列化
- 8、1、1序列化和反序列化是什么
- 8、1、2序列化涉及的类和接口
- 8、2操作基本数据类型
- 8、3操作对象
- 8、3、1将对象序列化到文件
- 8、3、2将对象反序列化到内存
- 9、随机访问流
- 10、FIle类在IO中的使用
- 五、ApacFileReaderhe IO包
- 1、简介
- 2、下载和添加包
- 3、FileUtils使用示例
- 4、IOUtils使用示例
- I就是Input，指程序读取外部系统数据的过程
- O就是Output，指程序将数据输出给外部系统的过程
- 数据源（Data Source）是提供数据的原始媒介，分为为程序提供数据的源设备（一般对应输入流）和接收程序数据的目标设备（一般对应输出流）。
- 常见数据源有：数据库、文件、其他程序、网络、内存、IO设备。
流是一个相对抽象的概念，所谓流就是一个传输数据的通道，这个通道可以传输相应类型的数据。进而完成数据的传输。流又分为输入流和输出流。
输入流：将数据源的数据通过输入流传输到程序中。（数据源–>程序）
输出流：将程序中的数据通过输出流传输到目的数据源中。（程序–>目的地）
4、java中四大IO抽象类- InputSteam：字节输入流的所有类的父类，继承自该流的流都是用于向程序中输入数据，单位为字节
- 常用方法：
- int read() 读取一个字节的数据，并返回int值，值大小为0-255，返回-1则表示未读出字节
- void close() 关闭输入流对象
- OutputSteam：字节输出流的所有类的父类，继承自该流的流都是用于程序中输出数据，单位为字节
- 常用方法：
- void write(int n) 向目的地中写入一个字节
- void close() 关闭输出流对象
- Reader：用于读取的字符流抽象类
- 常用方法：
- int read() 读取一个字符的数据，并返回int值，值大小为0-65535，返回-1则表示未读出字符
- void close() 关闭输入流对象
- Writer：用于输出的字符流抽象类
- 常用方法：
- void write(int n) 向目的地中写入一个字符
- void close() 关闭输出流对象
- 按流方向分类：
- 输入流：数据源–>程序，以InputSteam或Reader结尾
- 输出流：程序–>目的地，以OutputSteam或Writer结尾
- 按处理的数据分类：
- 字节流：处理的数据为字节，以Steam结尾
- 字符流：处理的数据为字符，以Reader或Writer结尾
- 按处理的对象分类：
- 节点流：直接从数据源或目的地读写数据，如FileInputSteam，DataInputSteam
- 处理流（也叫包装流）：不直接连接数据源或目的地，而是连接其他流，是处理其他流的流，用于提高程序性能，如BufferedInputSteam，BufferedReader
| 分类 | 字节输入流 | 字节输出流 | 字符输入流 | 字符输出流 |
|---|---|---|---|---|
| 抽象基类 | InputStream | OutputStream | Reader | Writer |
| 访问文件 | FileInputStream | FileOutputStream | FileReader | FileWriter |
| 访问数组 | ByteArrayInputStream | ByteArrayOutputStream | CharArrayReader | CharArrayWriter |
| 访问管道 | PipedInputStream | PipedOutputStream | PipedReader | PipedWriter |
| 缓冲流 | BufferedInputStream | BufferedOutputStream | BufferedReader | BufferedWriter |
| 转换流 | InputStreamReader | OutputStreamWriter | ||
| 对象流 | ObjectInputStream | ObjectOutputStream | ||
| 抽象基类 | FilterInputStream | FilterOutputStream | FilterReader | FilterWriter |
| 打印流 | PrintStream | PrintWriter | ||
| 特殊流 | DataInputStream | DataOutputStream |
| 流对象 | 作用 |
|---|---|
| InputStream/OutputStream | 字节流的抽象类。 |
| Reader/Writer | 字符流的抽象类。 |
| FilelnputStream/FileoytputStream | 节点流:以字节为单位直接操作“文件”。 |
| ByteArrayInputStream/ByteArrayOutputStream | 节点流:以字节为单位直接操作“字节数组对 |
| ObjectInputStream/ObjectOutputStream | 处理流:以字节为单位直接操作“对象”。 |
| DatalnputStream/DataOutputStream | 处理流:以字节为单位直接操作“基本数据类型与字符串类型”。 |
| FileReader/FileWriter | 节点流:以字符为单位直接操作“文本文件”(注意:只能读写文本文件)。 |
| BufferedReader/BufferedWriter | 处理流:将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。 |
| BufferedInputStream/BufferedOutputStream | 处理流:将lnputStream/OutputStream对象进行包装，增加缓存功能，提高读写效率。 |
| InputStreamReader/OutputStreamWriter | 处理流:将字节流对象转化成字符流对象。 |
| PrintStream | 处理流:将OutputStream进行包装，啊以方便地输出字符，更加灵活。 |
FileInputStream in = null;//新建一个FileInputStream流对象
try {
in = new FileInputStream("c:\Users\86131\Desktop\JavaSE\code\Hello.txt");
StringBuilder stringBuilder = new StringBuilder();
int s = 0;
while( (s = in.read())!=-1){//如果读取错误，及读取完毕,则返回-1,因此如果返回-1则结束循环
System.out.print((char) s);//将读取到的int型转化成char型输出
//将读取到的字符s转化成char型并添加到字符串stringBuilder中
stringBuilder.append((char)s);
}
System.out.println(" ");
System.out.println(stringBuilder);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();//关闭IO流
} catch (IOException e) {
e.printStackTrace();
}
}
}
三、File类的使用
1、File简介
- “File类源于java.io.File包,是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。”
- 一个File对象可以代表一个文件或目录。
-
文件：
//创建一个新file对象，括号内参数为路径；创建对象并不会在路径处创建文件 File file = new File("C:\Users\86131\Desktop\JavaSE\IO测试\Demo01.txt"); System.out.println(file.createNewFile());//创建一个新的文件，返回boolean值 System.out.println(file.exists());//判断文件是否存在，返回Boolean值 System.out.println(file.getPath());//获取文件相对路径，返回相对路径 System.out.println(file.getAbsolutePath());//获取文件绝对路径，返回绝对路径 System.out.println(file.getName());//获取文件名字，返回文件名 System.out.println(file.isFile());//判断是否为一个文件，返回Boolean值 System.out.println(file.isHidden());//判断是否为隐藏文件，返回Boolean值 System.out.println(file.delete());//删除文件，返回Boolean值 -
目录：
//创建一个File对象 File file1 = new File("C:\Users\86131\Desktop\JavaSE\IO测试\测试目录1"); File file2 = new File("d:/测试目录2/测试目录3"); System.out.println(file1.mkdir());//创建一个单级目录，返回Boolean值 System.out.println(file2.mkdirs());//创建一个多级目录，返回Boolean值 System.out.println(file1.exists());//判断目录是否存在，返回Boolean值 System.out.println(file1.isDirectory());//判断当前路径是否为目录，返回Boolean值 System.out.println(file1.getParentFile());//获取父级目录，返回父级目录路径 //获取该目录下的所有文件和目录路径名，返回值为字符串数组 String[] s = file2.list(); for (String temp : s){ System.out.println(temp); } System.out.println("------------------------"); //获取该目录下的所有文件，包括文件名和绝对路径，返回文件数组 File[] files = file2.listFiles(); for(File temp:files){ System.out.println(temp); }
FileInputStream/FileOutputStream：通过字节的形式读/写文件，适合所有类型文件
FileReader/FileWriter：专门读/写文本文件
1、1文件字节输入流主要方法：read() ：读取数据
实例：读取d:/1.txt文件内容
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream("d:/1.txt");
int temp = 0;
while ((temp = fileInputStream.read()) != -1) {
System.out.println(temp);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
{
try {
if (fileInputStream != null) {
fileInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
1、2文件字节输出流
主要方法：write()和flush() ：写入数据及刷新
实例：将读取到的d:/1.txt文件数据写入d:/2.txt文件中
FileInputStream fileInputStream = null;
FileOutputStream fos = null;
try {
fileInputStream = new FileInputStream("d:/1.txt");
fos = new FileOutputStream("d:/2.txt");
int temp = 0;
while ((temp = fileInputStream.read()) != -1) {
fos.write(temp);
}
fos.flush();//将文件从内存中写到磁盘中
} catch (Exception e) {
e.printStackTrace();
} finally {
{
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (fos != null) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
1、3通过缓冲区提高读写效率
方法一:
-
思路：创建一个指定长度的byte数组作为缓冲区
-
适用于读取较大的文件
-
注意：数组大小为2的整数次幂，一般1024为最佳
-
代码实现：
FileInputStream fileInputStream = null; FileOutputStream fos = null; try { fileInputStream = new FileInputStream("d:/1.txt"); fos = new FileOutputStream("d:/2.txt"); byte[] buff = new byte[1024];//创建缓冲区 int temp = 0; //fileInputStream.read(buff)一次读取一整个数组的数据 while ((temp = fileInputStream.read(buff)) != -1) { fos.write(buff,0,temp);//写入buff内数据，从第0位开始，长度为temp } fos.flush();//将文件从内存中写到磁盘中 } catch (Exception e) { e.printStackTrace(); } finally { { try { if (fileInputStream != null) { fileInputStream.close(); } if (fos != null) { fos.close(); } } catch (IOException e) { e.printStackTrace(); } } }
方法二：
-
思路：创建一个由输入流对象确定长度的byte数组作为缓冲区
-
由available()方法预估文件长度
-
注意：不建议大文件使用，因为对内存占用较大
-
代码实现：
FileInputStream fileInputStream = null; FileOutputStream fos = null; try { fileInputStream = new FileInputStream("d:/1.txt"); fos = new FileOutputStream("d:/2.txt"); //通过available方法获取输入文件大小，并据此创建对应大小的数组 byte[] buff = new byte[fileInputStream.available()]; //因为数组大小就是文件大小了，因为只需要进行一次读写操作 fileInputStream.read(buff); fos.write(buff); fos.flush();//将文件从内存中写到磁盘中 } catch (Exception e) { e.printStackTrace(); } finally { { try { if (fileInputStream != null) { fileInputStream.close(); } if (fos != null) { fos.close(); } } catch (IOException e) { e.printStackTrace(); } } }
方法一、二对比：
方法一：所用内存：较小；效率：较高
方法二：所用内存：较大；效率：高
1、4通过字节缓冲流提高读写效率BufferedInputStream和BufferedOutputStream 是字节缓冲流，是一种处理流，其原理和1、3中方法相同。
代码实现：
//新建流对象
FileInputStream fis = null;
BufferedInputStream bis = null;
FileOutputStream fos = null;
BufferedOutputStream bos = null;
try {
//流对象实例化
fis = new FileInputStream("D:\1.txt");
bis = new BufferedInputStream(fis);//缓冲流对象，套在节点流fis上
fos = new FileOutputStream("D:\2.txt");
bos = new BufferedOutputStream(fos);//缓冲流对象，套在节点流fos上
int temp = 0;
while ((temp = bis.read())!= -1){
bos.write(temp);
}
bos.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
//关闭流顺序：后开的先关闭
if (bis != null) {
bis.close();
}
if (fis != null) {
fis.close();
}
if (bos != null) {
bos.close();
}
if (fos != null) {
fos.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
1、5定义文件拷贝工具类
代码实现：
public static void main(String[] args) {
copyFile("d:/3.jpg","d:/4.jpg");
}
public static void copyFile(String src,String des){
FileInputStream fis = null;
BufferedInputStream bis = null;
FileOutputStream fos = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream(src));
bos = new BufferedOutputStream(new FileOutputStream(des));
int temp = 0;
while ((temp = bis.read())!= -1){
bos.write(temp);
}
bos.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (bis != null) {
bis.close();
}
if (fis != null) {
fis.close();
}
if (bos != null) {
bos.close();
}
if (fos != null) {
fos.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
2、文件字符流（节点流）
处理文本文件时，可以使用文件字符流
2、1文件字符输入流主要方法：read() 读取数据
实例：读取d:/1.txt文件内容
FileReader fr = null;
try {
fr = new FileReader("d:/1.txt");
int temp=0;
while ((temp = fr.read())!=-1){
System.out.print((char) temp);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fr!=null){
fr.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
2、2文件字符输出流
主要方法：write()和flush() ：写入数据及刷新
实例：写入字符到d:/2.txt
FileWriter fw = null;
try {
fw = new FileWriter("d:/2.txt");
fw.write("胡靖21130124");
fw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fw!=null){
fw.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
2、3使用字符流拷贝文本文件
代码实现：
FileReader fr = null;
FileWriter fw = null;
try {
fr = new FileReader("d:/1.txt");
fw = new FileWriter("d:/2.txt");
char[] chars = new char[1024];
int temp = 0;
while ((temp = fr.read(chars)) != -1) {
fw.write(chars, 0, temp);
}
fw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (fr != null) {
fr.close();
}
if (fw != null) {
fw.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
3、字符缓冲流（处理流）
3、1字符输入缓冲流
主要方法：realLine() :以行为单位读取文本文件
实例：读取d:/1.txt文件内容：
FileReader fr = null;
BufferedReader br = null;
try {
fr = new FileReader("d:/1.txt");
br = new BufferedReader(fr);
String s;
while ((s = br.readLine())!=null){//注意，这里不再是-1，而是null
System.out.println(s);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(br!=null){
br.close();
}
if(fr!=null){
fr.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
3、2字符输出缓冲流
主要方法：newLine() ：换行
实例：写入带有换行操作的字符到d:/2.txt
FileWriter fw = null;
BufferedWriter bw = null;
try {
fw = new FileWriter("d:/2.txt");
bw = new BufferedWriter(fw);
bw.write("123456");
bw.newLine();
bw.write("hujing");
bw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (bw!=null){
bw.close();
}
if (fw!=null){
fw.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
思考： rn也能实现换行操作且更加便利，为何使用newLine？
答：rn为Windows系统中的换行操作，在别的系统中并不通用，使用newLine可以在任意系统中实现换行，可移植性强。
3、3定义文本拷贝工具类代码实现：将d:/1.txt文件拷贝至d:/2.txt
public static void main(String[] args) {
copyFile("d:/1.txt","d:/2.txt");
}
public static void copyFile(String scr,String des){
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader(scr));
bw = new BufferedWriter(new FileWriter(des));
String temp;
while ((temp = br.readLine())!=null){
bw.write(temp);
bw.newLine();
}
bw.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (br!=null) {
br.close();
}
if (bw!=null){
bw.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
4、转换流（处理流）
InputStreamReader 和OutputStreamWriter 原来实现字节流转换成字符流
4、1键盘输入，屏幕输出- System.in和System.out为字节输入流和字节输出流，用于从键盘输入数据，显示屏输出数据；
代码实现：
BufferedWriter bw = null;
BufferedReader br = null;
try {System.in和System.out转换成字符流
//通过转换流InputStreamReader和OutputStreamWriter将字节流System.in和System.out转换成字符流
// 字符流 （字节流转字符流 （字节流 ））
br = new BufferedReader(new InputStreamReader(System.in));
bw = new BufferedWriter(new OutputStreamWriter(System.out));
while (true){
bw.write("请输入：");
bw.flush();
String sca = br.readLine();//程序读取控制台数据并赋给sca
if (sca.equals("exit")){
bw.write("结束输入");
break;
}
bw.write("您输入的是："+sca);
bw.newLine();
bw.flush();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (br!=null) {
br.close();
}
if (bw!=null){
bw.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
5、字符输出流（处理流）
字符输出流 PrintWriter 中println方法可以方便的换行输出数据。
字符输入流和字符输出流不一定要配对使用
6、字节数组流（节点流）ByteArrayInputStream 和 ByteArrayOutputStream 经常用在需要流和数组间进行转化的情况
6、1字节数组输入流作用：将字节数组中的数据读入流中
实例：将字符串转化成字节数组并读取
public static void main(String[] args) {
//"abcdefg"为字符串，getBytes()方法使其变成字节数组
byte[] arr = "abcdefg".getBytes();
StringBuilder sb = new StringBuilder();
ByteArrayInputStream bais = null;
try {
//该构造方法的参数为字节数组，这个字节数组就是数据源
bais = new ByteArrayInputStream(arr);
int temp = 0;
while ((temp=bais.read())!=-1){
sb.append((char) temp);
}
System.out.println(sb);
}finally {
try {
if (bais!=null){
bais.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
6、2字节数组输出流
作用：将流中的数据写入字节数组中
实例：
ByteArrayOutputStream bos = null;
StringBuilder sb = new StringBuilder();
try {
bos = new ByteArrayOutputStream();
bos.write('a');
bos.write('b');
bos.write('c');
//toByteArray()：将流转换为字节数组的方法
//arr中元素则为通过write方法写进的
byte[] arr = bos.toByteArray();
for(int i=0;i
sb.append((char) arr[i]);
}
System.out.println(sb);
} finally {
try {
if (bos!=null){
bos.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
7、数据流（处理流）
作用：当读写数据类型为基本类型时，使用DataInputStream和DataOutputStream 可以省去类型转换的麻烦
7、1数据输出流实例：输出各个类型的数据到文件中
DataOutputStream dos = null;
try {
//因为写入类型的原因，文件可以没有后缀，文件后缀无关紧要
dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("d:/data")));
dos.writeBoolean(true);//写入Boolean型
dos.writeChar('a');//写入char型
dos.writeInt(10);//写入int型
dos.writeDouble(3.14);//写入double型
dos.writeUTF("123456");//写入字符串
dos.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (dos!=null) {
dos.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
7、2数据输入流
实例：从文件中输入各个类型数据
DataInputStream dis = null;
try {
dis = new DataInputStream(new BufferedInputStream(new FileInputStream("d:/data")));
//注意：读取顺序应与写入顺序一致
System.out.println(dis.readBoolean());
System.out.println(dis.readChar());
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readUTF());
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (dis!=null) {
dis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
8、对象流
对象流能够对对象进行读写操作
8、1java对象的序列号和反序列化 8、1、1序列化和反序列化是什么序列化：传输方把对象变成字节序列的过程
反序列化：接受方把接收到的字节序列转化成对象的过程
序列化的作用：
- 持久性：把对象的字节序列永久的存放在硬盘内
- 网络通信：在网络上传输对象的字节序列
ObjectOutputStream：对象输出流，其中writeObject(Object obj)方法可以把参数指定的对象序列化
ObjectInputStream：对象输入流，其中readObject()方法可以从一个源中读取字节序列并反序列化成对象
只有实现了Serializable接口的类才能被序列化，Serializable接口是个空接口，起标记作用
8、2操作基本数据类型同上 7、数据流
8、3操作对象 8、3、1将对象序列化到文件注意：必须实现Serializable接口
-
创建对象user：
public class user implements Serializable {//注意实现Serializable private String name; private String id; private int age; public user(String name, String id, int age) { this.name = name; this.id = id; this.age = age; } public user() { } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override//重写方法，方便打印输出 public String toString() { return "User{" + "name='" + name + ''' + ", id='" + id + ''' + ", age=" + age + '}'; } } -
序列化到文件Object：
ObjectOutputStream oos = null; try { oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("d:/object"))); user user = new user("hj","21130124",18); oos.writeObject(user);//将一个对象序列化到外部 oos.flush(); } catch (Exception e) { e.printStackTrace(); } finally { try { if (oos!=null) { oos.close(); } } catch (Exception e) { e.printStackTrace(); } }
代码实现：
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("d:/object"));
User user = (User)ois.readObject();//返回值为Object型，需强制转化为User型
System.out.println(user);//在user类中重写了toString方法，所以可以直接输出
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (ois!=null) {
ois.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
9、随机访问流
RandomAccessFile 功能：
- 对文件进行读写
- 可以访问文件任意位置
常用方法：
- RandomAccessFile(String name,String mode) name确定文件，mode确定权限（r为可读，rw为可读写）
- seek(long a) 确定文件读写位置，a表示距离开头的字节个数
- getFilePointer() 获取流当前读写位置
实例：
RandomAccessFile raf = null;
try {
raf=new RandomAccessFile("d:/raf.txt","rw");
int[] a = new int[]{1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < a.length; i++) {
raf.writeInt(a[i]);
}
//指针从0开始，int型为4个字节，所以距离开头4个字节为第二个int型数据
raf.seek(4);
//readInt方法会自动往后读四个字节
System.out.println(raf.readInt());
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (raf!=null) {
raf.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
10、FIle类在IO中的使用
当以文件作为数据源或目标时，除了可以使用字符串指定文件位置外，还可以使用File类指定
方法如下：
//使用字符串指定：
fileInputStream = new FileInputStream("d:/1.txt");
//使用FIle类：
fileInputStream = new FileInputStream(new File("d:/1.txt"));
作用：
当使用第三方IO包时，必须使用File类
五、ApacFileReaderhe IO包 1、简介比JDK提供的IO类更加简单快捷**
官方网站：Welcome to The Apache Software Foundation!
2、下载和添加包下载网址：Commons IO – Commons IO Overview (apache.org)
添加包：
-
下载并解压
-
打开IDEA项目
-
打开项目结构（Ctrl+shift+Alt+s）
-
添加java文件
-
选中如图文件
- 添加成功
public static void main(String[] args) throws Exception{
//utf-8:编码格式
String s = FileUtils.readFileToString(new File(("d:/1.txt")),"utf-8");
System.out.println(s);
}
更多方法详见index.html文档
4、IOUtils使用示例public static void main(String[] args) throws Exception{
String s = IOUtils.toString(new FileInputStream("d:/1.txt"));
System.out.println(s);
}
更多方法详见index.html文档
