IO流常规操作

发布日期:2019-05-27

IO流

IO就是输入输出,IO设备在计算机中起着举足轻重的作用,IO流也就是输入输出流,用来交互数据,程序和程序交互,程序也可以和网络等媒介交互。

一、IO流的分类

要分类,肯定得站得不同角度来看这个问题。

根据流向划分,分为输入流和输出流根据数据的单位来分划,分为字节流和字符流根据功能划分,分为节点流和包装流还有很多

二、四大基本流

在java中IO流非常之多,但都继承于这四大基流,分别为,字节输入流(InputStream),字节输出流(OutputStream),字符输入流(Reader)和字符输出流(Writer).

它们都是抽象类,不能创建对象,只能创建它们的子类对象,阅读API发现,它们都有一个共同的方法close方法,用来关闭流,如果不关闭流的话程序会一直引用着文件。

三、模板操作

创建源和目标创建流对象具体的IO操作关闭流

在下面的例子中穿插讲述

四、文件流

文件流操作是是文件。分为字符流和字节流,字节流操作是所有的二进制文件包括视频啊,图片啊什么的。字符流主要解决的还是中文的一些问题,因为中文多个字节(GBK是2个字节,UTF-8是3个字节),所有可能出现读一半或者写一半就不读了或者不写了,这样就出现乱码了。具体用字符流还是字节流得具体选择,字节流是可以操作字符流的,但是反过来就可能出现问题。输入就是从文件中读到程序中来,而输出就是从程序中输出到文件中。在这样章节记住一句话:读进来,写出去。下面操作一下各个流的常用方法,

文件字节输入流(FileInputStream)

int read() 从此输入流中读取一个数据字节。 int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中int read(byte[] b, int off, int len)从此输入流中将最多 len 个字节的数据读入一个 byte 数组中

读取文件中所有的数据,用到了一个缓冲数组,也就是每次读取5个字节,直到读完为止有个len返回当前读了几个字节,如果后面没有字节了,那么它就返回-1

//读取文件中所有的数据byte[] buffer = new byte[5];//定义一个缓冲数组长度为5,每次只能读取5个字节int len = 0;//当前读取的字节数,没有字节就返回 -1while((len = in.read(buffer))!= -1 ){ String str = new String(buffer,0,len); System.out.println(str);}

文件字节输出流(FileOutputStream)

1.void write(byte[] b) 将 b.length 个字节从指定 byte 数组写入此文件输出流中。 2.void write(byte[] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 3.void write(int b) 将指定字节写入此文件输出流。

输出就是想文件中写数据,可以一次写一个字节,也可以写一个数组中的元素,这个比较简单。可以用一下四个步骤操作一下

public class FileOutputStreamDemo { public static void main(String[] args) throws Exception { //1.创建源 File f = new File("C:/Users/15626/Desktop/test/123.txt"); //2.创建输出流对象 FileOutputStream out = new FileOutputStream(f); //3.写操作 out.write(97);//只能一个一个的写 //将buffer数组中的数据写在文件中 byte[] buffer = "ABCDEF".getBytes(); out.write(buffer); //从索引1开始的3个字节写在文件中 out.write(buffer, 1, 3); //4.关闭资源 out.close(); }}

文件字符输入流(FileReader)

字符流的方法是从父类中继承过来的,也和上面字节流的方法大同小异

int read() 读取单个字符。 int read(char[] cbuf, int offset, int length) 将字符读入数组中的某一部分。

//文件字符输入流public class FileReaderDemo { public static void main(String[] args) throws IOException { //1.创建源 File src = new File("C:/Users/15626/Desktop/新建文件夹 (2)/test.txt"); //2.创建字符输入流对象 FileReader in = new FileReader(src); //3.读操作 char[] buffer = new char[10]; int len = -1; while((len = in.read(buffer)) != -1){ String str = new String(buffer,0,len); System.out.println(str); } //4.关闭流 in.close(); }}

文件字符输出流(FileWriter)

void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。 void write(int c) 写入单个字符。 void write(String str, int off, int len) 写入字符串的某一部分。

文件的拷贝操作

把指定目录的.java文件拷贝到指定的目录

//拷贝文件:把指定目录的.java文件拷贝到指定的目录public class FileCopyDemo2 { public static void main(String []args) throws Exception{ //得到指定目录的文件 File srcDir = new File("C:/Users/15626/Desktop/新建文件夹 (2)"); File destDir = new File("C:/Users/15626/Desktop/新建文件夹 (2)/qqq"); //筛选出后缀是.java的文件存储在fs这个文件数组中 File[] fs = srcDir.listFiles(new FilenameFilter(){ @Override public boolean accept(File dir, String name){ return new File(dir,name).isFile() && name.endsWith(".java"); } }); //遍历这些文件 for (File srcFile : fs) { //1.创建目标 File destFile = new File(destDir,srcFile.getName()); //2.创建输入流和输出流对象 FileInputStream in = new FileInputStream(srcFile); FileOutputStream out = new FileOutputStream(destFile); //3.输入输出操作 byte[] buffer = new byte[10]; int len = -1; while((len = in.read(buffer)) != -1){ out.write(buffer, 0, len); } //4.关闭流 in.close(); out.close(); } }}

文件夹的拷贝

https://www.cnblogs.com/tfper/p/9855228.html

文件流正确关闭资源

https://www.cnblogs.com/tfper/p/9833722.html

五、缓冲流

缓冲流是一个包装流,目的起缓冲作用.操作流的时候,习惯定义一个byte/char数组. int read():每次都从磁盘文件中读取一个字节. 直接操作磁盘文件性能极低,为了解决这个问题,我们 定义一个数组作为缓冲区. byte[] buffer = new byte[1024]; 该数组其实就是一个缓冲区. 一次性从磁盘文件中读取1024个字节. 如此以来,操作磁盘文件的次数少了,性能得以提升,java提供的默认缓存区大小是8192(1024*8),我们一般不用修改大小.

缓冲流也有四种,分别是 BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter.操作方法都和文件流差不多,我们来看一下缓冲流到底快了多少?

/** * @author 15626 * 操作字符或者字节流都应该用缓冲流包装起来,现在比较一下用缓冲流和不用缓冲流的情况写,复制一个文件所花费时间 * 长度的比较 */public class BufferCompare { public static void main(String[] args) throws Exception { File srcFile = new File("C:/Users/15626/Desktop/File/test.pdf"); File destFile = new File("C:/Users/15626/Desktop/File/copy.pdf"); //test1(srcFile,destFile);//不用缓冲流包装 test2(srcFile,destFile);//用缓冲流包装 } //使用缓冲流,从内存每次读取1024个字节:15ms public static void test2(File srcFile, File destFile) throws Exception { long begin = System.currentTimeMillis(); BufferedInputStream in = new BufferedInputStream(new FileInputStream(srcFile)); BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(destFile)); byte[] buffer = new byte[1024]; int len = -1; while((len = in.read(buffer)) != -1){ out.write(buffer, 0, len); } in.close(); out.close(); System.out.print(System.currentTimeMillis() - begin); } //使用字节流,从磁盘中每次读取1024个字节:38ms public static void test1(File srcFile,File destFile) throws Exception { long begin = System.currentTimeMillis(); FileInputStream in = new FileInputStream(srcFile); FileOutputStream out = new FileOutputStream(destFile); byte[] buffer = new byte[1024]; int len = -1; while((len = in.read(buffer)) != -1){ out.write(buffer, 0, len); } in.close(); out.close(); System.out.print(System.currentTimeMillis() - begin); }}

缓冲流的效率很高,所有以后操作字符字节流都可以用缓冲流包装起来。

六、内存流

内存流就是把程序中的数据暂存在内存中,在这里也就是数组中,或者把内存中的数据输出到其他媒介,内存流也是分为字节流,字符流还有一个字符串流(保存在字符串中)。简单操作一下,熟悉一个方法

import java.io.*;/** * @author 15626 * 字节内存流,或者说是字节数组流 * 字节内存输入流 : ByteArrayOutputStream * 字节内存输出流 : ByteArrayInputStream */public class ByteArrayStreamDemo { public static void main(String[] args) throws Exception { //字节内存输出流:把程序的内容写到内存中的byte数组中 ByteArrayOutputStream out = new ByteArrayOutputStream(); out.write("ABSAK".getBytes()); //把程序中的数据存在了缓冲数组中,toByteArray()方法用来获取缓冲区的数据 byte[] buffer = out.toByteArray(); //字节内存输入流: 把内存中的数据读到程序中 ByteArrayInputStream in = new ByteArrayInputStream(buffer); byte[] by = new byte[1024]; int len = -1; while((len = in.read(by)) != -1){ System.out.print(new String(by,0,len)); } //关闭流无效,因为本身就在存储在内存中 in.close(); out.close(); }}

/** * @author 15626 * 字符内存流或者说是字符数组流 * 字符内存输出流:CharArrayWriter * 字符内存输入流:CharArrayReader */public class CharArrayReaderWriterDemo { public static void main(String[] args) throws Exception { //字符内存输出流 : 从程序把数据存储到内存中的一个缓冲数组中 CharArrayWriter cWriter = new CharArrayWriter(); cWriter.write("你是天边最美的云彩"); //获取缓冲数组中的内容,用toCharArray()方法获取 char[] ch= cWriter.toCharArray(); //字符内存输入流:从内存中被数据读取到程序中来 CharArrayReader sReader = new CharArrayReader(ch); char[] buffer = new char[1024]; int len = -1; while((len = sReader.read(buffer)) != -1){ System.out.println(new String(buffer,0,len)); } //关闭流无效,因为本身就在存储在内存中 sReader.close(); cWriter.close(); }}

/** * @author 15626 * 字符串的内存流,把程序中的数据存储在一个缓冲字符串中 * 字符串的输出流 :StringWriter * 字符串的输入流:StringReader */public class StringWriterReaderDemo { public static void main(String[] args) throws Exception { //字符串的输出流 StringWriter out = new StringWriter(); out.write("你真的想成为一只帅帅气气的一只小人吗"); //获取缓冲区的字符串 //System.out.print(out.toString()); //字符串的输入流 StringReader in = new StringReader("海纳百川,有容乃大"); char[] buffer = new char[1024]; int len = -1; while((len = in.read(buffer)) != -1){ System.out.print(new String(buffer,0,len)); } //关闭流无效,因为本身就在存储在内存中 in.close(); out.close(); }}

要注意的关闭流无效,但是为了追求完美的格式,防止忘记了其他流的关闭,我还还是自娱自乐的关一下吧!

七、对象流

对象流包括ObjectInputStream和ObjectOutputStream,名字起得很有范,肯定是字节流

一般用对象流进行序列化和反序列化通过writeObject方法做序列化操作的,通过readObject方法做反序列化操作

1.序列化

指把堆内存中的Java对象数据,通过某种方式把对象存储到磁盘文件中或者传递给其他网络的节点(在网络上传输). 我们把这个过程称之为序列化.

需要做序列化的对象的类,必须实现序列化接口:java.io.Serializable接口(标志接口[没有抽象方法]). 底层会判断,如果当前对象是Serializable的实例,才允许做序列化.大多数类都已经实现了这个接口了

2.反序列化

把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象的过程.

import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;/** * @author 15626 * 对象流的序列化和反序列化操作 * ObjectInputStream 用WriterObjcet 来做序列化 * ObjectOutputStream 用ReaderObject 来做反序列化 * 需要做序列化的类必须实现Serializable接口 */public class ObjectStreamDemo { public static void main(String[] args) throws Exception { File f = new File("file/111.txt"); writeObject(f);//序列化 readObject(f);//反序列化 } public static void readObject(File f) throws Exception{ ObjectInputStream in = new ObjectInputStream(new FileInputStream(f)); Student s = (Student)in.readObject(); System.out.println(s); in.close(); } public static void writeObject(File f) throws Exception { ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f)); out.writeObject(new Student("小伙子",19,"12345")); out.close(); }}class Student implements Serializable { /** * 做反序列化操作必须存在序列化的字节码文件,由于随着版本升级肯定字节码会发生改变,java提供了序列化版本ID, * 可以固定这一份字节码文件,解决了这个问题 */ private static final long serialVersionUID = 1L; private String name; private int age; //密码一般不会做序列化的,静态的字段和瞬态的字段不能做序列化,所以给密码加上瞬态transient修饰符 //反序列化的结果就为null transient private String password; @Override public String toString() { return "Student [name=" + name + ", age=" + age + ", password=" + password + "]"; } public Student(String name, int age, String password) { super(); this.name = name; this.age = age; this.password = password; }}

可以看到里面有两个重要的问题,一个是反序列化对象需要对象的字节码文件,需要提供序列化ID固定这份字节码文件,还有一个是transient瞬息字段是不能序列化.

八、打印流

1.字节打印流

import java.io.File;import java.io.PrintStream;/** * @author 15626 * 字节打印流 * 可以自动刷新的,不想API说的那样,必须用换行符或者println才可以刷新缓冲区 */public class PrintStreamDemo { public static void main(String[] args) throws Exception { File f = new File("file/123.txt"); PrintStream p = new PrintStream(f); p.print("aa"); p.println(121); p.append("a"); p.close(); // System.out.println(); //这行代码等价于下面的两行代码// PrintStream ps = System.out;// ps.println("a"); }}

2.字符打印流

/** * @author 15626 * 字符打印流 * 当启用自动刷新后,即new PrintWriter(new FileOutputStream(f),true); true * 调用println方法或者printf或者后进行刷新。 * * 当不启动自动刷新,需要手动刷新,调用flush方法,或者close方法会进行刷新 */public class PrintWriterDemo { public static void main(String[]args) throws Exception{ File f = new File("file/123.txt"); PrintWriter p = new PrintWriter(new FileOutputStream(f),true); p.print("wqe"); p.println(); p.close(); }}, 1, 0, 9);