IO流

流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流两种。IO流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地。虽然IO流通常与磁盘文件的存取有关，但是程序的源和目的地也可以是键盘、鼠标、内存或控制台等等。

Java由数据流处理输入/输出模式，程序从指向源的输入流中读取源中的数据，可以是文件、网络、压缩包或其他数据源。输出流的指向是数据要到达的目的地，程序通过向输出流中写入数据把信息传递到目的地。输出流的目标可以是文件、网络、压缩包、控制台和其他数据输出目标。

File类

File 类是java.io包中唯一代表磁盘文件本身的对象。File 类定义了一些与平台无关的方法来操作文件，可以通过调用File类中的方法，实现创建、删除、重命名文件等操作。File 类的对象主要用来获取文件本身的一些信息，如文件所在的目录、文件的长度、文件读写权限等。 数据流可以将数据写入到文件中，文件也是数据流最常用的数据媒体。

public class FileClassDemo {public static void main(String[] args) {//创建文件对象，将已有文件或者未创建的文件封装成对象File f1 = new File("fileDemo.txt");File f2 = new File("d:\\files\\","fileDemo2.txt");System.out.println(f1); //打印文件名System.out.println(f2); //打印文件路径//封装的是什么打印的就是什么}
}

文件的创建和删除

可以通过给定路径字符串转换为抽象路径名来创建一个File实例。

File f = new File("a.txt");

可以通过File对象的delete()方法将文件删除。

f.delete();

File对象功能：文件列表

static File[] listRoots()：返回系统盘列表
String[] list()：返回文件目录(包含隐藏文件)，只能获取文件名称
String[] list(FilenameFilter filter)：返回指定文件目录下的指定文件列表 
File[] listFiles()：返回文件目录名称和其他信息，如长度等

代码演示

import java.io.File;
import java.io.FilenameFilter;
public class FileClassDemo2 {public static void main(String[] args) {//listRootDemo();//listDemo();//listDemo2();listFilesDemo();}//获取系统盘列表public static void listRootDemo(){File[] files = File.listRoots();for(File file : files){System.out.println(file);}}//获取文件目录public static void listDemo(){File f = new File("d:\\");String[] names = f.list();for (String name : names){System.out.println(name);}}//获取指定文件目录下的文件列表public static void listDemo2(){File dir = new File("d:\\");String[] arr = dir.list(new FilenameFilter(){ //匿名内部类public boolean accept(File dir,String name){ //文件过滤return name.endsWith(".java");}});for(String name : arr){ //高级for循环System.out.println(name);}}//获取文件目录的名称和其他信息public static void listFilesDemo(){File dir = new File("d:\\");File[] files = dir.listFiles();for(File f : files){System.out.println(f.getName()+"..."+f.length());}}
}

File类的常用方法

①创建

boolean createNewFile()：在指定位置下创建文件，如果该文件已经存在，则不创建，返回false
boolean mkdir()：创建文件夹
boolean mkdirs()：创建多级文件夹

②删除

boolean delete()：删除失败返回false
boolean deleteOnExit()：在程序退出时删除指定文件

③判断

boolean canExecute()：判断文件是是否能执行
boolean exists()：判断文件是否存在
boolean isDirectory()：判断目录是否存在
boolean isFile()：判断是否是文件

④获取

String getName()：获取文件名
String getPath()：获取路径
String getParent()：获取父目录，该方法返回的是绝对路径的父目录，如果获取相对路径则返回null
String getAbsolutePath()：获取绝对路径，文件若不存在则获取对应的文件夹目录
long lastModified()：获取文件最后的修改时间
long length()：获取文件大小

代码演示

import java.io.File;
import java.io.IOException;
public class FileClassDemo3 {public static void main(String[] args)throws IOException{method();}public static void method()throws IOException {//创建文件对象File f = new File("e:\\files\\new.txt");f.deleteOnExit(); //在程序退出时就删除System.out.println("createNewFile: "+f.createNewFile());System.out.println("delete: "+f.delete());//创建文件夹File dir = new File("e:\\dir");System.out.println("mkdir: "+dir.mkdir());//创建多级文件夹File dirs = new File("e:\\a\\b\\c");System.out.println("mkdirs: "+dir.mkdirs());}
}

字符流Reader和Writer

既然IO流是用于操作数据的，那么数据最常见的形式就是文件
先以操作文件为主的来演示
需求：在硬盘上创建一个文件并写入一些文字数据

package cn.itcast.demo;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {public static void main(String[] args)throws IOException{//创建FileWriter对象，明确文件的存放位置FileWriter fw = new FileWriter("e:\\files\\demo.txt");//写入数据fw.write("Hello World");//刷新流对象中的数据fw.flush();//关闭流资源(在关闭之前会刷新一次缓冲区的数据)fw.close();}
}

IO异常的处理方式：

package cn.itcast.demo;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo2 {public static void main(String[] args) {FileWriter fw = null;try {fw = new FileWriter("Hello Java");}catch(IOException e) {e.printStackTrace();}finally {try {if(fw != null) {fw.close();}}catch(IOException e) {e.printStackTrace();}}}
}

演示对已有文件的续写

可以通过在创建写入流对象时，往传递一个true参数，代表不覆盖已有文件，并在已有文件的末尾出进行数据续写

package cn.itcast.demo;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo3 {public static void main(String[] args)throws IOException {//演示对已有文件的续写,传入一个true参数代表不覆盖内容FileWriter fw = new FileWriter("e:\\files\\demo.txt",true);fw.write("\r\nHello World"); //写入文本fw.flush(); //刷新流数据fw.close(); //关闭流资源}
}

文本文件读取方式一
通过用于读取文件的read方法，一次读取一个字符。为了方便演示，这里直接在主函数抛出IO异常。

package cn.itcast.demo2;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo {public static void main(String[] args)throws IOException {//声明读取流对象，与指定文件相关联FileReader fr = new FileReader("e:\\files\\demo.txt");//读取文件int ch = 0;while((ch = fr.read()) != -1) {System.out.print((char)ch+" ");}//关闭读取流资源fr.close();}
}

文本文件读取方式二
通过字符数组进行读取

package cn.itcast.demo2;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo2 {public static void main(String[] args)throws IOException {//声明文本读取流对象，与指定文件相关联FileReader fr = new FileReader("e:\\files\\demo.txt");//声明一个字符数组char[] buf = new char[1024];int len = 0;//读取数据while((len = fr.read(buf)) != -1) {System.out.println(new String(buf,0,len));}}
}

练习：读取一个.java文件，并打印在控制台上

package cn.itcast.demo2;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderTest {public static void main(String[] args)throws IOException {//声明FileReader对象，与指定文件相关联FileReader fr = new FileReader("e:\\files\\demo.java");char[] buf = new char[1024];int len = 0;while((len = fr.read(buf)) != -1) {System.out.println(new String(buf,0,len));}fr.close();}
}

练习：复制文本文件
其实就是将一个文本文件的数据存储到另一个文本文件中
步骤：

1. 获取写入流对象，并与目的文件相关联
2. 获取读取流对象，并与源文件相关联
3. 开始读取源文件，并写入目的文件，写入时要记得刷新
4. 关闭读取流和写入流资源

package cn.itcast.demo2;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test {public static void main(String[] args) {FileReader fr = null;FileWriter fw = null;try {fr = new FileReader("e:\\files\\demo.txt");fw = new FileWriter("e:\\files\\demo2.txt");char[] buf = new char[1024];int len = 0;while((len = fr.read(buf)) != -1) {fw.write(buf);fw.flush();}fr.close();fw.close();}catch(IOException e) {e.printStackTrace();}
}

字符流缓冲区

字符读取流缓冲区BufferedReader

该缓冲区提供了一个一次读一行的方法readLine()
方便于对文本数据的读取
当返回null时，表示读到了文件末尾
readLine()方法返回的时候只返回回车符之前的数据内容，并不返回回车符

package cn.itcast.demo2;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderDemo {public static void main(String[] args)throws IOException {//声明文件读取流对象FileReader fr = new FileReader("e:\\files\\demo.java");//将读取流对象作为参数传递给缓冲区对象的构造方法BufferedReader bufr = new BufferedReader(fr);String line = null;while((line = bufr.readLine()) != null) {System.out.println(line);}//关闭缓冲区读取流bufr.close();}
}

自定义一个字符读取流缓冲区BufferedReader

readLine()方法原理:
无论是读一行，获取多个字符。其实最终都是在硬盘上一个一个读取。
所以最终还是使用read方法一次读取一个的方法
明确了BufferedReader的readLine方法的原理后，可以自定义一个类包含一个功能和readLine方法一致的方法。

普及一个知识：

在Windows中，
‘\r’ 回车，回到当前行的行首，而不会换到下一行，如果接着输出的话，本行以前的内容会被逐一覆盖；
‘\n’ 换行，换到当前位置的下一行，而不会回到行首。

package cn.itcast.demo2;
import java.io.FileReader;
import java.io.IOException;
public class MyBufferedReaderDemo {public static void main(String[] args)throws IOException {MyBufferReader Mybufr = new MyBufferReader(new FileReader("e:\\files\\demo.java"));char[] buf = new char[1024];String line = null;while((line = Mybufr.MyreadLine()) != null) {System.out.println(line);}Mybufr.Myclose();}
}
class MyBufferReader {private FileReader fr;MyBufferReader(FileReader fr) {this.fr = fr;}//自定义一次读取一行的方法public String MyreadLine()throws IOException {//定义一个容器StringBuffer sb = new StringBuffer();int ch = 0;while((ch = fr.read()) != -1){if(ch == '\r'){ //回车continue;}else if(ch == '\n'){ //换行sb.toString();}else{sb.append((char)ch);}}//为了返回数据的最后一行 因为最后一行有可能没有换行符\nif(sb.length() != 0){return sb.toString();}return null;}public void Myclose()throws IOException{fr.close();}
}

字符写入流缓冲区BufferedWriter

该缓冲区提供了一个换行的方法newLine();

package cn.itcast.demo;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterDemo {public static void main(String[] args)throws IOException {FileWriter fw = new FileWriter("e:\\files\\new.txt");BufferedWriter bufw = new BufferedWriter(fw);bufw.write("hello world");//换行bufw.newLine();bufw.write("hello java");bufw.close();}
}

练习：通过字符流缓冲区来复制一个文本文件

package cn.itcast.demo2;
import java.io.*;
public class Test2 {public static void main(String[] args) {BufferedWriter bufw = null;BufferedReader bufr = null;try {bufr = new BufferedReader(new FileReader("e:\\files\\new.txt"));bufw = new BufferedWriter(new FileWriter("e:\\files\\new2.txt"));String line = null;while((line = bufr.readLine()) != null){bufw.write(line);bufw.newLine();bufw.flush();}bufr.close();bufw.close();}catch(IOException e){e.printStackTrace();}}
}

带行号打印的字符读取流缓冲区LineNumberReader

它是BufferedReader的子类
跟踪行号的缓冲区输入流，此类定义了两个重要的方法

setLineNumber()：设置当前行号
getLineNumber()：获取当前行号

代码演示

import java.io.*;
public class LineNumberReaderDemo {public static void main(String[] args)throws IOException{FileReader fr = new FileReader("e:\\files\\demo.java");LineNumberReader lnr = new LineNumberReader(fr);String line = null;while((line = lnr.readLine()) != null) {//带着行号打印System.out.println(lnr.getLineNumber() + ":" + line);}    lnr.close();}
}

装饰设计模式

当想要对已有的对象进行功能增强时，可以自定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。那么这个自定义的类就称为装饰类。
装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象的功能，提供更强的功能.

例如：
体系一

|--MyReader //专门用于读取的类|--MyTextReader|--MyBufferTextReader|--MyMediaReader|--MyBufferMediaReader|--MyDataReader|--MyBufferDataReader

发现三个子类都有缓冲的共性，那么可以将其进行抽取封装

class MyBufferReader {MyBufferReader(MyBufferTextReader text) {}MyBufferReader(MyBufferMediaReader media) {}...
}

上面这个类扩展性很差
找到其参数的共同类型，他们都有一个父类MyReader
那么可以通过多态的形式，提高扩展性

class MyBufferReader extends MyReader {MyBufferReader(MyReader r) {}
}

最终变成体系二

MyReader //专门用于读取的类|--MyTextReader|--MyMediaReader|--MyDateReader|--MyBufferDemo

我们将这种方式称之为装饰模式。

可以发现，装饰比继承更加灵活，避免了继承体系的雍冲。而且降低了类与类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的功能是相同的，只不过提供了更强的功能。
所以装饰类和被装饰类通常都属于同一个体系中。

练习：用装饰类模拟一下BufferedReader

package cn.itcast.demo2;
import java.io.*;
public class MyBufferedReaderDemo2 {public static void main(String[] args)throws IOException{FileReader fr = new FileReader("e:\\files\\demo.txt");//通过装饰类，这里的构造方法不仅可以接收文本读取流对象//还可以接收其他的读取流对象，提高了扩展性和代码的复用性MyBufferedReader2 mybuf = new MyBufferedReader2(fr);String line = null;while((line = mybuf.myreadLine()) != null) {System.out.println(line);}mybuf.myClose();}
}
class MyBufferedReader2 extends Reader {private Reader fr;MyBufferedReader2(Reader fr) {this.fr = fr;}//自定义一次读取一行的方法public String myreadLine()throws IOException {//定义一个临时容器，原BufferReader封装的是字符数组//为了方便，定义一个Stringbuiler容器，因为最终还是要讲数据变成字符串StringBuilder sb = new StringBuilder();int ch = 0;while((ch = fr.read())!=0) {if(ch == '\r')continue;if(ch == '\n')return sb.toString();elsesb.append((char)ch);}//为了返回数据的最后一行 因为最后一行有可能没有换行符\nif(sb.length() != 0)return sb.toString();return null;}public void myClose()throws IOException {fr.close();}@Overridepublic int read(char[] cbuf, int off, int len) throws IOException {return 0;}@Overridepublic void close() throws IOException {}

字节流InputStream和OutputStream

FileOutputStream用于写入诸如图像数据的原始字节流

package cn.itcast.demo3;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {public static void main(String[] args)throws IOException {//声明字节写入流对象FileOutputStream fos = new FileOutputStream("e:\\files\\demo.txt");//写入数据fos.write("Hello".getBytes());//关闭流资源fos.close();}
}

FileInputStream用于读取诸如图像数据的原始字节流。

package cn.itcast.demo3;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamDemo {public static void main(String[] args)throws IOException {//readFile();//readFile2();readFile3();}//文本读取方式一public static void readFile()throws IOException {//创建字节读取流对象，与指定文件相关联FileInputStream fis = new FileInputStream("e:\\files\\Demo.txt");int ch = 0;while((ch = fis.read()) != -1) {System.out.println((char)ch);}fis.close();}//文本读取方式二public static void readFile2()throws IOException{FileInputStream fis = new FileInputStream("e:\\files\\demo.txt");//定义字节数组byte[] buf = new byte[1024];int len = 0;while((len = fis.read(buf)) != -1){//将字节数组变成字符串，使用new String()System.out.println(new String(buf,0,len));}}//文本读取方式三public static void readFile3()throws IOException{FileInputStream fis = new FileInputStream("e:\\files\\demo.txt");//通过available获取文件的字节个数int num = fis.available();//定义一个刚刚好的缓冲区byte[] buf = new byte[num];//读取数据fis.read(buf);//将字节数组变成字符串打印System.out.println(new String(buf));fis.close();}
}

字节流练习：拷贝一张图片
思路：
1，用字节读取流对象和图片相关联
2，用字节写入流对象创建一个图片文件，用于存储获取到的图片
3，通过循环读写，完成数据的存储
4，关闭资源

package cn.itcast.demo3;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {public static void main(String[] args)throws IOException {//声明字节读取流对象，与源文件相关联FileInputStream fis = new FileInputStream("e:\\files\\Demo.png");//声明字节写入流对象，与目的文件相关联FileOutputStream fos = new FileOutputStream("e:\\files\\Demo2.png");//定义一个刚刚好的缓冲区byte[] buf = new byte[fis.available()];while((fis.read(buf)) != -1){fos.write(buf);}fis.close();fos.close();}
}

字节流缓冲区

• 字节读取流缓冲区BufferedInputStream
• 字节写入流缓冲区BufferedOutputStream

例如：通过字节流缓冲区实现MP3的复制

package cn.itcast.demo3;
import java.io.*;
public class BufferedStreamDemo {public static void main(String[] args)throws IOException {//使用字节缓冲区复制.mp3文件的复制FileInputStream fis = new FileInputStream("e:\\files\\demo.mp3");FileOutputStream fos = new FileOutputStream("e:\\files\\demo2.mp3");//将字节读取流作为参数传递给缓冲区对象的构造方法BufferedInputStream bufis = new BufferedInputStream(fis);//将字节写入流作为参数传递给缓冲区对象的构造方法BufferedOutputStream bufos = new BufferedOutputStream(fos);int by = 0;while((by = bufis.read()) != -1) {bufos.write(by);}bufis.close();bufos.close();}
}