1.流的分类
1)按照方向分类:输入流 输出流 2)按照操作的单位分类:字节流 字符流 3)组合情况:字节输入流 字节输出流 字符输入流 字符输出流
2.字节输入流
1)抽象父级:InputStream–不能实例化 2)普通子级:
-
FileInputStream–操作文件的字节输入流 构造方法参数:File file / String pathname
-
BufferedInputStream–高效字节输入流 构造方法参数:InputStream,但无法创建抽象父级对象,所以传的是FileInputStream
3.字节输出流
1)抽象父级:OutputStream–不能实例化 2)普通子级:
-
FileOutputStream–操作文件的字节输出流 构造方法参数:File file / String pathname 注意:默认存在一个参数boolean append,默认值为false,也就是覆盖输出 如果将FileOutputStream构造函数的第2个参数appned设置为true,就会实现追加输出的效果
-
BufferedOutputStream–高效字节输出流 构造方法参数:OutputStream,但无法创建抽象父级对象,所以传的是FileOutputStream
4.字符输入流
1)抽象父级:Reader 2)普通子级:
-
FileReader–操作文件的字符输入流 构造方法参数:File file /String filename
-
BufferedReader–高效字符输入流 构造方法参数:Reader,但无法创建抽象父级对象,所以传的是FileReader
5.字符输出流
1)抽象父级:Writer 2)普通子级:
-
FileWriter–操作文件的字符输出流 构造方法参数:File file /String filename 注意:默认存在一个参数boolean append,默认值为false,也就是覆盖输出 如果将FileWriter构造函数的第2个参数appned设置为true,就会实现追加输出的效果
-
BufferedWriter–高效字符输出流 构造方法参数:Writer,但无法创建抽象父级对象,所以传的是FileWriter
package cn.tedu.file;
import java.io.*;
/*本类用于练习字节输入流*/
public class TestIn {
public static void main(String[] args) {
// method();//字节流的读取
method2();
}
private static void method2() {
//定义一个在本方法都生效的局部变量,注意手动初始化,引用类型的默认值是null。
BufferedInputStream in=null;
//1.创建流对象
//InputStream s =
//new BufferedInputStream(new FileInputStream("D:\\ready\\1.txt"));
try {
in =
new BufferedInputStream(new FileInputStream(new File("D:\\ready\\1.txt")));
//2.使用流对象
int b;
while ((b=in.read())!=-1){//将本轮循环读到的数据赋值给b,只要不是-1,继续循环
System.out.println(b);//打印本轮读到的数据
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
//关闭流对象
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试字节流的读取
private static void method() {
//1.创建流对象,注意InputStreamd是抽象父类,不可以实例化
//Alt+Shift+向上,向上移动本行代码
//File file = new File("D:\\ready\\1.txt");
// String path="D:\\ready\\1.txt";
/**
* 创建一个在本方法中都生效的局部变量
* 注意手动初始化,引用类型默认值为null;
*/
InputStream in2 =null;
try {
//InputStream in=new FileInputStream(new File("D:\\ready\\1.txt"));
in2=new FileInputStream("D:\\ready\\1.txt");
//2.使用流对象:读取指定文件中的数据
/*read()每次调用都会读取一个字节,如果读到了文件数据的末尾,返回-1
* 这个方法的返回值类型是int,所以会查找指定字符对应的编码打印出来*/
// System.out.println(in2.read());
// System.out.println(in2.read());
// System.out.println(in2.read());
// System.out.println(in2.read());
// System.out.println(in2.read());
//2.2优化代码,使用循环读取文件
//定义变量,用来保存本次读到的数据
//读取数据,只要读到的数据不等于-1,说明还有数据,继续循环
int b;
while ((b=in2.read())!=-1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();//默认写法:打印错误信息
}finally {
/*finally{}代码块是try-catch结构的第三个部分
* 这部分不论是否捕获到异常,都一定会执行,所以常用来关流操作*/
//3.释放资源,流资源用完必须释放
try {
in2.close();//关流,显示不能创建局部变量,把变量提到外面,并且注意初始化。
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.tedu.file;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*本类用于测试字符输入流reader的读取操作*/
public class TestIn2 {
public static void main(String[] args) {
//method();//用于测试普通字符流
Method2();//用于测试高效字符流
}
private static void Method2() {
BufferedReader in2 = null;
// BufferedReader in = new BufferedReader(new FileReader("D:\\ready\\1.txt"));
try {
in2 = new BufferedReader(new FileReader("D:\\ready\\1.txt"));
while (true){
int b=in2.read();
if(b==-1){
break;
}
System.out.println(b);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
in2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试普通字符输入流的读取操作
private static void method() {
FileReader in2 = null;
try {
//1.创建流对象
in2 = new FileReader("D:\\ready\\1.txt");
// FileReader in=new FileReader(new File("D:\\ready\\1.txt"));
//使用流
int b;
while ((b = in2.read()) != -1) {
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
//关流
in2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.tedu.file;
import java.io.*;
/**
* 本类用于联系字节输出OutputStream
*/
public class TestOut {
public static void main(String[] args) {
// nethod1();//用于测试普通字节输出流
method2();//用来测试高效字节输出流
}
private static void method2() {
BufferedOutputStream out=null;
try {
//1.1创建高效字节输出流对象--覆盖输出
// BufferedOutputStream o1=
// new BufferedOutputStream(new FileOutputStream(new File("D:\\ready:\\1.txt")));
// BufferedOutputStream o2=
// new BufferedOutputStream(new FileOutputStream(("D:\\ready:\\1.txt")));
//1.2创建高效字节输出流对象--追加输出
// BufferedOutputStream out =
// new BufferedOutputStream(new FileOutputStream(new File("D:\\ready\\1.txt"), true));
out=
new BufferedOutputStream(new FileOutputStream("D:\\ready\\1.txt", true));
out.write(100);
out.write(97);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试普通字节输出流FileOutputStream
private static void nethod1() {
FileOutputStream out=null;
try {
//1.创建对象
// FileOutputStream out= new FileOutputStream(new File("D:\\ready\\2.txt"));//覆盖输出
// out = new FileOutputStream("D:\\ready\\1.txt");//覆盖输出
// out=new FileOutputStream(new File("D:\\ready\\1.txt"), true);//追加输出
out=new FileOutputStream("D:\\ready\\1.txt", true);//追加输出
//2.使用流对象
out.write(100);//对应ASCII码表中的
out.write(100);
out.write(100);
//文件中是aaa
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package cn.tedu.file;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* 本类用于练习字符输出流writer
*/
public class TestOut2 {
public static void main(String[] args) {
// method1();//用于测试普通字符输出流
method2();//用于测试高效字符输出流
}
//本方法用于测试高效字符输出流
private static void method2() {
BufferedWriter out = null;
try {
// out = new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt")));
// out=new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt")));
// out=new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt"), true));
// out=new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt"), true));
out = new BufferedWriter(new FileWriter("D:\\ready\\1.txt", true));
out.write("秦晓燕是仙女");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试普通字符输出流
private static void method1() {
FileWriter out = null;
try {
// //1.1创建字符输出流覆盖输出
// out = new FileWriter("D:\\ready\\1.txt");
// out=new FileWriter(new File("D:\\ready\\1.txt"));
// //1.2创建字符输出流对象---追加输出
// out=new FileWriter(new File("D:\\ready\\1.txt"), true);
out = new FileWriter("D:\\ready\\1.txt", true);
out.write(100);
out.write("h");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
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) {
InputStream in=null;
OutputStream out=null;
try {
in=new BufferedInputStream(new FileInputStream(f));
out= new BufferedOutputStream(new FileOutputStream(t));
//4.1定义变量用来保存读到的数据
int b;
//4.2循环读取源文件中的数据,只要不是-1,说明还有数据循环继续
while ((b=in.read())!=-1){
//4.3将读到的数据写入到新文件中
out.write(b);
}
System.out.println("恭喜您,复制成功");
} catch (Exception e) {
e.printStackTrace();
System.out.println("很遗憾,复制失败");
}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){
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();
}
}
}
}