黑马程序员-----程序员之路_____IO流

最新推荐文章于 2021-02-13 16:57:13 发布

小瓶子的瓶子

最新推荐文章于 2021-02-13 16:57:13 发布

阅读量628

点赞数

本文链接：https://blog.csdn.net/u012871223/article/details/16910201

版权

----------android培训、Java培训、期待与您交流！----------

1、IO流的常用基类：

(1)字节流

写入字节流：OutputStream：字节写入流抽象类

|--->FileOutputStream：字节写入流

|--->BufferedOutputStream：字节写入流缓冲区

|--->PrintStream：打印流

读取字节流：InputStream：字节读取流抽象类

|--->FileInputStream：字节读取流

|--->BufferedInputStream：字节读取流缓冲区

(2)字符流

写入字符流：Writer：字符写入流的抽象

|--->FileWriter：字符写入流

|--->BufferedWriter：字符写入流缓冲区

|--->OutputStreamWriter：字符通向字节的转换流(涉及键盘录入时用)

|--->PrintWriter：打印流，可处理各种类型的数据

读取字符流：Reader: 字符读取流的抽象类

|--->FileReader：字符读取流

|--->BufferedReader：字符读取流缓冲区

|--->InputStreamReader：字节通向字符的转换流(涉及键盘录入时用)

|--->LineNumberReader：跟踪行号的缓冲字符读取流

(3)IO流常用基类方法摘要：

字节写入流：OutputStream：

void close() 关闭此输出流并释放与此流有关的所有系统资源。

void flush() 刷新此输出流并强制写出所有缓冲的输出字节。

abstract void write(int b) 将指定的字节写入此输出流。

void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。

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

字节读取流：InputStream：

void close() 关闭此输入流并释放与该流关联的所有系统资源。

int available() (特有方法！！

返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。

abstract int read() 从输入流中读取数据的下一个字节。

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

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

long skip(long n) 跳过和丢弃此输入流中数据的 n 个字节。

字符写入流：Writer：

abstract void close() 关闭此流，但要先刷新它。

abstract void flush() 刷新该流的缓冲。

void write(int c) 写入单个字符。

void write(char[] cbuf) 写入字符数组。

abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。

void write(String str) 写入字符串。

void write(String str, int off, int len) 写入字符串的某一部分。

字符读取流：Reader：

abstract void close() 关闭该流并释放与之关联的所有资源。

int read() 读取单个字符。

int read(char[] cbuf) 将字符读入数组

abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

long skip(long n) 跳过字符。

2、IO流常用基类的子类：

字节流

写入流：

(1)FileOutputStream：

构造方法：

FileOutputStream(String name)

创建一个向具有指定名称的文件中写入数据的输出文件流。

FileOutputStream(String name, boolean append)

创建一个向具有指定 name 的文件中写入数据的输出文件流。

FileOutputStream(File file)

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

FileOutputStream(File file, boolean append)

创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

方法摘要：

public void flush()字节写入的时候不用刷新

void close() 关闭此文件输出流并释放与此流有关的所有系统资源。

void write(int b) 将指定字节写入此文件输出流。

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

void write(int b) 将指定字节写入此文件输出流。

(2)BufferedOutputStream：

构造方法：

BufferedOutputStream(OutputStream out)

创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

BufferedOutputStream(OutputStream out, int size)

创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

方法摘要：

void flush() 刷新此缓冲的输出流。

void write(byte[] b, int off, int len)

将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。

void write(int b) 将指定的字节写入此缓冲的输出流。

(3)PrintStream：打印流，可将各种类型的数据原样打印，有自动刷新功能

构造方法：

PrintStream(String fileName)

创建具有指定文件名称且不带自动行刷新的新打印流。

PrintStream(File file)

创建具有指定文件且不带自动行刷新的新打印流。

PrintStream(OutputStream out)

创建新的打印流。

PrintStream(OutputStream out, boolean autoFlush) (当autoFlush为true时具有自动刷新功能)

创建新的打印流。

方法摘要：

PrintStream append(char c)

将指定字符添加到此输出流。

PrintStream的演示代码如下：

package day20;
/*
 打印流：
 该流提供了打印方法，可以将各种数据类型的数据都原样打印。
 字节打印流
 PrintStream
 构造函数可以接收的参数类型：
 1，file对象 File
 2，字符串路径。String
 3，字节输出流。OutputStream
 字符打印流
 PrintWriter
  构造函数可以接收的参数类型：
 1，file对象 File
 2，字符串路径。String
 3，字节输出流。OutputStream
 4，字符输出流， Writer 
 */
import java.io.*;
class PrintStreamDemo
{
	public static void main(String[] args)throws IOException
	{
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));//读取键盘输入
		
		PrintWriter out=new PrintWriter(new FileWriter("a.txt"),true);//想对文件刷新把文件封装在流里面就可以了/想要提高效率就来一个BufferedWriter
		String line=null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			out.println(line.toUpperCase()); 
			//out.flush();
		}
		out.close();
		bufr.close();	
	}
}

void close()

关闭流。

void flush()

刷新该流的缓冲。

void print(各种类型的数据：)

打印各种类型的数据

void println(各种类型的数据：)：自动换行

打印各种类型的数据

void write(byte[] buf, int off, int len)

将 len 字节从指定的初始偏移量为 off 的 byte 数组写入此流。

void write(int b)

将指定的字节写入此流。

读取流：

（4）FileInputStream：

构造方法：

FileInputStream(String name)

通过打开一个到实际文件的连接来创建一个 FileInputStream

该文件通过文件系统中的路径名 name 指定。

FileInputStream(File file)

通过打开一个到实际文件的连接来创建一个 FileInputStream，

该文件通过文件系统中的 File 对象 file 指定。

方法摘要：

int available() (字节读取流特有方法！！！)

返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。

int read()

从此输入流中读取一个数据字节。

int read(byte[] b)

从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

int read(byte[] b, int off, int len)

从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

long skip(long n)

从输入流中跳过并丢弃 n 个字节的数据。

（5）BufferedInputStream:(有read方法，注意与BufferReader的特有方法readLine进行区别)

构造方法：

BufferedInputStream(InputStream in)

创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

BufferedInputStream(InputStream in, int size)

创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

方法摘要：

int available() (字节读取流特有方法！！！)

返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数。

int read()

参见 InputStream 的 read 方法的常规协定。

int read(byte[] b, int off, int len)

从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。

long skip(long n)

参见 InputStream 的 skip 方法的常规协定。

FileInputStream与FileOutputStream的例子，复制一个图片

package day19;
/*
 复制一个图片
 思路：
 1，用字节读取流对象和图片关联
 2，用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
 3，通过循环读写，完成数据的存储
 4，关闭资源
 */
import java.io.*;
class CopyPic 
{
	public static void main(String[] args)
	{
		FileOutputStream fos=null;
		FileInputStream fis=null;
		try
		{
			fos=new FileOutputStream("c:\\2.bmp");
			fis=new FileInputStream("c:\\1.bmp");
			byte[] buf=new byte[1024];
			int len=0;
			while((len=fis.read(buf))!=-1)
			{
				fos.write(buf,0,len);
			}
		}
		catch(IOException e)
		{
			throw new RuntimeException("复制文件失败");
		}
		finally
		{
			try
			{
				if(fis!=null)
					fis.close();
			}
			catch(IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
			try
			{
				if(fos!=null)
					fos.close();
			}
			catch(IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}

BufferedInputStream与BufferedOutputStream的例子，复制一个MP3文件

package day19;
/*
 演示mp3的复制，通过缓冲区
 BuffereOutputStream
 BuffereInputStream
  
 */
import java.io.*;
 class CopyMp3
 {
	public static void main(String[] args)throws IOException
	{
		long start=System.currentTimeMillis();
		copy_2();
		long end=System.currentTimeMillis();
		System.out.println((end-start)+"毫秒");
	}
	public static void copy_2()throws IOException
	{
		MyBufferedInputStream bufis=new MyBufferedInputStream/*缓冲区放读进来的数据*/(new FileInputStream/*在读取硬盘上的数据*/("C:\\00.mp3"));
		BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("C:\\1.mp3"));
		
		int by=0;
		//System.out.println("第一个字节："+bufis.myRead());
		while((by=bufis.myRead())!=-1)
		{
			bufos.write(by);
		}
		bufos.close();
		bufis.myClose();
	}
	//通过字节流的缓冲区完成复制。
	public static void copy_1()throws IOException
	{
		BufferedInputStream bufis=new BufferedInputStream(new FileInputStream/*在读取硬盘上的数据*/("C:\\00.mp3"));
		BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("C:\\10.mp3"));
		
		int by=0;
		while((by=bufis.read())!=-1)
		{
			bufos.write(by);
		}
		bufos.close();
		bufis.close();
	}
}

字符流

写入流：

(6)FileWriter:

构造方法：

FileWriter(String fileName)

根据给定的文件名构造一个 FileWriter 对象。

FileWriter(String fileName, boolean append)

根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。

FileWriter(File file)

根据给定的 File 对象构造一个 FileWriter 对象。

FileWriter(File file, boolean append)

根据给定的 File 对象构造一个 FileWriter 对象。

FileWriter(FileDescriptor fd)

构造与某个文件描述符相关联的 FileWriter 对象。

方法摘要：跟Writer一样

abstract void close() 关闭此流，但要先刷新它。

abstract void flush() 刷新该流的缓冲。

void write(int c) 写入单个字符。

void write(char[] cbuf) 写入字符数组。

abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。

void write(String str) 写入字符串。

void write(String str, int off, int len) 写入字符串的某一部分。

(7)BufferedWriter:（有一个newLine方法，自动换行）

构造方法：

BufferedWriter(Writer out)

创建一个使用默认大小输出缓冲区的缓冲字符输出流。

BufferedWriter(Writer out, int sz)

创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

方法摘要：

void close() 关闭此流，但要先刷新它。

void flush() 刷新该流的缓冲。

void newLine() 写入一个行分隔符。自动换行

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

void write(int c) 写入单个字符。

void write(String s, int off, int len) 写入字符串的某一部分。

(8)OutputStreamWriter：字节通向字符的转换流

构造方法：

OutputStreamWriter(OutputStream out)

创建使用默认字符编码的 OutputStreamWriter。

方法摘要：

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

void write(int c) 写入单个字符。

void write(String str, int off, int len) 写入字符串的某一部分。

(9)PrintWriter:

构造方法：

PrintWriter(String fileName) 创建具有指定文件名称且不带自动行刷新的新 PrintWriter。

PrintWriter(File file) 使用指定文件创建不具有自动行刷新的新 PrintWriter。

PrintWriter(Writer out) 创建不带自动行刷新的新 PrintWriter。

PrintWriter(Writer out, boolean autoFlush) 创建新 PrintWriter。

PrintWriter(OutputStream out) 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。

PrintWriter(OutputStream out, boolean autoFlush) 通过现有的 OutputStream 创建新的 PrintWriter。

方法摘要：

PrintWriter append(char c) 将指定字符添加到此 writer。

void print(各种类型的数据：) 打印各种类型的数据

void println(各种类型的数据：)：自动换行，打印各种类型的数据

void write(char[] buf) 写入字符数组。

void write(char[] buf, int off, int len) 写入字符数组的某一部分。

void write(int c) 写入单个字符。

void write(String s) 写入字符串。

void write(String s, int off, int len) 写入字符串的某一部分。

读取流：

(10)FileReader

构造方法：

FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader。

FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader。

FileReader(FileDescriptor fd) 在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

方法摘要：和Reader基类方法一致：

abstract void close() 关闭该流并释放与之关联的所有资源。

int read() 读取单个字符。

int read(char[] cbuf) 将字符读入数组

abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

long skip(long n) 跳过字符。

(11)BufferedReader:（有特有方法readLine()，注意与BufferInputStream的read()方法进行区别）

构造方法：

BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。

方法摘要：

int read() 读取单个字符。

int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

String readLine() 读取一个文本行。包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

(12)LineNumberReader：（跟踪行号的缓冲字符输入流）

构造方法：

LineNumberReader(Reader in) 使用默认输入缓冲区的大小创建新的行编号 reader。

方法摘要：

int read() 读取单个字符。

int read(char[] cbuf, int off, int len) 将字符读入数组中的某一部分。

String readLine() 读取文本行。

long skip(long n) 跳过字符。

int getLineNumber() 获得当前行号。

void setLineNumber(int lineNumber) 设置当前行号。

(13)InputStreamReader：字符通向字节的桥梁：

构造方法：

InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。

方法摘要:

int read() 读取单个字符。

int read(char[] cbuf) 将字符读入数组

abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

long skip(long n) 跳过字符。

Filereader与Filewriter的例子，将C盘文件复制到D盘

package day18;
/*
 将C盘一个文本文件复制到D盘 
 复制原理：
 其实就是将C盘下的文件数据存储到D盘的一个文件中。
 步骤：
 1，在D盘创建一个文件，用于存储C盘文件中的数据
 2，定义读取流和C盘文件关联
 3，通过不断的读写完成数据存储
 4，关闭资源
 */
import java.io.*;
class CopyText
{
	public static void main(String[] args) throws IOException
	{
		copy_2();
	}
	
	public static void copy_2()
	{
		FileWriter fw=null;
		FileReader fr=null;
		try
		{
			fw=new FileWriter("SyatemDemo_copy.txt");
			fr=new FileReader("SystemDemo.java");
			char[] buf=new char[1024];
			int len=0;
			while((len=fr.read(buf))!=-1)
			{
				fw.write(buf,0,len);
			}
		}
		catch(IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			if(fr!=null)
				try
			{
					fr.close();
			}
			catch(IOException e)
			{
				
			}
			if(fw!=null)
				try
			{
					fw.close();
			}
			catch(IOException e)
			{
				
			}
			
		}
	}
	//从C盘读取一个字符，就往D盘写一个字符。
	public static void copy_1()throws IOException
	{
		//创建目的地
		FileWriter fw=new FileWriter("RuntimeDemo_copy.txt");
		//与已有文件关联
		FileReader fr=new FileReader("RuntimeDemo.java");
		int ch=0;
		while((ch=fr.read())!=-1)
		{
			fw.write(ch);
		}
		fw.close();
		fr.close();
	}
}

BufferedReader与Bufferedwriter的例子，复制一个.java文件

package day19;
/*
 通过缓冲区复制一个.java文件
 */
import java.io.*;
public class CopyTextByBuf 
{
	public static void main(String[] args)
	{
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try
		{
			bufr=new BufferedReader(new FileReader("BufferedWriterDemo.java"));
			bufw=new BufferedWriter(new FileWriter("BufWriter_copy.txt"));
			
			String line=null;
			while((line=bufr.readLine())!=null)
			{
				bufw.write(line);
				bufw.newLine();
				bufw.flush();
			}
		}
		catch(IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			try
			{
				if(bufr!=null)
					bufr.close();
			}
			catch(IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
			try
			{
				if(bufw!=null)
					bufw.close();
			}
			catch(IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}

}

3、流操作的规律：

流操作的难点：流对象很多，不知道具体用哪个

规律：

(1)第一步：先明确源和目的

源：

文本：用Reader

字节：用InputStream

目的：

文本：用Writer

字节：用OutputStream

(2)第二步：明确是不是纯文本

是：用字符流；

不是：用字节流

(3)第三步：明确流体系后，通过设备来明确具体使用哪个流对象

源设备：

键盘：System.in

硬盘：文件流File

内存：数组流ArrayStream

目的设备：

键盘：System.out

硬盘：文件流File

内存：数组流ArrayStream

----------android培训、Java培训、期待与您交流！----------

小瓶子的瓶子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员-----程序员之路_____IO流

----------android培训、Java培训、期待与您交流！----------IO流很实用所以我要做详细的总结2、IO流的常用基类：(1)字节流写入字节流：OutputStream：字节写入流抽象类|--->FileOutputStream：字节写入流|--->BufferedOutputStream：字节写入流缓冲区|--->Pr
复制链接

扫一扫