欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

IO流大总结

程序员文章站 2022-04-09 20:24:46
写在前面 1.概念 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种:输入流,输出流 流按操作类型分为两种: 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的 字符流 : 字符流只能操作纯字符数 ......

- - - - - - - - - - - - - - -

写在前面

- - - - - - - - - - - - - - -

  • 1.概念
    • IO流用来处理设备之间的数据传输
    • Java对数据的操作是通过流的方式
    • Java用于操作流的类都在IO包中
    • 流按流向分为两种:输入流,输出流
    • 流按操作类型分为两种:
      • 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
      • 字符流 : 字符流只能操作纯字符数据,比较方便
  • 2.IO流常用父类
    • 字节流的抽象父类:
      • InputStream
      • OutputStream
    • 字符流的抽象父类:
      • Reader
      • Writer
  • 3.IO程序书写
    • 使用前,导入IO包中的类
    • 使用时,进行IO异常处理
    • 使用后,释放资源

- - - - - - - - - - - - - - -

目 录

- - - - - - - - - - - - - - -


1.read()一次读取一个字节

2.read()方法返回值为什么是int

3.定义小数组实现缓冲

4.实现了缓冲区的BufferedInputStream和BufferOutputStream

5.flush方法和close方法

6. 字节流读写中文

7.流的标准处理异常代码1.6版本及其以前

8.流的标准处理异常代码1.7版本之后

9.拷贝文件

10.录入数据拷贝到文件

11.字符流 FileReader

12.字符流 FileWriter

13.字符流的拷贝

14.什么情况下使用字符流

15.字符流是否可以拷贝非纯文本的文件

16.自定义字符数组的拷贝

17.带缓冲的字符流

18.readLine()和newLine()方法

19.LineNumberReader

20.装饰设计模式

21.使用指定的码表读写字符

22.序列流

23.序列流整合多个

24.内存输出流

25.定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

26.对象操作流ObjecOutputStream

27.对象操作流ObjectInputStream

28.对象操作流优化

29.id号

30.打印流的概述和特点

31.标准输入输出流概述和输出语句

32.修改标准输入输出流拷贝图片

33.两种方式实现键盘录入

34.随机访问流概述和读写数据

35.数据输入输出流

36.Properties的概述和作为Map集合的使用

37.获取Properties中的每一个键

38.Properties的load()和store()功能

- - - - 正 在 施 工 - - - -

- - - - - - - - - - - - - - -






read()一次读取一个字节

    FileInputStream fis = new FileInputStream("乌合之众.txt");  
    //创建一个文件输入流对象,并关联乌合之众.txt
    int b;                                                  
    //定义变量,记录每次读到的字节
    while((b = fis.read()) != -1) {                         
    //将每次读到的字节赋值给b并判断是否是-1
        System.out.println(b);                              
        //打印每一个字节
    }
    
    fis.close();                                            
//关闭流释放资源


read()方法返回值为什么是int

  • read()方法读取的是一个字节,为什么返回是int,而不是byte
  • 因为字节输入流可以操作任意类型的文件,比如图片音频等,这些都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到11111111,那么这11111111byte类型的-1,程序是遇到-1就会停止,后面的数据就读不到了。所以在读取的时候用int类型接收,会在其前面补上24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型。



定义小数组实现缓冲

  • write(byte[] b)
  • write(byte[] b, int off, int len)写出有效的字节个数

  • 定义小数组的标准格式

        FileInputStream fis = new FileInputStream("* - 梵高先生.flac");
        FileOutputStream fos = new FileOutputStream("梵高先生.flac");
        int len;
        byte arr[] = new byte[8*1024];
        //自定义字节数组
        while((len=fis.read(arr))!=-1){
            fos.write(arr, 0, len);
            //写出字节数组写出有效个字节个数
        }
        fis.close();
        fos.close();



实现了缓冲区的BufferedInputStream和BufferOutputStream

  • BufferedInputStream
    • BufferedInputStream内置了一个缓冲区(数组)
    • BufferedInputStream中读取一个字节时,BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 然后返回给程序一个字符。
    • 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取。
    • 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192
  • BufferedOutputStream
    • BufferedOutputStream也内置了一个缓冲区(数组)
    • 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中,
    • 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
  • 组合流过滤器实现拷贝
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("* - 梵高先生.flac"));
        //创建缓冲区对FileInputStream对象的装饰
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2004-梵高先生.flac"));
        //创建缓冲区对FileOutputStream对象的装饰
int b;
while((b = bis.read()) != -1) {     
    bos.write(b);
}
        
bis.close();//只关装饰后的对象即可
bos.close();
  • 小数组的读写和带Buffered的读取哪个更快?
    • 定义小数组如果是8192个字节大小和Buffered比较的话,定义小数组会略胜一筹,因为读和写操作的是同一个数组,而Buffered操作的是两个数组.



flush方法和close方法

  • flush()方法
    • 用来刷新缓冲区的,刷新后可以再次写出
  • close()方法
    • 用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出



字节流读写中文

  • 字节流读取中文的问题
    • 字节流在读中文的时候有可能会读到半个中文,造成乱码
  • 字节流写出中文的问题
    • 字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组
    • 写出回车换行 write("\r\n".getBytes());




流的标准处理异常代码1.6版本及其以前

  • try finally嵌套
FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("from.txt");
            fos = new FileOutputStream("to.txt");
            int b;
            while((b = fis.read()) != -1) {
                fos.write(b);
            }
        } finally {
            try {
                if(fis != null)
                    fis.close();
            }finally {
                if(fos != null)
                    fos.close();
            }
        }



流的标准处理异常代码1.7版本之后

  • try close
try(
    FileInputStream fis = new FileInputStream("from.txt");
    FileOutputStream fos = new FileOutputStream("to.txt");
){
    int b;
    
    while((b = fis.read()) != -1) {
        fos.write(b);
    }
    
}
  • 在try()中创建的流对象必须实现了AutoCloseable这个接口,如果实现了,在try后面的{. . .}执行后就会自动调用流对象的close方法将流关掉.



拷贝文件

  • 在控制台录入文件的路径,将文件拷贝到当前项目下
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件路径");
String line = sc.nextLine();                //将键盘录入的文件路径存储在line中
File file = new File(line);                 //封装成File对象
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getName());

int len;
byte[] arr = new byte[8192];                //定义缓冲区
while((len = fis.read(arr)) != -1) {
    fos.write(arr,0,len);
}

fis.close();
fos.close();




录入数据拷贝到文件

  • 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出
Scanner sc = new Scanner(System.in);
FileOutputStream fos = new FileOutputStream("text.txt");
System.out.println("请输入:");
while(true) {
    String line = sc.nextLine();
    if("quit".equals(line))
        break;
    fos.write(line.getBytes());
    fos.write("\r\n".getBytes());
}

fos.close();




字符流 FileReader

  • 字符流是什么
    • 字符流是可以直接读写字符的IO流
    • 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出.
  • FileReader
    • FileReader类的read()方法可以按照字符大小读取
 FileReader fr = new FileReader("from.txt"); 
 //创建输入流对象,关联from.txt 
 int ch; 
 while((ch = fr.read()) != -1) { 
 //将读到的字符赋值给ch 
 System.out.println((char)ch); 
 //将读到的字符强转后打印 
 }

 fr.close();
 //关流 




字符流 FileWriter

  • FileWriter类的write()方法可以自动把字符转为字节写出
FileWriter fw = new FileWriter("to.txt");
fw.write("write");
fw.close();




字符流的拷贝

FileReader fr = new FileReader("from.txt");
FileWriter fw = new FileWriter("to.txt");

int ch;
while((ch = fr.read()) != -1) {
    fw.write(ch);
}

fr.close();
fw.close();



什么情况下使用字符流

  • 字符流也可以拷贝文本文件, 但不推荐使用。因为读取时会把字节转为字符, 写出时还要把字符转回字节。
  • 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流。读取的时候是按照字符的大小读取的,不会出现读取半个中文,造成乱码的情况。写出的时候可以直接将字符串写出,不用转换为字节数组。


字符流是否可以拷贝非纯文本的文件

  • 不可以拷贝非纯文本的文件
    • 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用"?"代替,写出的时候会将"?"字符转换成字节写出去。如此这般,写出之后的文件就错乱了。



自定义字符数组的拷贝

FileReader fr = new FileReader("form.txt");          
//创建字符输入流,关联aaa.txt
FileWriter fw = new FileWriter("to.txt");          
//创建字符输出流,关联bbb.txt

int len;
char[] arr = new char[1024*8];                      
//创建字符数组
while((len = fr.read(arr)) != -1) {                 
//将数据读到字符数组中
    fw.write(arr, 0, len);                          
    //从字符数组将数据写到文件上
}

fr.close();
//关流释放资源
fw.close(); 




带缓冲的字符流

  • BufferedReaderread()方法读取字符时会一次读取若干字符到缓冲区, 然后逐个返回给程序, 减少读取次数, 以期提高效率。
  • BufferedWriterwrite()方法写出字符时会先写到缓冲区, 缓冲区写满时才会写到文件, 减少写入次数, 以期提高效率。
BufferedReader br = new BufferedReader(new FileReader("form.txt")); 
//创建字符输入流对象,关联aaa.txt 
BufferedWriter bw = new BufferedWriter(new FileWriter("to.txt")); 
//创建字符输出流对象,关联bbb.txt

int ch;             
while((ch = br.read()) != -1) {
//read一次,会先将缓冲区读满,从缓冲去中一个一个的返给临时变量ch
    bw.write(ch);
    //write一次,是将数据装到字符数组,装满后再一起写出去
}
    
br.close(); 
//关流
bw.close();  



readLine()和newLine()方法

  • BufferedReaderreadLine()方法可以读取一行字符(不包含换行符号)
  • BufferedWriternewLine()可以输出一个跨平台的换行符号"\r\n"
BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
String line; 
while((line = br.readLine()) != null) {
   bw.write(line); 
   //bw.write(""); //只支持windows系统 
   bw.newLine(); //跨平台的 
}

br.close();
bw.close(); 



LineNumberReader

  • LineNumberReaderBufferedReader的子类, 具有相同的功能, 并且可以统计行号
    • 调用getLineNumber()方法可以获取当前行号
    • 调用setLineNumber()方法可以设置当前行号
LineNumberReader lnr = new LineNumberReader(new FileReader("form.txt")); 
String line; 
lnr.setLineNumber(100); //设置行号 
while((line = lnr.readLine()) != null) {
    System.out.println(lnr.getLineNumber() + ":" + line);//获取行号 
}

lnr.close(); 



装饰设计模式

interface Coder {
    public void code(); 
 }
 class Persion implements Coder {
    
        @Override
        public void code() {
            System.out.println("It's none of my business during the daytime");
            System.out.println("Write java at night");
        }
        
    }
 class XPersion implements Coder {
        private Persion s;                      
        //被包装的类的引用
        public XPersion (Persion s) {       
        //构造方法将被包装的对象作为参数传入
            this.s = s;
        }
        @Override
        public void code() {
        //对其原有功能进行升级
            s.code();
            System.out.println("Get cervical spondum buff");
            System.out.println("......");
            System.out.println("sudden death");
            System.out.println("......");
        }
        
    } 



使用指定的码表读写字符

  • FileReader是使用默认码表读取文件, 如果需要使用指定码表读取, 那么可以使用InputStreamReader(字节流,编码表)
  • FileWriter是使用默认码表写出文件, 如果需要使用指定码表写出, 那么可以使用OutputStreamWriter(字节流,编码表)
BufferedReader br =  new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt"), "UTF-8"));
BufferedWriter bw =  new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt"), "GBK")); 
int ch; 
while((ch = br.read()) != -1) { 
    bw.write(ch); 
}

br.close();
bw.close();




序列流

  • 1.什么是序列流
    • 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
  • 2.使用方式
    • 整合两个: SequenceInputStream(InputStream, InputStream)
FileInputStream fis1 = new FileInputStream("a.txt");            
//创建输入流对象,关联a.txt
FileInputStream fis2 = new FileInputStream("b.txt");            
//创建输入流对象,关联b.txt
SequenceInputStream sis = new SequenceInputStream(fis1, fis2);  
//将两个流整合成一个流
FileOutputStream fos = new FileOutputStream("c.txt");           
//创建输出流对象,关联c.txt
        
int b;
while((b = sis.read()) != -1) {                                 
//用整合后的输入流
    fos.write(b);                                               
    //写到指定文件上
}
        
sis.close();
fos.close(); 



序列流整合多个

  • 整合多个: SequenceInputStream(Enumeration)
FileInputStream fis1 = new FileInputStream("a.txt");    
//创建输入流对象,关联a.txt
FileInputStream fis2 = new FileInputStream("b.txt");    
//创建输入流对象,关联b.txt
FileInputStream fis3 = new FileInputStream("c.txt");    
//创建输入流对象,关联c.txt
Vector<InputStream> v = new Vector<>();                 
//创建vector集合对象
v.add(fis1);                                            
//将流对象添加
v.add(fis2);
v.add(fis3);
Enumeration<InputStream> en = v.elements();             
//获取枚举引用
SequenceInputStream sis = new SequenceInputStream(en);  
//en传递给SequenceInputStream的构造方法
FileOutputStream fos = new FileOutputStream("d.txt");
int b;
while((b = sis.read()) != -1) {
    fos.write(b);
}
    
sis.close();
fos.close();



内存输出流

  • 1.什么是内存输出流
    • 该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取所有数据
  • 2.使用方式
    • 创建对象: new ByteArrayOutputStream()
    • 写出数据: write(int), write(byte[])
    • 获取数据: toByteArray()
FileInputStream fis = new FileInputStream("a.txt");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int b;
while((b = fis.read()) != -1) {
    baos.write(b);
}
            
//byte[] newArr = baos.toByteArray();               
//将内存缓冲区中所有的字节存储在newArr中
//System.out.println(new String(newArr));
System.out.println(baos);
fis.close();



定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

FileInputStream fis = new FileInputStream("a.txt");             
//创建字节输入流,关联a.txt
ByteArrayOutputStream baos = new ByteArrayOutputStream();       
//创建内存输出流
byte[] arr = new byte[5];                                       
//创建字节数组,大小为5
int len;
while((len = fis.read(arr)) != -1) {                            
//将文件上的数据读到字节数组中
    baos.write(arr, 0, len);                                    
    //将字节数组的数据写到内存缓冲区中
}
System.out.println(baos);                                       
//将内存缓冲区的内容转换为字符串打印
fis.close();




对象操作流ObjecOutputStream

  • 1.什么是对象操作流
    • 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是序列化和反序列化的操作.
  • 2.使用方式
    • 写出: new ObjectOutputStream(OutputStream)writeObject()
public class ObjectOutputStream {

    /**
     * @param args
     * @throws IOException 
     * 将对象写出,序列化
     */
     
    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//创建对象输出流
        oos.writeObject(p1);
        oos.writeObject(p2);
        oos.close();
    }

}



对象操作流ObjectInputStream

  • 读取: new ObjectInputStream(InputStream), readObject()
public class ObjectInputStream {

        /**
         * @param args
         * @throws IOException 
         * @throws ClassNotFoundException 
         * @throws FileNotFoundException 
         * 读取对象,反序列化
         */
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        Person p1 = (Person) ois.readObject();
        Person p2 = (Person) ois.readObject();
        System.out.println(p1);
        System.out.println(p2);
        ois.close();
        }           
}




对象操作流优化

  • 将对象存储在集合中写出
Person p1 = new Person("Tom", 20);
Person p2 = new Person("Jerry", 22);
Person p3 = new Person("Jack", 10);
Person p4 = new Person("Herry", 20);

ArrayList<Person> list = new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
oos.writeObject(list);                                  
//写出集合对象

oos.close();
  • 读取到的是一个集合对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
ArrayList<Person> list = (ArrayList<Person>)ois.readObject();   
//泛型在运行期会被擦除,索引运行期相当于没有泛型
//想去掉黄色可以加注解@SuppressWarnings("unchecked")
for (Person person : list) {
    System.out.println(person);
}
        
ois.close();




id号

  • 要写出的对象必须实现Serializable接口才能被序列化
  • 不用必须加id号




打印流的概述和特点

  • 1.什么是打印流
    • 该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式
    • System.out就是一个PrintStream, 其默认向控制台输出信息
PrintStream ps = System.out;
ps.println(97);                 
//底层用的是Integer.toString(x),将x转换为数字字符串打印
ps.println("a string");
ps.println(new Person("Tom", 20));
Person p = null;
ps.println(p);                  //如果是null,就返回null,如果不是null,就调用对象的toString()
  • 2.使用方式
    • 打印: print(), println()
    • 自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)
PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);
//如果为 true,则 println、printf 或 format 方法将刷新输出缓冲区
pw.write(97);
pw.print("Hello");
pw.println("你好");

pw.close();




标准输入输出流概述和输出语句

  • 1.什么是标准输入输出流
    • System.inInputStream, 标准输入流, 默认可以从键盘输入读取字节数据
    • System.outPrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
  • 2.修改标准输入输出流
    • 修改输入流: System.setIn(InputStream)
    • 修改输出流: System.setOut(PrintStream)
System.setIn(new FileInputStream("a.txt"));             
//修改标准输入流
System.setOut(new PrintStream("b.txt"));                
//修改标准输出流

InputStream in = System.in;                             
//获取标准输入流
PrintStream ps = System.out;                            
//获取标准输出流
int b;
while((b = in.read()) != -1) {                          
//从a.txt上读取字节
    ps.write(b);                                        
    //将数据写到b.txt上
}

in.close();
ps.close();




修改标准输入输出流拷贝图片

System.setIn(new FileInputStream("png.png"));       
//改变标准输入流
System.setOut(new PrintStream("copy.png"));         
//改变标准输出流

InputStream is = System.in;                         
//获取标准输入流
PrintStream ps = System.out;                        
//获取标准输出流

int len;
byte[] arr = new byte[1024 * 8];

while((len = is.read(arr)) != -1) {
    ps.write(arr, 0, len);
}

is.close();
ps.close();




两种方式实现键盘录入

  • A:BufferedReaderreadLine方法。
    • BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  • B:Scanner




随机访问流概述和读写数据

  • A:随机访问流概述
    • RandomAccessFile类不属于流,是Object类的子类。但它融合了InputStreamOutputStream的功能。
    • 支持对随机访问文件的读取和写入。
  • B:read(),write(),seek()




数据输入输出流

  • 1.什么是数据输入输出流
    • DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据
    • 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.
  • 2.使用方式
    • DataOutputStream(OutputStream), writeInt(), writeLong()
    • DataInputStream(InputStream), readInt(), readLong()
DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));
dos.writeInt(998);
dos.writeInt(1998);
dos.writeInt(2998);

dos.close();
DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
int x = dis.readInt();
int y = dis.readInt();
int z = dis.readInt();
System.out.println(x);
System.out.println(y);
System.out.println(z);
dis.close();



Properties的概述和作为Map集合的使用

  • A:Properties的概述
    • Properties 类表示了一个持久的属性集。
    • Properties 可保存在流中或从流中加载。
    • 属性列表中每个键及其对应值都是一个字符串。
Properties prop = new Properties();
prop.put("abc", 123);
System.out.println(prop);




获取Properties中的每一个键

  • A:Properties的特殊功能
    • public Object setProperty(String key,String value)
    • public String getProperty(String key)
    • public Enumeration<String> stringPropertyNames()
Properties prop = new Properties();
prop.setProperty("name", "Tom");
prop.setProperty("tel", "18000000000");

//System.out.println(prop);
Enumeration<String> en = (Enumeration<String>) prop.propertyNames();
while(en.hasMoreElements()) {
    String key = en.nextElement();              //获取Properties中的每一个键
    String value = prop.getProperty(key);       //根据键获取值
    System.out.println(key + "="+ value);
}




Properties的load()和store()功能

Properties prop = new Properties();
prop.load(new FileInputStream("config.properties"));        
//将文件上的键值对读取到集合中
prop.setProperty("tel", "18912345678");
prop.store(new FileOutputStream("config.properties"), null);
//第二个参数是对列表参数的描述,可以给值,也可以给null
System.out.println(prop);

Output:
{tel=18912345678}



(-̇᷇̂ᴥ ̇᷇̂-) ↓