Java IO流

一. I/O流

流:表示数据的来源和目的,并提供数据处理的方法

I/O流:可以理解为连接程序与文件/数组/网络连接/数据库

分类

  1. 按流向分类:输入流输出流

    • 程序可以用输出流向文件写数据,用输入流从文件读取数据
    • 针对键盘,只有输入流;针对屏幕,只有输出流
  2. 按读取类型分类:字节流字符流

    • 字节流:二进制,可以处理一切文件,以字节为基本处理单位
    • 字符流:文本文件,只能处理纯文本
  3. 按发生源头分类:节点流过滤流

    • 节点流:直接操作目标设备对应的流(文件流、字节数组流、标准输入/输出流等)
    • 过滤流:继承带有Filter关键字的流,程序通过过滤流操作节点流,更加灵活方便
  4. 一些其他分类:

  • 按操作方式分类

在这里插入图片描述

  • 按操作对象分类

在这里插入图片描述

二. 字节流 vs 字符流

字节流

  1. InputStream 子类
  • ByteArrayInputStream
  • FileInputStream
  • FilterInputStream
    • BufferedInputStream
    • DataInputStream
    • PushbackInputStream
  • PipedInputStream
  • SequenceInputStream
  • ObjectInputStream
  • StringBufferInputStream
  1. OutputStream 子类
  • ByteArrayOutputSream
  • FileOutputStream
  • FilterOutputStream
    • BufferedOutputStream
    • DataOutputStream
    • PrintStream
  • PipedOutputStream
  • ObjectOutputStream

举例

  1. 向流中输入和从流中读取字节数组,使用ByteArrayInputStreamByteArrayOutputSream

    // 向输入流中输入字符数组
    import java.io.*;
    public class ByteArrayStream {
    	public static void main(String[] args){
    		byte[] b = "hello".getBytes(); 
             ByteArrayInputStream bais = new ByteArrayInputStream(b); // 将字节数组作为字节流的数据源
         	int n =0;
         	while((n = bais.read())!=-1){
            	System.out.print((char)n);
        	}
       	}
    }
    
    // 从输出流中读取字符数组
    import java.io.*;
    public class ByteArrayStream {
    	public static void main(String[] args){
     		byte[] b = "hello".getBytes(); 
    		ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 构造一个字节数组输出流,用于将多个字节写入到流中,最后可以整体转为一个字节数组
    		baos.write(b, 0, b.length);
    		System.out.println(new String(baos.toByteArray()));
    	}
    }
    
  2. 文件的读写操作,使用FileInputStreamFileOutputStream

    // 读取文件
    import java.io.*;
    public class OpenFile {
        public static void main(String args[]) throws IOException{
            try{                                        // 创建文件输入流对象
                FileInputStream  rf = new FileInputStream("OpenFile.java");
                int n=512,c=0;
                byte buffer[] = new byte[n];
                while ((c=rf.read(buffer,0,n))!=-1 ){   // 读取输入流
                    System.out.print(new String(buffer,0,c));
                }            
                rf.close();                            // 关闭输入流
            }
            catch (FileNotFoundException ffe){
                System.out.println(ffe);}
            catch (IOException ioe){
                System.out.println(ioe);
            }
        }
    }
    
    // 写入文件
    import java.io.*;
    public class Write1 {
        public static void main(String args[]){
            try{
                System.out.print("Input: ");
                int count,n=512;
                byte buffer[] = new byte[n];
                count = System.in.read(buffer);        // 读取标准输入流
                FileOutputStream  wf = new FileOutputStream("Write1.txt");
                                                       // 创建文件输出流对象
                wf.write(buffer,0,count);              // 写入输出流
                wf.close();                            // 关闭输出流
                System.out.println("Save to Write1.txt!");
            }
            catch (FileNotFoundException ffe){
                System.out.println(ffe);}
            catch (IOException ioe){
                System.out.println(ioe);} }
    }
    

字符流

  1. Reader 子类
  • BufferedReader
    • LineNumberReader
  • CharArrayReader
  • FilterReader
    • PushbackReader
  • InputStreamReader
    • FileReader
  • PipedReader
  • StringReader
  1. Writer 子类
  • BufferedWriter
    • LineNumberReader
  • CharArrayWriter
  • FilterWriter
  • OutputStreamWriter
    • FileWriter
  • PipedWriter
  • PrintWriter
  • StringWriter

转化

Java提供的支持:

  1. 输入字节流转为字符流:InputStreamReader
  2. 输出字符流转为字节流:OutputStreamWriterPrintWriter
// 字节流 -> 字符流
InputStreamReader ins = new InputStreamReader(System.in);
InputStreamReader ins = new InputStreamReader(new    
                             FileInputStream(“test.txt”));

// 字符流 -> 字节流
OutputStreamWriter outs = new OutputStreamWriter(new    
                             FileOutputStream(“test.txt”));

三. 过滤流

  1. 作用:缓存作用,用于装配文件磁盘、网络设备、终端等读写开销大的节点流,提高读写性能

  2. 常用过滤流:

  • BufferedReader:用于缓存字符流,可以一行一行的读
import java.io.*;
public class inDataSortMaxMinIn { 
    public static void main(String args[]) {
    	try{
			BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));  // 流的装配
			String c1;
			int i=0;
			int[] e = new int[10];   
			while(i<10){
				try{
					c1 = keyin.readLine();
					e[i] = Integer.parseInt(c1);
					i++;
			}  
				catch(NumberFormatException ee){
					System.out.println("请输入正确的数字!");
				}
			}
		}
		catch(Exception e){
			System.out.println("系统有错误");
 		}
	}
}
  • DataInputStreamDataOutputStream:可从字节流中写入、读取Java基本数据类型,不依赖于机器的具体数据类型,方便存储和恢复数据
import java.io.*;
public class DataStream {
	public static void main(String[] args)throws Exception{
		try {
			DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new 																				FileOutputStream("test.txt"))); // 流的装配
			dos.writeInt(3);//写入整型
			dos.writeDouble(3.14);//写入浮点型
			dos.writeUTF(“hello”);//写入字符串
			dos.close();

			DataInputStream dis = new DataInputStream(new BufferedInputStream(new 																					FileInputStream("test.txt")));
			System.out.println(dis.readInt()); //读取整型,输出3
			System.out.println(dis.readDouble()); //读取浮点型,输出3.14
			System.out.println(dis.readUTF()); //读取字符串,输出hello
			dis.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}
}

  • PrintWriter:可以向该字符流中写入Java基本数据类型,用于包装输出字符

    ​ 流类对象

import java.io.*;
public class PrintWrit {
	public static void main(String[] args)throws Exception{
		PrintWriter out = new PrintWriter(new BufferedWriter(new 
                                    FileWriter("foo.txt"))); // 流的装配
		out.println(“hello”); //写入字符串
		out.println(3); //写入整型
		out.close(); //关闭流,系统自动将缓冲区内容flush
	}  
}

四. 对象的序列化与反序列化

序列化:将内存中的动态对象表达成可以传输的串形式,即一种字节序列

反序列化:与序列化相反的过程,将字节序列完全恢复为原来的对象

Java提供的支持:ObjectInputStream类 与 ObjectOutputStream类,以及Seriallizable接口

举例:

import java.io.*;
public class Student implements Serializable { // 序列化的类
	int number=1;
	String name;
	Student(int number,String n1) {
		this.number = number;
		this.name = n1;
    }
    void save(String fname) {
		try{
			FileOutputStream fout = new FileOutputStream(fname);
			ObjectOutputStream out = new ObjectOutputStream(fout);
			out.writeObject(this);               // 对象序列化
			out.close();
    	}
    	catch (FileNotFoundException fe){}
    	catch (IOException ioe){}
	}
    void display(String fname) {
		try{
			FileInputStream fin = new FileInputStream(fname);
			ObjectInputStream in = new ObjectInputStream(fin);
			Student u1 = (Student)in.readObject();  // 对象反序列化
			System.out.println(u1.getClass().getName()+"  "+
                                 u1.getClass().getInterfaces()[0]);
			System.out.println("  "+u1.number+"  "+u1.name);
			in.close();
		}
     	catch (FileNotFoundException fe){}
     	catch (IOException ioe){}
     	catch (ClassNotFoundException ioe) {}
	}

	public static void main(String arg[]) {
        String fname = "Student.obj"; // 文件名
        Student s1 = new Student(1,"Wang");
        s1.save(fname);
        s1.display(fname); // 1 wang
	}
}

五. 文件操作

File类

文件(或目录)路径名字的抽象表示

作用:

  1. 主要用来获取文件本身的一些信息,如文件所在的目录,文件的长度,文件的读写权限等
  2. 实现对实际文件系统对象上的某些操作(比如,读、写、执行)进行限制

Java文件读写

提供的支持:File类、FileInputStream类、FileInputStream类、FileReader类、FileWriter类、RandomAccessFile类,以及 FileFilter接口、FilenameFilter接口

总结

​ 在整理博客的过程中参考了一些资料以及许多他人优秀的文章,就不一一列举,在此表示感谢。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值