Java知识总结-IO字节流

说明：通过流操作原理根据源和目的分析面对问题时需要用哪种流对象

一，字节流

InputStream:字节输入流

字节输入流常见共性方法：

read():从输入流中读取一个字节；

read(byte[] b):从输入流读取一定数量的字节，并将其存储在缓冲区数组b中；

read(byte[] b,int off,int len):将输入流中最多len个数据字节读入byte数组；

OutputStream：字节输出流

字节输出流常见共性方法：

write(int b):将指定的字节写入输入流；

write(byte[] b):将字节数组b中所有字节写入输出流

write(byte[] b,int off,int len):将指定字节数组中从off开始指定的len个元原写入输出流。

二，FileInputStream和FileOutputStream

示例1：

通过FileInputStream读取文件并打印

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException{
		//建立流
		FileInputStream fis=new FileInputStream("123.txt");
		int num=0;
		//读取并打印
		while((num=fis.read())!=-1){
			System.out.println(num);
		}
		//关闭流
		fis.close();
	}
}

示例2：

通过FileOutputStream向文件写入数据。

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException{
		//建立流
		FileOutputStream fos=new FileOutputStream("333.txt");
		String str="FileOutputStream";
		//写入数据
		fos.write(str.getBytes());
		//关闭流
		fos.close();
	}
}

示例3：

通过FileInputStream和FileOutputStream复制一个文件。

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException{
		//建立流
		FileInputStream fis=new FileInputStream("321.jpg");
		FileOutputStream fos=new FileOutputStream("333.jpg");
		int num=0;
		//复制文件
		while((num=fis.read())!=-1){
			fos.write(num);
		}
		//关闭流
		fis.close();
		fos.close();
	}
}

三，字节流缓冲区

BufferedOutputStream：字节输出路缓冲区

BufferedInputStream：字节输入流缓冲区

示例：使用缓冲区复制文件：

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException{
		//建立流
				BufferedInputStream bis
					=new BufferedInputStream(new FileInputStream("111.txt"));
				BufferedOutputStream bos
					=new BufferedOutputStream(new FileOutputStream("222.txt"));
				int num;
				//复制文件
				while((num=bis.read())!=-1){
					bos.write(num);
				}
				//关闭流
				bis.close();
				bos.close();

	}
}

四，自定义一个字节输入流缓冲区

//自定义字节符输入流缓冲区
class MybufferedInputStream{
	private InputStream is;
	byte[] buf=new byte[1024];
	int len;
	int num;
	//构造函数，传入InputStream对象作为参数
	MybufferedInputStream(InputStream is){
		this.is=is;
	}
	//自定义read方法
	public int myRead() throws IOException{
		if(len==0){
			//当数组为空时，从IuputStream流中读取数据到数组
			len=is.read(buf);
			if(len<0)
				return -1;
			num=0;
			byte b=buf[num];
			num++;
			len--;
			return b&255;
		}
			
		else if(len>0){
			byte b=buf[num];
			num++;
			len--;
			return b&255;
		}
		return -1;
			
	}
	//自定义close方法
	public void myclose() throws IOException{
		is.close();
	}
}

运用自定义的缓冲区复制文件

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException{
		//建立流
		MybufferedInputStream bis
			=new MybufferedInputStream(new FileInputStream("111.txt"));
		BufferedOutputStream bos
			=new BufferedOutputStream(new FileOutputStream("222.txt"));
		int num;
		//复制文件
		while((num=bis.myRead())!=-1){
			bos.write(num);
		}
		//关闭流
		bis.myclose();
		bos.close();
		
	}
}

五，标准输入流和标准输出流

System.in:标准输入流；

System.out:标准输出流；

示例：使用标准输入流读取键盘输入并用标准输出流打印：

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException{
		//标准输入路
		InputStream in=System.in;
		//标准输出流
		OutputStream out=System.out;
		StringBuilder sb=new StringBuilder();
		while(true){
			//输入流读取键盘录入
			int num=in.read();
			if(num=='\r')
				continue;
			if(num=='\n'){
				String str=sb.toString();
				if("over".equals(str))
					break;
				//输出流打印
				out.write(str.getBytes());
				System.out.println();
				sb.delete(0,sb.length());
			}
			else	 
				sb.append((char)num);
		}
		in.close();
		out.close();
	}
}

六，转换流

OutputStreamWriter ：字符流通向字节流的桥梁；

构造函数：

OutputStreamWriter(OutputStream out)

InputStreamReader ：字节流通向字符流的桥梁；

构造函数：

InputStreamReader(InputStream in)

示例：

import java.io.*;
public class Test {
	public static void main(String[] args) throws IOException{
		//OutputStream os=System.out;
		//OutputStreamWriter osw=new OutputStreamWriter(os);
		//BufferedWriter bufw=new BufferedWriter(osw);
		//InputStream is=System.in;
		//InputStreamReader isr=new InputStreamReader(is);
		//BufferedReader bufr=new BufferedReader(isr);
		BufferedReader bufr = 
				new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bufw = 
				new BufferedWriter(new OutputStreamWriter(System.out));
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}
}

七，操作流的基本规律

流操作的基本规律：

通过三个明确来完成。

1，明确源和目的。
 源：输入流。InputStream  Reader
 目的：输出流。OutputStream  Writer。
2，操作的数据是否是纯文本。
 是：字符流。
 不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。
 通过设备来进行区分：
 源设备：内存，硬盘。键盘
 目的设备：内存，硬盘，控制台。