1.流的分类
按照数据流向的不同：输入流和输出流
按照处理数据的单位不同：字节流（（非文本文件）视频、音频、图像）、字符流（文本文件）
按照角色的不同：节点流和处理流
2.IO体系
抽象基类 节点流 缓冲流（处理流的一种，可以提高文本操作的效率）
InputStream FileInputStream BufferedInputStream
OutputStream FileOutputStream BufferedOutputStream
Reader FileReader BufferedReader
Writer FileWriter BufferedWriter
public class FileInputOutputStream {
// 从硬盘中存在的文件，读取内容加载到程序中，FileInputStream
// 要读取的文件一定要存在，否则抛一个异常FileNotFoundException
@Test
public void testFileInputStream1() throws Exception{
// 1、创建一个File类的对象
File file = new File("hello.txt");
// 2、创建一个FileInputStream类的对象
FileInputStream fis = new FileInputStream(file);
// 3、调用FileInputStream中的方法，实现file文件的读取
// read()方法：可以读取文件中的一个字节 当执行到文件结尾时，返回-1
/* int b = fis.read();
// 判断有没有读取到文件结尾
while(b!=-1){
System.out.println((char)b);
b = fis.read();
}*/
int b;
while((b=fis.read())!=-1){
System.out.println((char)b);
}
// 4、关闭相应的流
fis.close();
}
// 使用try-catch-finally处理异常：保证流的关闭一定可以执行
@Test
public void testFileIntputStream2(){
File file = new File("hello.txt");
FileInputStream fis = null;
try {
fis = new FileInputStream(file);
int b;
while((b=fis.read())!=-1){
System.out.println((char)b);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
// 不管是否发生异常，finally中的代码一定会执行
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 将读取到的数据填充到字节数组中
@Test
public void testFileInputStream3(){
FileInputStream fis = null;
try {
File file = new File("hello.txt");
// 将file对象作为FileInputStream的形参传进来
fis = new FileInputStream(file);
// 读取的数据要写入的数组
byte[] b = new byte[5];
// 每次读入到byte中字节的长度
int len;
while ((len=fis.read(b))!=-1) {
for (int i = 0; i < len; i++) {
System.out.print((char)b[i]);
}
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// FileOutputStream
@Test
public void testFileOutputStream(){
// 1、创建一个File对象，指定要写入的文件位置
// 输出的物理文件也可以不存在，当执行过程中，如果不存在，则自动创建，若存在，则将原来的文件覆盖
File file = new File("hello2.txt");
// 2、创建一个FileOutputStream对象，将file对象作为形参传递给FileOutputStream的构造器。
FileOutputStream fos = null;
try {
fos=new FileOutputStream(file);
// 3、执行写入操作
fos.write(new String("hello").getBytes());
} catch (Exception e) {
e.printStackTrace();
}finally {
// 4、关闭输出流（释放资源）
if (fos!=null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
// 从硬盘读取一个文件并写入到另一个位置（文件的复制）
@Test
public void testFileInputOutputStream(){
// 1、提供读入、写出的文件
File file1 = new File("hello.txt");
File file2 = new File("hello3.txt");
// 2、提供相应的输入流和输出流
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(file1);
fos = new FileOutputStream(file2);
byte[] b = new byte[20];
int len;
// 3、实现文件的复制
while ((len=fis.read(b))!=-1) {
System.out.println(len);
// 从头开始写 写的长度是len
fos.write(b, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} 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();
}
}
}
}
// 实现文件复制的方法
public static void copyFile(String src,String dest){
// 1、提供读入、写出的文件
File file1 = new File(src);
File file2 = new File(dest);
// 2、提供相应的输入流和输出流
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(file1);
fos = new FileOutputStream(file2);
byte[] b = new byte[20];
int len;
// 3、实现文件的复制
while ((len=fis.read(b))!=-1) {
// 从头开始写 写的长度是len
fos.write(b, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} 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();
}
}
}
}
@Test
public void testCopyFile(){
copyFile("1.jpg", "2.jpg");
}
}
public class TestBuffered {
// 使用BufferedInputStream和BufferedOutputStream实现非文本复制
@Test
public void testBufferedInputOutputStream(){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
// 1.提供读写的文件
File file1 = new File("1.jpg");
File file2 = new File("3.jpg");
// 2.创建响应的节点流 FileInputStream FileOutputStream
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
// 3.将创建的节点流对象作为形参传递给缓冲流的构造器
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
// 4.具体实现文件复制的操作
byte[] b = new byte[1024];
int len;
while ((len=bis.read(b))!=-1) {
// 写数据
bos.write(b, 0, len);
// 清除缓存
bos.flush();
}
} catch (Exception e) {
e.printStackTrace();
}finally {
// 5.释放资源
if (bis!=null) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bos!=null) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Test
public void testBufferReader(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
File file = new File("oop.txt");
File file1 = new File("oop2.txt");
FileReader fr = new FileReader(file);
FileWriter fw = new FileWriter(file1);
br = new BufferedReader(fr);
bw = new BufferedWriter(fw);
/*char[] c = new char[1024];
int len;
while ((len=br.read(c))!=-1) {
String str = new String(c, 0, len);
bw.write(str);
bw.flush();
}*/
String str;
while ((str=br.readLine())!=null) {
bw.write(str);
bw.newLine();// 自动换行
bw.flush();
}
} catch (Exception e) {
e.printStackTrace();
}finally {
if (bw!=null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (br!=null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}