Java-IO流总结
IO流：
IO流分为两大类：字节流和字符流
IO的作用就是为了读写操作的。
每种流都分为输入流(Input)、输出流(Output)；站在java程序的角度来说，java程序进行读取操作时，就是输入流；如果java程序向其他地方(硬盘，其他的设备)写入操作时，就是输出流。
IO流只能操作文件，不能操作文件夹，否则会报错。
字节流：
字节输入流：InputStream
字节输出流：OutputStream
OutputStream：
可以向文件中写入字节,进行写入常用的是OutputStream的子类：FileOutputStream，常用的写入方法是write(byte[]),传入byte数组。
下面将是演示利用FileOutputStream来进行写入文件：
package com.xiaoshitou_io; import java.io.FileOutputStream; import java.io.IOException; public class Test { /** * 使用FileOutputStream来写入文件 * @throws IOException * */ public static void main(String[] args) throws IOException { // 创建FileOutputStream对象 // write.txt 文件在项目的根目录下面 FileOutputStream fos = new FileOutputStream("write.txt"); // 准备byte数组 byte[] b = "Hello every body!".getBytes(); // 写入整个数组 fos.write(b); // 写入换行符,System.lineSeparator()方法返回一个字符串，表示跨平台的换行符 fos.write(System.lineSeparator().getBytes()); // 写入数组的一部分 fos.write(b, 0, 5);// 应该写入的是Hello // 关闭输出流 fos.close(); // 文件的内容为： /* Hello every body! Hello */ } }
如果写入的文件存在，会被覆盖掉；要想在文件的末尾进行追加内容（保留以前的内容），就需要在创建FileOutputStream对象是，向构造器传入一个true；下面演示向文件中追加内容：
package com.xiaoshitou_io; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; public class Test { /** * 使用FileOutputStream来写入文件 * 直接在Write.txt文件追加内容 * @throws IOException * */ public static void main(String[] args) throws IOException { // 创建FileOutputStream对象 // write.txt 文件在项目的根目录下面 File writeFile = new File("write.txt"); // 在创建对象传入一个true FileOutputStream fos = new FileOutputStream(writeFile, true); // 准备byte数组 byte[] b = (System.lineSeparator()+"我是追加的内容,哈哈").getBytes(); // 写入文件 fos.write(b); // 关闭输出流 fos.close(); // 文件的内容为： /* Hello every body! Hello 我是追加的内容,哈哈 */ } }
InputStream:
进行文件的读取经常使用的是InputStream的子类，FileInputStream可以读取任何文件，经常用的方法就是直接读入一个byte数组，这样是为了提高读取效率，不是用一个一个字节的读取。
下面演示一个文件的复制，文件的复制，就是利用字节输入流读取文件，然后利用输出流写入文件。下面是复制一个视频文件(同时用了输入流和输出流)：
package com.xiaoshitou_io; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class Test { /** * 将C:\Users\Beck\Desktop\temp目录下all.avi文件复制到 * 当前文件中，名字为copy.avi */ public static void main(String[] args){ // 创建输入输出流 FileInputStream fis = null; FileOutputStream fos = null; try{ File file = new File("C:/Users/Beck/Desktop/temp"); fis = new FileInputStream(new File(file, "all.avi")); fos = new FileOutputStream(new File(file, "copy.avi")); // 进行读写操作 int len = -1; // 每次读入1M byte[] b = new byte[1024*1024]; while ((len=fis.read(b)) != -1){ // 写入 fos.write(b, 0, len); } }catch (IOException e){ e.printStackTrace(); throw new RuntimeException("文件复制失败!"); }finally{ // 关闭流对象 try{ if (fos != null){ fos.close(); } }catch (IOException e){ e.printStackTrace(); throw new RuntimeException("释放资源失败!"); }finally{ try{ if (fis != null){ fis.close(); } }catch (IOException e){ e.printStackTrace(); throw new RuntimeException("释放资源失败!"); } } } System.out.println("复制文件完毕!"); // 输出结果: /*复制文件完毕!*/ } }
BufferedInputStream&BufferedOutputStream:
字符缓冲输入流和字符缓冲输出流，这两个流的作用的是提高输入输出的效率。BufferedInputStream&BufferedOutputStream，接收的参数分别是InputStream，OutputStream,底层还是利用字节的输入输出流，只是对输入输出流进行了封装。
下面利用BufferedInputStream&BufferedOutputStream进行文件的复制：
package com.xiaoshitou_io; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class Test { /** * 将C:\Users\Beck\Desktop\temp目录下all.avi文件复制到 * 当前文件中，名字为copy.avi * 这次使用的是BufferedInputStream 和 BufferedOutputStream来完成 */ public static void main(String[] args){ // 创建缓冲输入输出流 BufferedInputStream bis = null; BufferedOutputStream bos = null; try{ File file = new File("C:/Users/Beck/Desktop/temp"); bis = new BufferedInputStream(new FileInputStream(new File(file, "all.avi"))); bos = new BufferedOutputStream(new FileOutputStream(new File(file, "copy.avi"))); // 进行读写操作 int len = -1; // 每次读入1M byte[] b = new byte[1024*1024]; while ((len=bis.read(b)) != -1){ // 写入 bos.write(b, 0, len); } }catch (IOException e){ e.printStackTrace(); throw new RuntimeException("文件复制失败!"); }finally{ // 关闭流对象 try{ if (bos != null){ bos.close(); } }catch (IOException e){ e.printStackTrace(); throw new RuntimeException("释放资源失败!"); }finally{ try{ if (bis != null){ bis.close(); } }catch (IOException e){ e.printStackTrace(); throw new RuntimeException("释放资源失败!"); } } } System.out.println("复制文件完毕!"); // 输出结果: /*复制文件完毕!*/ } }
练习:把一个视频文件按照5M的大小切割成多个。
package com.xiaoshitou_io; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; public class Test { /** * 将C:\Users\Beck\Desktop\temp目录下all.avi文件复制到 * 这次是把all.avi视频文件切割成多个文件。按照每个文件5M的大小切割 * @throws IOException */ public static void main(String[] args) throws IOException{ // 这次我把IOException直接抛出去了没有捕获 BufferedInputStream bis = new BufferedInputStream( new FileInputStream("C:/Users/Beck/Desktop/temp/all.avi")); // 读取视频文件 int len = -1; // 每次读入5M byte[] bytes = new byte[1024*1024*5]; int flag = 0; while ((len=bis.read(bytes)) != -1 ){ flag++; // 把读入的文件写入到一个文件中 writeToFile(bytes, len, flag); } // 关闭输入流 bis.close(); System.out.println("切割完成!"); } // 将一个byte数组的内容写入到一个文件中 private static void writeToFile(byte[] bytes, int len, int flag) throws IOException { BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("C:/Users/Beck/Desktop/temp/copy_"+flag+".avi")); bos.write(bytes, 0, len); bos.close(); } }
切割结果：
字符流：
输出流：Writer
输入流：Reader
字符流的底层是字节流+编码表
字符流只能操作文本文件，进行文本文件的读写，如果是为了复制文件的话，最好选择字节流进行复制。
Writer：
Writer下面有两个常用的字符输出流：OutputStreamWriter和FileWriter
OutputStreamWriter：接收的参数是一个OutputStream参数，也可以传一个charset编码字符串，这样就可以按照你设置的编码写入文本文件中。
以utf-8编码形式向文本文件中写入内容：
package com.xiaoshitou_io; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; public class Test { /* * 以utf8的格式向文件中写入字符串 */ public static void main(String[] args) throws IOException{ // 创建 OutputStreamWriter对象 OutputStreamWriter osw = new OutputStreamWriter( new FileOutputStream("wirter.txt"),"utf-8"); osw.write("我是OutputStreamWriter写入的，"); osw.write("我的编码是UTF-8格式的。"); // 字符流需要自己刷新 osw.flush(); // 关闭流 osw.close(); //输出结果，两句话在一行，因为没有写入换行符 /* 我是OutputStreamWriter写入的，我的编码是UTF-8格式的。 */ } }
FileWriter：可以接收的参数可以是File对象或者是String类型的；它的编码是系统默认的编码，我们的一般编码是使用的是GBK编码。
使用FileWriter向文本文件中写入字符串：
package com.xiaoshitou_io; import java.io.FileWriter; import java.io.IOException; public class Test { /* * 用FileWriter向文件中写入内容 */ public static void main(String[] args) throws IOException{ // 创建 FileWriter对象 FileWriter fw = new FileWriter("writer_gbk.txt"); fw.write("我是用FileWriter写的"); // 写入换行符 fw.write(System.lineSeparator()); fw.write("我的编码是用的是默认的，GBK"); fw.flush(); // 关闭流 fw.close(); // 输出结果 /* 我是用FileWriter写的 我的编码是用的是默认的，GBK */ } }
Reader:
Reader下面有两个常用的字符流：InputStreamReader，FileReader
InputStreamReader：可以按照指定的编码去读取文本文件，接收的参数是InputStream和一个编码字符串。
以utf-8的编码去读取一个文本文件：
package com.xiaoshitou_io; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; public class Test { /* * 以UTF-8去读取writer.txt * 这个文件是刚才用utf-8的格式写入的， * 也只能以utf8的格式去读取，否则会出现乱码 */ public static void main(String[] args) throws IOException{ // 创建InputStreamReader对象 InputStreamReader isr = new InputStreamReader(new FileInputStream("wirter.txt"), "utf-8"); int len = -1; // 一次可以读取1024个字符，2*1024个字节，2KB char[] ch = new char[1024]; while ((len=isr.read(ch)) != -1){ System.out.print(new String(ch, 0, len)); } // 关闭流 isr.close(); // 输出结果： /* 我是OutputStreamWriter写入的，我的编码是UTF-8格式的。 */ } }
FileReader：以系统默认的编码去读取一个文本文件。接收的参数可以是一个File或者String。
用FileReader去读取GBK的文件，系统默认的编码是GBK
package com.xiaoshitou_io; import java.io.File; import java.io.FileReader; import java.io.IOException; public class Test { /* * 用FileReader来读取文件writer_gbk.txt * FileReader默认是用的是系统的默认编码 * 本机的默认编码是GBK */ public static void main(String[] args) throws IOException{ // 创建FileReader对象 FileReader fr = new FileReader(new File("writer_gbk.txt")); int len = -1; char[] ch = new char[1024]; while ((len=fr.read(ch)) != -1){ System.out.println(new String(ch,0,len)); } // 关闭流 fr.close(); // 输出结果 /* 我是用FileWriter写的 我的编码是用的是默认的，GBK */ } }
乱码：
乱码产生的原因：用一个A编码表将字符转成字节, 又用B编码表将字节转回字符. 两个编码表对应的关系不同,因此查到的结果就不同.
保证不乱码的方式 : 编码与解码保持相同.
字符流复制文件原理：
BufferedReader&BufferedWriter:
BufferedReader&BufferedWriter：字符缓冲输入输出流，接收的参数分别是：Reader，Writer；作用是提高读写的速度，读写时字符的编码是系统默认的编码：
BufferedReader特有的一个方式读取一行readLine(),不会读取换行符
BufferedWrter特有的一个方法时，newLine()写入一个换行符
在写入的数据之后，需要手动flush。
利用BufferedReader&BufferedWriter进行文本文件的读写：
package com.xiaoshitou_io; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class Test { /* * 利用BufferedReader&BufferedWriter进行文本文件的读写： * 复制文件：test.properties */ public static void main(String[] args) throws IOException{ BufferedReader br = new BufferedReader(new FileReader("test.properties")); BufferedWriter bw = new BufferedWriter(new FileWriter("test_copy.properties")); // 进行读写,缓冲流特有的方法就是可以按照行来读取，如果读取结束返回null String line = null; while ((line=br.readLine()) != null){ bw.write(line); // 写入换行 bw.newLine(); // 刷新 bw.flush(); } // 关闭流 bw.close(); br.close(); } }
字节流和字符流的总结：
IO流只能操作文件”文件”,不能操作文件夹(目录)，否则会出现异常。
打印流：
PrintStream,PrintWriter：字节打印流，字符打印流；打印流只有输出流，没有输入流；输出的目的可以是文件，也可以是其他流。PrintStream自带刷新功能，PrintWriter需要手动开启。
PrintStream：打印出来的字符的编码使用的是系统默认编码。
package com.xiaoshitou_io; import java.io.IOException; import java.io.PrintStream; public class Test { /* * 使用打印流：PrintStream */ public static void main(String[] args) throws IOException{ PrintStream ps = new PrintStream("print.txt"); ps.println("旺旺"); ps.println("欢欢"); ps.println("乐乐"); ps.close(); // 结果： /* 旺旺 欢欢 乐乐 */ } }
PrintWriter:
package com.xiaoshitou_io; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; public class Test { /* * 使用打印流：PrintWriter */ public static void main(String[] args) throws IOException{ // 创建PrintWriter对象时，开启自动刷新功能 PrintWriter pw = new PrintWriter(new FileWriter("print.txt"), true); pw.println("我是PrintWriter"); pw.println("出来的"); pw.close(); // 结果： /* 我是PrintWriter 出来的 */ } }
序列化&反序列化:
序列化：就是将对象写入文件的过程
反序列化：从文件读入对象的过程
ObjectOutputStream&ObjectInputStream：需要序列化的对象必须去实现Serializable接口，否则在序列化的时候会出错。
序列化的注意点：
1、static修饰的成员不能被序列化
2、要想成员变量不被序列化，可以用transient关键字修饰
3、为了不发生序列号冲突，设置：serialVersionUID
下面就进行序列化和反序列化：
package com.xiaoshitou_io; import java.io.Serializable; public class Student implements Serializable{ private static final long serialVersionUID = -5214244848175027425L; private String name; private String id; private transient String phone; public Student(String name, String id, String phone) { super(); this.name = name; this.id = id; this.phone = phone; } public Student() { super(); } @Override public String toString() { return "Student [name=" + name + ", id=" + id + ", phone=" + phone + "]"; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } } package com.xiaoshitou_io; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class Test { /* * 进行序列化和反序列化 * 对Student对象序列化 */ public static void main(String[] args) throws IOException, ClassNotFoundException{ // 创建ObjectOutputStream对象,绑定目的地 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tmp.txt")); // 创建Student对象 Student stu = new Student("张三", "T001", "15522223333"); // 写入对象 oos.writeObject(stu); // 关闭流 oos.close(); System.out.println("序列化成功!"); System.out.println("==============分割=============="); // 进行反序列化 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("tmp.txt")); // 读取对象 Object obj = ois.readObject(); if (obj instanceof Student){ Student s = (Student)obj; System.out.println(s); } // 关闭流 ois.close(); System.out.println("反序列化成功!"); // 结果：phone是transient关键字修饰的，所以没有被序列化 /* 序列化成功! ==============分割============== Student [name=张三, id=T001, phone=null] 反序列化成功! */ } }
Properties：
Properties类是HashTable的一个子类，实现了Map接口，所以里面保存的是键值对，元素的存取是无序的，这个类经常被用来处理配置文件。
利用Properties来读写文件：
package com.xiaoshitou_io; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; public class Test { /* * 利用Properties来读写文件 */ public static void main(String[] args) throws IOException{ // 读取Properties文件：pro.properties Properties pro = new Properties(); // 加载文件 pro.load(new FileReader("pro.properties")); // 根据key来读取值 String key = pro.getProperty("key"); System.out.println(key); String value = pro.getProperty("匿名"); System.out.println(value); System.out.println("============================="); // 修改Properties内的值，或者添加新的值 pro.setProperty("key", "我是修改的值"); pro.setProperty("add", "我是新添加的值"); // 保存进文件 pro.store(new FileWriter("pro.properties"),""); System.out.println("修改完成"); // 控制台打印结果: /* 姥姥阿里 娇娇 ============================= 修改完成 */ // pro.properties 文件中的内容： /* # #Sun Jun 11 08:53:22 CST 2017 key=我是修改的值 张嘴=监控 匿名=娇娇 add=我是新添加的值 */ } }
