IO流总结

/** * FileWriter 是一个写入字符文件的类 extends OutputStreamWriter * 此类的构造方法默认字符和默认字节缓冲区的大小都是可接受的;文件是否可用或是可以被创建的取决于平台,如果是开发文件写入,在这种情况下,此类中的构造方法将失败 * 构造方法： * public FileWriter(String name)  * 参数是文件路径,(例如:new FileWriter("D:\\a.txt")) * 路径说明： 绝对路径->从盘符开始,直到文件名完整路径("D:\\abc\\...\\a.txt") *          相对路径->相对当前文件夹开始("a.txt") * 使用：   1.根据指定的文件路径名找到对应的文件,如果文件不存在,将会自动创建->底层会(new FileOutputStream(String name)) *     2.它的方法都是extends OutputStreamWriter --> (append, append, append, write, write) * flush和close方法说明：当写入数据的是先把数据写到字符缓冲区,只有flush的时候才会写入文件中;当调用close的时候,在关闭流之前会先调用flush,所以说,在非长时期flush可以省略直接close * FileWriter的五种重载方法： * void write(String name) 写入一个字符串数据 * void write(String name,int index,int len) 写入一个字符串中的一部分,从哪里开始,写几个. * void write(int或char) 这里写int类型好处是即可以写char类型的数据,也可以写char对应的int类型的值.'a'->97 * void write(char[] chs) 写一个字符数组数据void write(char[] chs,int index,int len) 写一个字符数组的一部分,index开始,len结束 * ---------------------------------------------------------------------------------------------------------------- * FileReader也是一个类,是用来读取文件的,是一种字符输出流extends InputStreamReader * FileReader用于读取字符流,要读取字节流要考虑使用FileInputStream * 构造方法跟FileWrider一样,就是一个写一个读 * 注意的是：FileReader对象fr.read是读取单个字符返回值是int * 读取单个字符： * int line = 0; * while((line = fr.read()) != -1) //当读取返回不等于-1则输出 * 读取字符数组： * char[] buf = new char[num]; * int len = 0; * while((line=fr.read(buf)) != -1){ * String str = new String(buf,0,len); * } */public class FileWriteDemo {public static void main(String[] args) throws IOException {methodFileWriterFunction();methidFileReaderFunction();}private static void methidFileReaderFunction() throws IOException {FileReader fr = new FileReader("a.txt");char[] buf = new char[20];int len = 0;while((len = fr.read(buf)) != -1){String string = new String(buf,0,len);System.out.println(string);//abc m lov hg}}private static void methodFileWriterFunction() throws IOException {FileWriter writer = new FileWriter("a.txt");writer.write("abc");writer.write("\t");writer.append('m');writer.write("\t");writer.write("iloveyou", 1, 3);writer.write("\t");char[] ch = { 'h', 'g' };writer.write(ch);writer.close();/* * abc m lov hg */}}

/** * BufferedWrider也是一个输出流,但它的底层有一个默认是8192的char[]字符数组,当做缓冲使用,不用单独new char[]数组了; * 使用： * 1.首先new一个普通的FileWriter,2.将这个普通FileWriter包装为字符缓冲BufferedWriter * 自己的方法： * newLine();写入一个行分隔符; * 其他跟FileWriter方法一样. * ------------------------------------------------------------------------------------- * BufferedReader也是一个输入流,跟FileReader差不多,也是读取文件的,底层也有一个8192的char[]字符数组,同样作为缓冲区 * 使用：如下. * 自己的方法： * String readLine(); 读取一行 */public class BufferedWriteDemo {public static void main(String[] args) throws IOException {methodBufWriter();methodBufReader();}private static void methodBufReader() throws IOException {FileReader reader = new FileReader("a.txt");BufferedReader bufferedReader = new BufferedReader(reader);//char[] buf = new char[20];//int len = 0;//while((len = bufferedReader.read(buf)) != -1){//System.out.println(new String(buf,0,len));//}String line = null;while((line = bufferedReader.readLine()) != null){System.out.println(line);}}private static void methodBufWriter() throws IOException {FileWriter writer = new FileWriter("a.txt");BufferedWriter bufferedWriter = new BufferedWriter(writer);bufferedWriter.write("abc");bufferedWriter.newLine();bufferedWriter.write("love", 3, 1);bufferedWriter.close();//abc e}}//BufferedWriter底层声明的8192字符缓冲区class BufferedWriterCharArr{//private static int defaultCharBufferSize = 8192;//public BufferedWriter(Writer out, int sz) {//        super(out);//        if (sz <= 0)//            throw new IllegalArgumentException("Buffer size <= 0");//        this.out = out;//        cb = new char[sz];//        nChars = sz;//        nextChar = 0;////        lineSeparator = java.security.AccessController.doPrivileged(//            new sun.security.action.GetPropertyAction("line.separator"));//    }}

/** * OutputStream 是字节输出流：把内存中的数据,以字节的方式,写入到文件中保存 * java.io.OutputStream 是所有字节输入流的父类  * 读、写的过程：java程序-->JVM-->操作系统-->方法-->读写 * 成员方法： * abstract void write(int b) 写入一个字节 * void write(byte[] b) 写入字节数组 * void write(byte[] b, int off, int len) 写入字节数组,off是开始的索引,len写几个 * void close() 关闭此输出流并释放与此流有关的所有系统资源。 * void flush()   刷新此输出流并强制写出所有缓冲的输出字节。 * -------------------------------------------------------------------- * java.io.FileOutputStream:文件字节输出  extends OutputStream * FileOutputStream(File file) 创建一个指定File对象表示的文件中写入数据的文件输出流. * FileOutputStream(String name) 创建一个文件路径 * 构造方法： * 1.如果构造方法中传递的目的地不存在,则会创建一个文件;如果目的地已经存在,会覆盖 * 续写(追加写)和换行 * 换行:可以使用换行符号 * Windows:\r\n * linux:/n * mac:/r * ------------------------------------------------------------------- * java.io.BufferedOutputStream:字节缓冲输出流  extends OutputStream * 有继承自父类OutputStream的成员方法 * abstract  void write(int b) 写入一个字节 * void write(byte[] b) 写入字节数组 * void write(byte[] b, int off, int len) 写入字节数组,off是开始的索引,len写几个 * void close() 关闭此输出流并释放与此流有关的所有系统资源。 * void flush()   刷新此输出流并强制写出所有缓冲的输出字节。 * 构造方法: * BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。  * BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。  * 参数: * int size:指定的底层缓冲区(字节数组)的大小 * OutputStream out:字节输出流 * 我们可以传入FileOutputStream,就会给FileOutputStream增加一个缓冲区,提高FileOutputStream读取数据的效率 * ==================================================================== * java.io.InputStream：是所有字节输入流的父类 * 共性的成员方法: * int read():读取一个字节并返回，没有字节返回-1. * int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。 * void close() 关闭此输入流并释放与该流关联的所有系统资源。  * -------------------------------------------------------------------- * java.io.FileInputStream 文件字节输入流 extends InputStream * 构造方法： * FileInputStream(File file) 字节输入流对象 * FileInputStream(String name) 文件路径 * 读取数据read(byte[] byte) 返回int：读取一定的字节数,并存到字节数组中 * 明确两件事件： * 1.方法返回值int是什么：是每次读取的有效字节个数 * 2.byte[]作用是起到缓冲作用 * --------------------------------------------------------------------- * java.io.BufferedInputStream 字节缓冲流 extends InputStream * 继续自父类InputStream中的成员方法 * int read():读取一个字节并返回，没有字节返回-1. * int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。 * void close() 关闭此输入流并释放与该流关联的所有系统资源。  * 使用如下 */public class OutputStreamDemo {public static void main(String[] args) throws IOException {methodFileOutputStream();methodBufFileOutStream();methodFileInputStream();methodBufInputStream();}private static void methodBufInputStream() throws IOException {FileInputStream fis = new FileInputStream("b.txt");BufferedInputStream bis = new BufferedInputStream(fis);byte[] bytes = new byte[1024];int len = 0;while((len = bis.read(bytes)) != -1){System.out.println(new String(bytes,0,len));//这是字符缓冲流}}private static void methodBufFileOutStream() throws IOException {FileOutputStream fos = new FileOutputStream("b.txt");BufferedOutputStream bos = new BufferedOutputStream(fos);bos.write("这是字符缓冲流".getBytes());bos.close();}private static void methodFileInputStream() throws IOException {FileInputStream inputStream = new FileInputStream("b.txt");byte[] bytes = new byte[10];int len = 0;while((len = inputStream.read(bytes)) != -1){System.out.println(new String(bytes,0,len));}}private static void methodFileOutputStream() throws FileNotFoundException, IOException {FileOutputStream outputStream = new FileOutputStream("b.txt");byte[] bytes = new byte[]{'a','b','3'};outputStream.write(bytes);bytes = "你好".getBytes();outputStream.close();}}

/** * java.io.InputStreamReader extends Reader 字符流 * 作用:是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。 *  * 继承自父类Reader中的成员方法 * int read() 读取单个字符。  *  int read(char[] cbuf) 将字符读入数组。  *  abstract  void close() 关闭该流并释放与之关联的所有资源。  *   *  构造方法: *  InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。 *  InputStreamReader(InputStream in, String charsetName)  创建使用指定字符集的 InputStreamReader。 *  参数: *  InputStream in:字节输入流,用来读取文件中保存的字节 *  String charsetName:编码表的名称,可以是"GBK","gbk","UTF-8","utf-8",...不区分大小写;不指定默认为系统编码(GBK) *   *  使用步骤: *  1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源 *  2.创建转换流InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称 *  3.使用InputStreamReader中的方法read,读取文件 *  4.释放资源 *   *  注意事项:指定的编码表名称要和读取的文件编码相同,否则会发生乱码 */public class Demo02InputStreamReader {public static void main(String[] args) throws IOException {read_gbk();read_utf8();}/* * 使用InputStreamReader读取UTF-8格式的文件 */private static void read_utf8() throws IOException {//1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源FileInputStream fis = new FileInputStream("utf-8.txt");//2.创建转换流InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//你好//InputStreamReader isr = new InputStreamReader(fis,"GBK");//浣犲ソ//3.使用InputStreamReader中的方法read,读取文件char[] cs = new char[1024];int len = 0;while((len = isr.read(cs))!=-1){System.out.println(new String(cs, 0, len));}//4.释放资源isr.close();}/* * 使用InputStreamReader读取GBK格式的文件 */private static void read_gbk() throws IOException {//1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源FileInputStream fis = new FileInputStream("gbk.txt");//2.创建转换流InputStreamReader对象,构造方法中传递字节输入流和指定的编码表名称InputStreamReader isr = new InputStreamReader(fis,"GBK");//你好//InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//???//3.使用InputStreamReader中的方法read,读取文件int len = 0;while((len = isr.read())!=-1){System.out.println((char)len);}//4.释放资源isr.close();}}

/** * java.io.OutputStreamWriter extends Writer * 作用:是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。 *  * 继承自父类Writer的成员方法 * abstract  void close() 关闭此流，但要先刷新它。  *abstract  void flush() 刷新该流的缓冲。  *void write(char[] cbuf) 写入字符数组。  *abstract  void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。  *void write(int c) 写入单个字符。  *void write(String str) 写入字符串。  *void write(String str, int off, int len) 写入字符串的某一部分。  * * 构造方法: * OutputStreamWriter(OutputStream out) 创建使用默认字符编码的 OutputStreamWriter。 * OutputStreamWriter(OutputStream out, String charsetName)  创建使用指定字符集的 OutputStreamWriter。 * 参数: * OutputStream out:字节输出流,用于将转换后的字节写入到文件中 * String charsetName:编码表的名称,可以是"GBK","gbk","UTF-8","utf-8",...不区分大小写;不指定默认为系统编码(GBK) *  * 使用步骤: * 1.创建字节输出流对象,构造方法中绑定要输出的目的地 * 2.创建转换流OutputStreamWriter,构造方法中传递字节输出流对象和指定的编码表名称 * 3.使用OutputStreamWriter中的方法write,把数据写入到内存缓冲区中 * 4.使用OutputStreamWriter中的方法flush或者close把内存缓冲区中的数据,刷新到文件中 * 5.释放资源 */public class OutputStreamWriterDemo {public static void main(String[] args) throws IOException {write_utf8();write_gbk();}/* * 使用OutputStreamWriter写UTF-8格式的文件 */private static void write_utf8() throws IOException {//1.创建字节输出流对象,构造方法中绑定要输出的目的地FileOutputStream fos = new FileOutputStream("utf-8.txt");//2.创建转换流OutputStreamWriter,构造方法中传递字节输出流对象和指定的编码表名称OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");//3.使用OutputStreamWriter中的方法write,把数据写入到内存缓冲区中osw.write("你好");//4.使用OutputStreamWriter中的方法flush或者close把内存缓冲区中的数据,刷新到文件中//osw.flush();//5.释放资源osw.close();}/* * 使用OutputStreamWriter写GBK格式的文件 */private static void write_gbk() throws IOException {//1.创建字节输出流对象,构造方法中绑定要输出的目的地FileOutputStream fos = new FileOutputStream("gbk.txt");//2.创建转换流OutputStreamWriter,构造方法中传递字节输出流对象和指定的编码表名称//OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");OutputStreamWriter osw = new OutputStreamWriter(fos);//不指定编码表,默认使用GBK//3.使用OutputStreamWriter中的方法write,把数据写入到内存缓冲区中osw.write("你好");//4.使用OutputStreamWriter中的方法flush或者close把内存缓冲区中的数据,刷新到文件中//osw.flush();//5.释放资源osw.close();}}

/** * java.io.ObjectOutputStream extends OutputStream 字节流 * 作用:把对象以流的方式,写入到文件中保存,称之为序列化 *  * 构造方法: * ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。 * 参数: * OutputStream out:字节输出流,可以传入FileOutputStream *  * 成员方法: * void writeObject(Object obj)  将指定的对象写入 ObjectOutputStream。  *  * 使用步骤: * 1.创建字节输出流FileOutputStream对象,构造方法绑定要写的目的地 * 2.创建对象的序列化流ObjectOutputStream对象,构造方法中传递FileOutputStream对象 * 3.调用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中 * 4.释放资源 */public class Demo01ObjectOutputStream {public static void main(String[] args) throws IOException {//1.创建字节输出流FileOutputStream对象,构造方法绑定要写的目的地FileOutputStream fos = new FileOutputStream("person.txt");//2.创建对象的序列化流ObjectOutputStream对象,构造方法中传递FileOutputStream对象ObjectOutputStream oos = new ObjectOutputStream(fos);//3.调用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中oos.writeObject(new Person("柳岩",18));//4.释放资源oos.close();}}

/** * java.io.ObjectInputStream extends InputStream 字节输入流 * 作用:把文件中保存的对象,以流的方式读取出来使用,称之为对象的反序列化 *  * 构造方法: * ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。 * 参数: * InputStream in:字节输入流,可以使用FileInputStream *  * 成员方法: * Object readObject() 从 ObjectInputStream 读取对象。  *  * 使用步骤: * 1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源 * 2.创建对象反序列流ObjectInputStream对象,构造方法中传递FileInputStream对象 * 3.使用ObjectInputStream对象中的方法readObject,读取文件 * 4.释放资源 *  * 注意: * readObject方法声明了ClassNotFoundException,class文件找不到异常 * 如果反序列的对象,没有对应的class文件,则抛出此异常 */public class Demo02ObjectInputStream {public static void main(String[] args) throws IOException, ClassNotFoundException {//1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源FileInputStream fis = new FileInputStream("person.txt");//2.创建对象反序列流ObjectInputStream对象,构造方法中传递FileInputStream对象ObjectInputStream ois = new ObjectInputStream(fis);//3.使用ObjectInputStream对象中的方法readObject,读取文件Object obj = ois.readObject();System.out.println(obj);//4.释放资源ois.close();}}

/** * java.io.Serializable接口:标记型接口 类通过实现 java.io.Serializable * 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。 * 类实现了Serializable就可以序列化和反序列化了,不实现就会抛出异常NotSerializableException * java.lang.Cloneable接口:实现了这个就可以克隆(复制) * 去市场买肉-->肉上有一个蓝色章(检测合格)-->放心购买-->炒菜,炖肉,包饺子... *   * static修饰的成员属于类,不属于对象,也就不能被序列化和反序列化 瞬态关键字transient:可以阻止成员变量序列化和反序列化 ArrayList: * private transient Object[] elementData; */public class Person implements Serializable {private String name;// private static int age; //0// private transient int age;//0public int age;// 自定义序列号,无论类是否修改,都会使用此序列号// private static final long serialVersionUID = 123456L;private static final long serialVersionUID = 4364292156193835471L;public Person() {super();}public Person(String name, int age) {super();this.name = name;this.age = age;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}//geter/seter省略}