Java语言基础学习IO流

一、File类的使用

java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关。

File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。

File对象可以作为参数传递给流的构造器。

注意:在main()方法中new File类对象，对象路径是相较于当前工程；在单元测试方法中则是相较于当前Module。

1.如何创建File类的实例

File(String filePath)

File(String parentPath,String childPath)

File(File parentFile,String childPath)

相对路径：相较于某个路径下，指明的路径。

绝对路径：包含盘符在内的文件或文件目录的路径

3.Java中路径分隔符

windows:\\

unix:/

@Test

public void test1(){

//构造器1

File file1 = new File("hello.txt");//相对于当前module

File file2 = new File("D:\\workspace_idea1\\JavaSenior\\day08\\he.txt");

System.out.println(file1);

System.out.println(file2);

//构造器2：

File file3 = new File("D:\\workspace_idea1","JavaSenior");

System.out.println(file3);

//构造器3：

File file4 = new File(file3,"hi.txt");

System.out.println(file4);

}

二、 File 类的使用：常用方法

1.File类的获取功能

public String getAbsolutePath()：获取绝对路径

public String getPath() ：获取路径

public String getName() ：获取名称

public String getParent()：获取上层文件目录路径。若无，返回null

public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。

public long lastModified() ：获取最后一次的修改时间，毫秒值

如下的两个方法适用于文件目录：

public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组

public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组

2. File类的重命名功能

public boolean renameTo(File dest):把文件重命名为指定的文件路径

比如：file1.renameTo(file2)为例：

要想保证返回true,需要file1在硬盘中是存在的，且file2不能在硬盘中存在。

3. File类的判断功能

public boolean isDirectory()：判断是否是文件目录

public boolean isFile() ：判断是否是文件

public boolean exists() ：判断是否存在

public boolean canRead() ：判断是否可读

public boolean canWrite() ：判断是否可写

public boolean isHidden() ：判断是否隐藏

4.File类的创建功能

创建硬盘中对应的文件或文件目录

public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false

public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。

public boolean mkdirs() ：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建

注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下。

@Test

public void test6() throws IOException {

File file1 = new File("hi.txt");

if(!file1.exists()){

//文件的创建

file1.createNewFile();

System.out.println("创建成功");

}else{//文件存在

file1.delete();

System.out.println("删除成功");

}

5. File类的删除功能

删除磁盘中的文件或文件目录

public boolean delete()：删除文件或者文件夹

删除注意事项：Java中的删除不走回收站。

要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。

6.总结

File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。

后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点"。

二、IO流原理及流的分类

I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。

Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。

java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

1.Java IO原理

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。

输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类

字符流和字节流

字符流的由来：因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。字节流和字符流的区别：

读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

字节流：一次读入或读出是8位二进制。

字符流：一次读入或读出是16位二进制。

设备上的数据无论是图片或者视频，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

结论：只要是处理纯文本数据，就优先考虑使用字符流。除此之外都使用字节流。

2.FileReader读入数据的基本操作

FileReader (read(char[] cbuf))

将day09下的hello.txt文件内容读入程序中，并输出到控制台

说明点：

1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1

2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理

3. 读入的文件一定要存在，否则就会报FileNotFoundException。

@Test

public void testFileReader(){

FileReader fr = null;

try {

//1.实例化File类的对象，指明要操作的文件

File file = new File("hello.txt");//相较于当前Module

//2.提供具体的流

fr = new FileReader(file);

//3.数据的读入

//read():返回读入的一个字符。如果达到文件末尾，返回-1

//方式一：

// int data = fr.read();

// while(data != -1){

// System.out.print((char)data);

// data = fr.read();

// }

//方式二：语法上针对于方式一的修改

int data;

while((data = fr.read()) != -1){

System.out.print((char)data);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

//4.流的关闭操作

// try {

// if(fr != null)

// fr.close();

// } catch (IOException e) {

// e.printStackTrace();

// }

//或

if(fr != null){

try {

fr.close();

} catch (IOException e) {

e.printStackTrace();

}

2.1FileReader中使用readchar cbuf读入数据

//对read()操作升级：使用read的重载方法

@Test

public void testFileReader1() {

FileReader fr = null;

try {

//1.File类的实例化

File file = new File("hello.txt");

//2.FileReader流的实例化

fr = new FileReader(file);

//3.读入的操作

//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1

char[] cbuf = new char[5];

int len;

while((len = fr.read(cbuf)) != -1){

//方式一：

//错误的写法

// for(int i = 0;i < cbuf.length;i++){

// System.out.print(cbuf[i]);

// }

//正确的写法

// for(int i = 0;i < len;i++){

// System.out.print(cbuf[i]);

// }

//方式二：

//错误的写法,对应着方式一的错误的写法

// String str = new String(cbuf);

// System.out.print(str);

//正确的写法

String str = new String(cbuf,0,len);

System.out.print(str);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

if(fr != null){

//4.资源的关闭

try {

fr.close();

} catch (IOException e) {

e.printStackTrace();

}

3.FileWriter写出数据的操作

FileWriter (write(char[] cbuf,0,len)

从内存中写出数据到硬盘的文件里。

说明：

1. 输出操作，对应的File可以不存在的。并不会报异常

File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。

File对应的硬盘中的文件如果存在：

如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖

如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容

@Test

public void testFileWriter() {

FileWriter fw = null;

try {

//1.提供File类的对象，指明写出到的文件

File file = new File("hello1.txt");

//2.提供FileWriter的对象，用于数据的写出

fw = new FileWriter(file,false);

//3.写出的操作

fw.write("I have a dream!\n");

fw.write("you need to have a dream!");

} catch (IOException e) {

e.printStackTrace();

} finally {

//4.流资源的关闭

if(fw != null){

try {

fw.close();

} catch (IOException e) {

e.printStackTrace();

}

4.使用FileReader和FileWriter实现文本文件的复制

@Test

public void testFileReaderFileWriter() {

FileReader fr = null;

FileWriter fw = null;

try {

//1.创建File类的对象，指明读入和写出的文件

File srcFile = new File("hello.txt");

File destFile = new File("hello2.txt");

//不能使用字符流来处理图片等字节数据

// File srcFile = new File("爱情与友情.jpg");

// File destFile = new File("爱情与友情1.jpg");

//2.创建输入流和输出流的对象

fr = new FileReader(srcFile);

fw = new FileWriter(destFile);

//3.数据的读入和写出操作

char[] cbuf = new char[5];

int len;//记录每次读入到cbuf数组中的字符的个数

while((len = fr.read(cbuf)) != -1){

//每次写出len个字符

fw.write(cbuf,0,len);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

//4.关闭流资源

//方式一：

// try {

// if(fw != null)

// fw.close();

// } catch (IOException e) {

// e.printStackTrace();

// }finally{

// try {

// if(fr != null)

// fr.close();

// } catch (IOException e) {

// e.printStackTrace();

// }

//方式二：

try {

if(fw != null)

fw.close();

} catch (IOException e) {

e.printStackTrace();

}

try {

if(fr != null)

fr.close();

} catch (IOException e) {

e.printStackTrace();

}

5.FileInputStream和FileOutputStream复制文件的方法

FileInputStream (read(byte[] buffer))

FileOutputStream (write(byte[] buffer,0,len)

//指定路径下文件的复制

public void copyFile(String srcPath,String destPath){

FileInputStream fis = null;

FileOutputStream fos = null;

try {

File srcFile = new File(srcPath);

File destFile = new File(destPath);

fis = new FileInputStream(srcFile);

fos = new FileOutputStream(destFile);

//复制的过程

byte[] buffer = new byte[1024];

int len;

while((len = fis.read(buffer)) != -1){

fos.write(buffer,0,len);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

if(fos != null){

try {

fos.close();

} catch (IOException e) {

e.printStackTrace();

}

if(fis != null){

try {

fis.close();

} catch (IOException e) {

e.printStackTrace();

}

结论：

1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理。

2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理。

处理流之一：缓冲流的使用

* 1.缓冲流：

* BufferedInputStream

* BufferedOutputStream

* BufferedReader

* BufferedWriter

* 2.作用：提供流的读取、写入的速度

* 提高读写速度的原因：内部提供了一个缓冲区

* 3. 处理流，就是“套接”在已有的流的基础上。

6.缓冲流字节型实现非文本文件的复制

BufferedInputStream (read(byte[] buffer))

BufferedOutputStream (write(byte[] buffer,0,len) / flush()

//实现非文本文件的复制

@Test

public void BufferedStreamTest() throws FileNotFoundException {

BufferedInputStream bis = null;

BufferedOutputStream bos = null;

try {

//1.造文件

File srcFile = new File("爱情与友情.jpg");

File destFile = new File("爱情与友情3.jpg");

//2.造流

//2.1 造节点流

FileInputStream fis = new FileInputStream((srcFile));

FileOutputStream fos = new FileOutputStream(destFile);

//2.2 造缓冲流

bis = new BufferedInputStream(fis);

bos = new BufferedOutputStream(fos);

//3.复制的细节：读取、写入

byte[] buffer = new byte[10];

int len;

while((len = bis.read(buffer)) != -1){

bos.write(buffer,0,len);

// bos.flush();//刷新缓冲区

}

} catch (IOException e) {

e.printStackTrace();

} finally {

//4.资源关闭

//要求：先关闭外层的流，再关闭内层的流

if(bos != null){

try {

bos.close();

} catch (IOException e) {

e.printStackTrace();

}

if(bis != null){

try {

bis.close();

} catch (IOException e) {

e.printStackTrace();

}

//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.

// fos.close();

// fis.close();

}

7..缓冲流字符型实现文本文件的复制

BufferedReader (read(char[] cbuf) / readLine())

BufferedWriter (write(char[] cbuf,0,len) / flush()

//实现文件复制的方法

public void copyFileWithBuffered(String srcPath,String destPath){

BufferedInputStream bis = null;

BufferedOutputStream bos = null;

try {

//1.造文件

File srcFile = new File(srcPath);

File destFile = new File(destPath);

//2.造流

//2.1 造节点流

FileInputStream fis = new FileInputStream((srcFile));

FileOutputStream fos = new FileOutputStream(destFile);

//2.2 造缓冲流

bis = new BufferedInputStream(fis);

bos = new BufferedOutputStream(fos);

//3.复制的细节：读取、写入

byte[] buffer = new byte[1024];

int len;

while((len = bis.read(buffer)) != -1){

bos.write(buffer,0,len);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

//4.资源关闭

//要求：先关闭外层的流，再关闭内层的流

if(bos != null){

try {

bos.close();

} catch (IOException e) {

e.printStackTrace();

}

if(bis != null){

try {

bis.close();

} catch (IOException e) {

e.printStackTrace();

}

//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.

// fos.close();

// fis.close();

}

IO 中的输入流的 read() 方法返回值为什么是 int

Java 下 IO 中 FileReder 和 FileInputStream 分别是以字符和字节的形式来完成数据的读取的，然而返回值确是 int 类型的数据，这样做的核心目的只是要取到到一个 int 类型下的 -1 来表示数据流的末尾。为什么要这样做？又是怎么实现的呢？

首先看 FileReder ：

FileReader fr = new FileReader("src.txt");

int ch = fr.read();

如上面的代码，FileReader 的 read 方法返回值是一个 int 类型的变量来接收的，然而 read 方法在实际中却是以字符形式来进行数据的读取的。通过上面的基本数据类型的取值范围我们能发现 char 类型数据的取值范围为 0 ~ 65535 ，也就是说 char 类型数据是取不到负值的；int 类型数据的取值范围为 -2147483648 ~ 2147483647 ，可以取到负值；同时 int 的取值范围又包含 char 的取值范围，这就为使用 int 作为返回值类型提供了可能，因为流需要一个特殊的值来表示流末尾，这个值不应该在 char 的取值范围内，如果使用 char 取值范围内的值作为流末尾标志，那么这个值同样有可能出现在数据流中间作为数据来传输，流在读到这个值的时候会认为已经到达流末尾，后面未读取的数据将被截断。所以 Java 中选择了使用 -1 来作为流末尾，这个值不在 char 的取值范围内，所以不存在数据截断，然而 -1 又在 int 的取值范围内，同时 int 的取值范围包含 char 的取值范围，所以 FileReader 下 read 方法返回的 char 类型数据直接转为了 int 类型。

再看 FileInputStream ：

FileInputStream fis = new FileInputStream("src.txt");

int b = fis.read();

同理 FileInputStream 也需要一个自己取不到的值来作为流末尾的标志，Java 同样使用 -1 来作为字节流的流末尾，从上面基本数据类型的取值范围我们可以看到 byte 的取值范围为 -128 ~ 127 ，这就意味走着 byte 可以取到 -1 ，如果把 -1 直接当作 int 作为流末尾，那么就无法区分这个读到的结果是流末尾还是流中的数据了，那么 Java 是如何实现取值 -1 的呢？在 Java 内部，Java 通过高位补 0 来实现数据从 byte 到 int 的转换，举个例子：

-1 在 byte 类型和 int 类型中都可以取到，-1 在 byte 类型下的二进制存储形式为 11111111 ，然而使用 read 方法的时候，Java 内部将 byte 的高位补 0 将 byte 转为 int 类型，所以 byte 类型的 -1 在 int 类型下的二进制存储形式为 00000000 00000000 00000000 11111111，对应的 int 值为 255，通过高位补 0 ，所有 byte 类型的负数都转为了正数。然而在使用这些读到的 byte 数据时，只要将这些数据从 int 强转回 byte 即可得到原有的数据。所以就可以使用 -1 来作为流末尾的标志，因为 Java 内部将 byte 的负数通过高位补 0 将其转换为了正数。