Java IO知识点 | 易学教程

类型

Java中IO的输入输出定义了多个流类型

按程序的数据流方向氛围输入流和输出流。
按处理数据单位不同分为字节流(一次一个字节)和字符流(一次一个字符，两个字节)。
按功能不同分为节点流(直接从数据源读写)和处理流(连接在已存在的流之上)。
继承自InputStream/OutputStream的都是字节流

//InputStream
int read() throws IOException //读一个字节,末尾返回-1
int read(byte[] buffer) throws IOException//读取一系列字节存储到buffer数组中，返回读取到的字节数，到末尾返回-1
int read(byte[] buffer，int offset, int length) throws IOException//读取length个字节从offset开始
void close() throws IOException//关闭流释放内存资源

//OutputStream
void wtrte(int b)throws IOException//写一个字节
void wtrte(byte[] b) throws IOException//将字节数组中数据写入输出流
void write(byte[] b,int off,int len)throws IOException//写len个字节
void close() throws IOException//关闭流释放内存资源
void flush()throws IOException//将输出流缓冲中数据全部写出，在close前最好调用一次

Reader与InputStream类似，只是字节替换为字符

//Writer与OutputStream类似,加入了将字符串写入输出流
void write(String str)throws IOException
void write(Stirng str,intoffset,int length)throws IOException

例子

FileInputStream

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestFileInputStream {

	public static void main(String[] args) {
		int b=0;
		FileInputStream in=null;
		try {
			in = new FileInputStream("E:\\eclipse\\Csdn\\src\\TestFileInputStream.java");
		} catch(FileNotFoundException e) {
			System.out.println("找不到指定文件");
			System.exit(-1);
		}
		
		try {
			while((b=in.read())!=-1) {
				System.out.print((char)b);
			}in.close();
		} catch(IOException e) {
			System.out.println("文件读取错误");
			System.exit(-1);
		}

	}

}

执行代码会将自身打印一遍，但因为是字节流，无法打印中文，字符流则可以。

FileOutputStream

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestFileOutputStream {

	public static void main(String[] args) {
		int b=0;
		FileInputStream in = null;
		FileOutputStream out = null;
		try {
			in = new FileInputStream("E:\\eclipse\\Csdn\\src\\TestFileOutputStream.java");
			out = new FileOutputStream("D:\\Desktop\\copy.txt");
			while((b=in.read())!=-1) {
				out.write(b);
			}
			in.close();
			out.close();
		} catch(FileNotFoundException e1) {
			System.out.println("找不到指定文件");
			System.exit(-1);
		} catch(IOException e2) {
			System.out.println("文件复制错误");
			System.exit(-1);
		}
		System.out.println("文件已复制");
	}

}

执行代码会在指定位置将自身复制。

FileReader、FileWriter写法与上面类似

处理流

缓冲流Buffering（使用普遍）

在这里插入图片描述

BufferedInputStream

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class TestBufferStream {

	public static void main(String[] args) {
		try {
			FileInputStream fis = new FileInputStream("E:\\eclipse\\Csdn\\src\\TestBufferStream.java");
			BufferedInputStream bis = new BufferedInputStream(fis);
			int c = 0;
			System.out.println((char)bis.read());
			bis.mark(100);
			for(int i = 0;i<10 && (c = bis.read())!=-1;i++) {
				System.out.print((char)c+" ");
			}
			System.out.println();
			bis.reset();//返回上一标记点
			for(int i = 0;i<10 && (c = bis.read())!=-1;i++) {
				System.out.print((char)c+" ");
			}
			bis.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}

}

BufferedWriter/BufferedReader

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestBufferReader {

	public static void main(String[] args) {
		try {
			BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\Desktop\\copy.txt"));
			BufferedReader br = new BufferedReader(new FileReader("D:\\Desktop\\copy.txt"));
			String s = null;
			for(int i = 1;i<=100;i++) {
				s = String.valueOf(Math.random());//写一百行随机数
				bw.write(s);
				bw.newLine();
			}
			bw.flush();//将缓冲区所有数据写入
			while((s=br.readLine())!=null) {//一次读一行
				System.out.println(s);
			}
			bw.close();
			br.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
}

转换流

InputStreamReader和OutputStreamWriter用于字节数据到字符数据之间的转换
InputStreamReader和InputStream套接
OutputStreamWriter和OutputStream套接
构造时可以指定编码集合，如InputStreamReader isr = new InputStreamReader(new FileinputStream("","ISO8859_1"))

OutputStreamWriter

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class TestOutputStreamWriter {

	public static void main(String[] args) {
		try {
			OutputStreamWriter osw = new OutputStreamWriter(
					new FileOutputStream("D:\\Desktop\\copy.txt"));
			osw.write("asdfghjkl");
			System.out.println(osw.getEncoding());
			osw.close();
			osw = new OutputStreamWriter(
					new FileOutputStream("D:\\Desktop\\copy.txt",true),"ISO8859_1");//true表示在文件末尾接着写入
			osw.write("asdfghjkl");
			System.out.println(osw.getEncoding());
			osw.close();
			
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
}

InputStreamReader

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestInputStreamReader {

	public static void main(String[] args) {
		InputStreamReader isr = new InputStreamReader(System.in);//System.in是InputStream的子类对象
		BufferedReader br = new BufferedReader(isr);//使用BufferedReader能使用readLine方法
		String s = null;
		try {
			s = br.readLine();
			while(s!=null) {
				if(s.equalsIgnoreCase("exit"))//equalsIgnoreCase忽略大小写
					break;
				System.out.println(s.toUpperCase());
				s = br.readLine();
			}
			br.close();
		} catch(IOException e) {
			e.printStackTrace();
		}
	}
}

数据流

DataInputStream 和 DataOutputStream 分别继承InputStream 和 OutputStream，需要套接在InputStream和OutputStream类型节点流上
提供了存取Java原石数据类型数据的方法

Print流

PrintWriter和PrintStream都属于输出流，分别针对字符和字节
提供Print、Println方法输出
不会抛出异常
自动flush

Object流

将Object直接写入或读出（序列化）
必须实现Serializable接口（自动实现）
手动实现Externalizable接口也可序列化

ObjectOutputStream/ObjectInputStream

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class TestObjectIO {

	public static void main(String[] args) {
		T t = new T();
		try {
			FileOutputStream fos = new FileOutputStream("D:\\Desktop\\copy.txt");
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.writeObject(t);
			oos.flush();
			oos.close();
			FileInputStream fis = new FileInputStream("D:\\Desktop\\copy.txt");
			ObjectInputStream ois = new ObjectInputStream(fis);
			T t1 = (T)ois.readObject();
			System.out.println(t1.i+" "+t1.j+" "+t1.d+" "+t1.k);
		}catch(IOException e) {
			e.printStackTrace();
		}catch(ClassNotFoundException e1) {
			e1.printStackTrace();
		}
	}
}
class T implements Serializable{
	int i = 10;
	int j = 0;
	double d = 2.3;
	transient int k = 15;//transient关键字标记的变量将在序列化时透明，不予读写
}

来源：CSDN

作者：lightYear12138

链接：https://blog.csdn.net/lightYear12138/article/details/104614349

标签

throws