推荐学习：《java视频教程》
IO简介
1 Stream
在学习IO流之前,我们首先需要学习的概念就是Stream流 为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意: 1.流只能单方向流动 2.输入流用来读取 → in 3.输出流用来写出 → out 4.数据只能从头到尾顺序的读写一次 所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
2 IO流的继承结构
在java中,根据处理的数据单位不同,可以把流分为字节流和字符流 字节流 : 针对二进制文件 字符流 : 针对文本文件 再结合对应类型的输入和输出方向,常用的流有:
3 File文件类
3.1概述
封装一个磁盘路径字符串,对这个路径可以执行一次操作 可以封装文件路径、文件夹路径、不存在的路径
3.2创建对象
File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例 new File(“d:/abc/a.txt”); new File(“d:/abc”,”a.txt”);
3.3常用方法
3.4 练习：测试常用方法
创建包: cn.tedu.file 创建类: TestFile.java
package cn.tedu.file;import java.io.File;import java.io.IOException;import java.util.Arrays;/*本类用于测试文件类File*/public class TestFile { public static void main(String[] args) throws IOException { //1.创建File类对象 /*1.ready目录与1.txt需要自己手动创建 * 2.File需要导包：import java.io.File; * 3.路径是String类型，必须写正确，不然找不到文件 * 4.完整的文件名包含两部分：文件名+后缀名*/ File file = new File("E:\\ready\\1.txt"); //2.1测试File中的常用方法 System.out.println(file.length());//3，获取文件的字节量 System.out.println(file.exists());//true,判断文件是否存在 System.out.println(file.isFile());//true,判断是否为文件 System.out.println(file.isDirectory());//false，判断是否为文件夹 System.out.println(file.getName());//1.txt获取文件名 System.out.println(file.getParent());//E:\ready 获取父级路径 System.out.println(file.getAbsolutePath());//E:\ready\1.txt 获取带盘符的完整路径：绝对路径 //2.2 测试创建与删除 /*new 只会帮你在内存中创建一个File类型的对象 * 并不会帮你在磁盘中创建一个真实存在的2.txt文件*/ file = new File("E:\\ready\\2.txt"); //创建一个之前不存在的文件2.txt,如果创建成功，会返回true /*如果指定创建文件的路径不对，会抛出异常：java.io.Exception * 所以需要提前处理这个问题，我们暂时选择在main()上抛出 * 这个IO异常是目前我们遇到的强制要求必须预先处理的异常 * 如果不处理，方法的调用会报错，通不过编译*/ System.out.println(file.createNewFile());//创建之前不存在的文件 file = new File("E:\\ready\\m"); System.out.println(file.mkdir());//创建之前不存在的单层文件夹 file = new File("E:\\ready\\a\\b\\c"); System.out.println(file.mkdirs());//创建之前不存在的多层文件夹 System.out.println(file.delete());//c被删除，删除空文件夹或者文件 file = new File("E:\\ready\\a"); System.out.println(file.delete());//false,a文件夹不是空的，里面有内容 file = new File("E:\\ready\\2.txt"); System.out.println(file.delete());//2.txt被删除，可以删除文件 //2.3测试展示文件列表 file = new File("E:\\ready"); String[] list = file.list();/*不常用*/ System.out.println(Arrays.toString(list)); //这句话会报错，因为这是一个String[],所以数组中每个元素都是String类型的 //那么只能用String类中的方法，而isDirectory()是File类中的方法 //System.out.println(list[0].isDirectory()); File[] fs = file.listFiles();/*常用*/ System.out.println(Arrays.toString(fs)); System.out.println(fs[0].isDirectory()); }}4 字节流读取
字节流是由字节组成的,字符流是由字符组成的. Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。 所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等
4.1 InputStream抽象类
此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象哦
4.2 FileInputStream子类
直接插在文件上，直接读取文件数据
4.3 BufferedInputStream子类
BufferedInputStream 为另一个输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
4.4 练习：字节流读取案例
创建包: cn.tedu.file 创建类: TestIn.java
package cn.tedu.file;import java.io.*;/*本类用于练习字节输入流*/public class TestIn { public static void main(String[] args) { //method();//字节流的读取 method2();//高效字节流的读取 } //本方法用于测试高效字节流的读取 private static void method2() { //定义一个在本方法中都生效的局部变量in,注意手动初始化，值为null InputStream in = null; try { //1.创建高效字节输入流对象// InputStream in = new BufferedInputStream(// new FileInputStream(new File("E:\\ready\\1.txt"))); in = new BufferedInputStream (new FileInputStream("E:\\ready\\1.txt")); //2.使用流进行读取 int b; while ((b= in.read())!= -1){ System.out.println(b); } } catch (Exception e) { e.printStackTrace(); }finally {//关流操作写在finally{}中 //3.流用完以后一定要关闭！！！ try { in.close(); } catch (IOException e) { e.printStackTrace(); } } } //本方法用于测试字节流的读取 private static void method() { //创建一个在本方法都生效的局部变量注意手动初始化 InputStream in = null; try { //1.创建字节输入流对象用于读取 //InputStream in = new InputStream();//报错原因：抽象类不可实例化 //InputStream in = new FileInputStream(new File("E:\\ready\\1.txt")); in = new FileInputStream("E:\\ready\\1.txt"); //2.开始读取 /*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/// System.out.println(in.read());// System.out.println(in.read());// System.out.println(in.read());// System.out.println(in.read()); //需求：需要循环读取文件中的所有内容，直至读完 //定义变量，记录读到的数据 int b; while((b=in.read())!= -1){ System.out.println(b); } } catch (Exception e) { e.printStackTrace();//打印错误信息 /*try-catch结构中的第三个部分：finally{} * 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/ }finally { try { //3.释放资源，流资源用完必须释放！！！ in.close(); } catch (IOException e) { e.printStackTrace(); } } }}5 字符流读取
常用于处理纯文本数据,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8
5.1 Reader抽象类
用于读取字符流的抽象类。
5.2 FileReader子类
用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
5.3 BufferedReader子类
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
5.4 练习：字符流读取案例
创建包: cn.tedu.file 创建类: TestIn2.java
package cn.tedu.file;import java.io.*;/*本类用于测试字符流的读取*/public class TestIn2 { public static void main(String[] args) { //method();//测试普通字符输入流 method2();//测试高效字符输入流 } //创建一个用于测试高效字符输入流的方法 private static void method2() { //1.定义一个在本方法都生效的局部变量，手动初始化值null Reader in=null; try{ //1.创建高效字符读取流对象 //in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt"))); in = new BufferedReader(new FileReader("E:\\ready\\1.txt")); //2.使用流对象 int b; while((b=in.read())!=-1){ System.out.println(b); } }catch (Exception e){ e.printStackTrace(); }finally { //3.关闭流对象 try { in.close(); } catch (IOException e) { e.printStackTrace(); } } } //创建一个用于测试普通字符输入流的方法 private static void method() { //1.1创建一个在本方法中都生效的局部变量，注意初始化值null Reader in = null; try { //1.2创建字符输入流对象，注意需要捕获异常 //Reader in = new Reader();//报错原因：抽象父级不可实例化 //in = new FileReader(new File("E:\\ready\\1.txt")); in = new FileReader("E:\\ready\\1.txt"); //2.使用流对象 //System.out.println(in.read()); //需求：循环读取文件中的所有内容，只要不是-1，就说明还有数据，继续读取 //3.1定义变量，记录读取到的数据 int b; while((b = in.read())!= -1){ System.out.println(b); } } catch (Exception e) { e.printStackTrace(); } finally {//3.关流 try { in.close(); } catch (IOException e) { e.printStackTrace(); } } }}6 字节流写出
6.1 OutputStream抽象类
此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.
6.2 FileOutputStream 子类
直接插在文件上,直接写出文件数据
6.3 BufferedOutputstream 子类
该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统
6.4 练习: 字节输出流测试:
创建包: cn.tedu.file 创建类: TestOut.java
package cn.tedu.file;import java.io.*;/*本类用于测试字节输出流*/public class TestOut { public static void main(String[] args) { method();//用于测试普通字节输出流 //method2();//用于测试高效字节输出流 } //创建一个用于测试高效字节输出流的方法 private static void method2() { //1.创建一个在本方法都生效的局部变量，注意手动初始化 OutputStream out = null; try{ //2.创建高效字节输出流对象// out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt"))); out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt")); //3.使用流对象--进行写出操作 out.write(97); out.write(97); out.write(97); }catch (Exception e){ e.printStackTrace(); }finally {//关流操作要放在finally{}中 try { //4.关流 out.close(); } catch (IOException e) { e.printStackTrace(); } } } //创建一个用于测试普通字节输出流的方法 private static void method() { //1.创建一个在本方法中都生效的局部变量，注意手动初始化null OutputStream out = null; //2.创建try-catch-finally结构，因为IO操作可能会产生异常 try{ //3.创建普通字节输出流对象 //out = new FileOutputStream(new File("E:\\ready\\2.txt")); //out = new FileOutputStream("E:\\ready\\2.txt"); out = new FileOutputStream("E:\\ready\\2.txt",true); //4.使用流对象--进行写出操作 out.write(99);//对应ASCII码表中的a out.write(99);//对应ASCII码表中的b out.write(99);//对应ASCII码表中的c }catch (Exception e){ e.printStackTrace(); }finally {//如果想要代码一定会执行，需要写在finally中 try { //5.关流操作 out.close(); } catch (IOException e) { e.printStackTrace(); } } }}7 字符流写出
7.1 Writer 抽象类
写入字符流的抽象类
7.2 FileWriter 子类
用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.
7.3 BufferedWriter子类
将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了
7.4 练习: 字符输出流测试:
创建包: cn.tedu.file 创建类: TestOut2.java
package cn.tedu.file;import java.io.*;/*本类用于测试字符输出流*/public class TestOut2 { public static void main(String[] args) { //method();//用于测试普通字符输出流 method2();//用于测试高效字符输出流 } //创建一个用于测试高效字符输出流的方法 private static void method2() { //1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！ Writer out = null; //2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构 try{//存放可能会抛出异常的代码 //3.创建普通字符输出流对象 //out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt"))); //out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt")); out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true)); //4.使用流对象 out.write(100); out.write(100); out.write(100); out.write(100); out.write(100); }catch (Exception e){//匹配并捕获异常 e.printStackTrace();//如果捕获到异常就打印错误信息 }finally {//一定会被执行到的代码块，常用于关流 try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } //创建一个用于测试普通字符输出流的方法 private static void method() { //1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！ Writer out = null; //2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构 try{//存放可能会抛出异常的代码 //3.创建普通字符输出流对象 //out = new FileWriter(new File("E:\\ready\\2.txt")); //out = new FileWriter("E:\\ready\\2.txt"); out = new FileWriter("E:\\ready\\2.txt",true); //4.使用流对象 out.write(98); out.write(98); out.write(98); out.write(98); }catch (Exception e){//匹配并捕获异常 e.printStackTrace();//如果捕获到异常就打印错误信息 }finally {//一定会被执行到的代码块，常用于关流 try { out.close(); } catch (IOException e) { e.printStackTrace(); } } }}8 拓展
通过学习以上的几种流,我们也可以拓展尝试做下文件的复制: 创建包: cn.tedu.file 创建类: TestCopyFile.java
package cn.tedu.file;import java.io.*;import java.util.Scanner;/*本类用于练习文件复制综合案例*/public class TestCopyFile { public static void main(String[] args) { //1.提示并接收用户输入的两个路径 System.out.println("请输入源文件路径");//--被复制的那个文件 String f = new Scanner(System.in).nextLine(); System.out.println("请输入新文件路径：");//--复制好的新文件 String t = new Scanner(System.in).nextLine(); //2.调用创建好的自定义方法完成文件复制 //ZFCopy(f,t);//用字符流完成文件的复制案例 ZJCopy(f,t);//用字节流完成文件的复制案例 } //利用字节流完成文件复制案例 private static void ZJCopy(String f, String t) { //1.定义在整个方法都生效的局部变量，注意手动初始化，引用类型默认值为null InputStream in = null; OutputStream out = null; //2.由于代码可能会发生异常，所以需要编写try-catch-finally结构 try{ //3.1创建高效字节输入流对象--FIS的参数是用户传入的源文件路径f in = new BufferedInputStream(new FileInputStream(f)); //3.2创建高效字节输出流对象--FOS的参数是用户传入的新文件路径t out = new BufferedOutputStream(new FileOutputStream(t)); //4.利用创建好的流对象完成业务 //4.1定义变量用来保存读到的数据 int b; //4.2循环读取源文件中的数据，只要不是-1，说明还有数据循环继续 while((b = in.read()) != -1){ //4.3将读到的数据写入到新文件中 out.write(b); } System.out.println("恭喜您！文件复制成功！"); }catch (Exception e){ System.out.println("很抱歉！文件复制失败！"); e.printStackTrace(); }finally { try { out.close(); } catch (IOException e) { e.printStackTrace(); } try { in.close(); } catch (IOException e) { e.printStackTrace(); } } } //利用字符流完成文件复制案例 private static void ZFCopy(String f, String t) { //1.定义在整个方法中都生效的局部变量，注意手动初始化，默认值为null Reader in = null; Writer out = null; //2.由于代码可能会发生异常，所以需要编写try-catch-finally结构 try{ //3.1创建高效字符输入流对象 in = new BufferedReader(new FileReader(f)); //3.2创建高效字符输出流对象 out = new BufferedWriter(new FileWriter(t)); //4.拿到流对象以后，就可以使用流对象来完成业务了 //4.1定义变量用来保存读到的数据 int b; //4.2循环读取源文件，直到返回值为-1，说明没有数据了，再结束循环 while ((b=in.read())!=-1) { //4.3将本轮循环中读到的数据写入到新文件中 out.write(b); } System.out.println("恭喜您！文件复制成功！"); }catch (Exception e){ System.out.println("很抱歉！文件复制失败！"); e.printStackTrace(); }finally { /*关流是有顺序的：如果有多个流，最后创建的流最先关闭 * 多条关流语句需要各自try-catch*/ try { out.close(); } catch (IOException e) { e.printStackTrace(); } try { in.close(); } catch (IOException e) { e.printStackTrace(); } } }}9 总结:IO的继承结构
1.主流分类
按照方向进行分类:输入流 输出流(相对于程序而言,从程序写数据到文件中是输出)按照传输类型进行分类:字节流 字符流组合: 字节输入流 字节输出流 字符输入流 字符输出流2.学习方法:在抽象父类中学习通用的方法,在子类中学习如何创建对象 3.字节输入流:
InputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileInputStream 子类,操作文件的字节输入流,普通类--BufferedInputStream 子类,缓冲字节输入流,普通类
4.字符输入流
Reader 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileReader,子类,操作文件的字符输入流,普通类--BufferedReader,子类,缓冲字符输入流,普通类
5.字节输出流:
OutputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileOutputStream 子类,操作文件的字节输出流,普通类--BufferedOutputStream 子类,缓冲字节输出流,普通类
6.字符输出流
Writer 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileWriter,子类,操作文件的字符输出流,普通类--BufferedWriter,子类,缓冲字符输出流,普通类
推荐学习：《java教程》
以上就是JAVA详细解析之IO流、File、字节流以及字符流的详细内容，更多请关注php中文网其它相关文章！
