黑马程序员------IO流（No.1）（IO流概述、Reader、Writer、BufferedReader、BufferedWriter、装饰设模式）

最新推荐文章于 2022-07-13 12:09:02 发布

硅与神经键

最新推荐文章于 2022-07-13 12:09:02 发布

阅读量900

点赞数

分类专栏： Java SE 牛刀小试文章标签： IO Reader Writer BufferedReader BufferedWriter

本文链接：https://blog.csdn.net/HelloXiaobi/article/details/11794563

版权

Java SE 牛刀小试专栏收录该内容

28 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

IO流概述

IO流用来处理设备间的数据传输

java对数据的操作是通过流的方式

java用于操作流的对象都在IO包中

流按照操作数组分为两种：字节流与字符流

流按流向分：输入流和输出流

字节流的抽象基类：

InputStream，OutputStream.

字符流的抽象基类：

Reader Writer。

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。

如：Reader的子类FileReader。

Writer

既然IO流是用于操作数据的，那么数据的最常见体现形式:文件

/*
既然IO流是用于操作数据的，那么数据的最常见体现形式:文件

需求：在硬盘上，创建一个文件并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象，FileWriter。后缀名
是父类名。前缀名是该流对象的功能。
*/
import java.io.*;
class WriterDemo{
	public static void main(String[] args)throws IOException{
		//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
		//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
		//其实该步就是在明确数据要存在的目的地。
		FileWriter f = new FileWriter("C:\\Users\\Xiaobi\\Desktop\\自学\\demo.txt");
		// 调用write方法，将字符串写入到流中。
		f.write("adcx");
		//刷新流对象中的缓冲中的数据
		//将数据刷到目的地中。
		f.flush();
		f.write("sdasd");
		f.flush();
		//关闭数据源，但是关闭之前会刷新一次内部的缓冲中的数据。
		//将数据刷到目的地中。
		//和flush的区别：flush是刷新后，流可以继续使用，close刷新后，会将流关闭。
		f.write("哈哈");
		f.close();
	}
}

IO处理异常的基本方式

/*
IO异常的处理方式
*/
import java.io.*;
class WriterDemo2{
	public static void main(String[] args){
		FileWriter f = null;
		try
		{
			f = new FileWriter("demo.txt");
			f.write("fdsfasf");
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}finally{
			try
			{
				//对要关闭的流进行不为null判断。
				if(f!=null)
					f.close();
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
		}
	}
}

文件的续写

传递一个true参数，代表不覆盖已有文件。并在已有文件的末尾出进行数据续写。

FileWriter f = new FileWriter("demo.txt",true);

/*
对已有的文件续写
*/
import java.io.*;
class WriterDemo3{
	public static void main(String[] args)throws IOException{
		//传递一个true参数，代表不覆盖已有文件。并在已有文件的末尾出进行数据续写。
		FileWriter f = new FileWriter("demo.txt",true);
		f.write("哈哈\r\n你是坏人");
		f.close();
	}
}

文本文件读取：

read():一次读一个字符，而且会自动往下读。

read();返回：作为整数读取的字符，范围在0-65535之间，如果已到达流的末尾，则返回-1.

import java.io.*;
class ReaderDemo{
	public static void main(String[] args)throws IOException{
		//创建一个文件读取对象，和指定的文件相关联。
		//要保证该文件是已经存在的，如果不存在，会发生异常：FileNotFoundException
		FileReader f = new FileReader("demo.txt");
		//read():一次读一个字符，而且会自动往下读。
		//read();返回：作为整数读取的字符，范围在0-65535之间，如果已到达流的末尾，则返回-1.
		int ch = 0;
		while((ch = f.read())!=-1)
		System.out.print((char)ch);
	}
}

通过字符数组进行读取。

import java.io.*;
/*
通过字符数组进行读取
*/
class ReaderDemo2{
	public static void main(String[] args)throws IOException{
		FileReader f = new FileReader("demo.txt");
		//定义一个字符数组，用于存储读到的字符。
		//该read(char[])返回的是读到的个数。
		char[]buf = new char[1024];
		int num = 0;
		while((num = f.read(buf))!=-1){
			//read(char[] cbuf,int off,int len)
			System.out.print(new String(buf,0,num));//不建议println，文件过大的时候换行问题
		}
		f.close();
	}
}

拷贝文本文件：

复制原理：

其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：

1.在D盘创建一个文件，用于存储C盘文件中的数据。

2.定义读取流和C盘文件关联。

3.通过不断的读写完成数据存储。

4.关闭资源。

import java.io.*;
/*
复制原理：
其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：
1.在D盘创建一个文件，用于存储C盘文件中的数据。
2.定义读取流和C盘文件关联。
3.通过不断的读写完成数据存储。
4.关闭资源。
*/
class ReaderDemo3{
	public static void main(String[] args)throws IOException{
		copy_1();
		copy_2();
	}
	public static void copy_1()throws IOException{
		//与已有文件关联
		FileReader fr = new FileReader("demo.txt");
		//创建目的地
		FileWriter fw = new FileWriter("demo_copy1.txt");
		int ch = 0;
		while((ch=fr.read())!=-1){
			fw.write(ch);
		}
		fw.close();
		fr.close();
	}
	public static void copy_2(){
		FileReader fr = null;
		FileWriter fw = null;
		try
		{
			fr = new FileReader("demo.txt");
			fw = new FileWriter("demo_copy2.txt");
			char[] buf = new char[1024];
			int len = 0;
			while((len=fr.read(buf))!=-1){
				fw.write(buf,0,len);
			}
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}finally{
			if(fw!=null)
				try
				{
					fw.close();
				}
				catch (IOException e)
				{
					System.out.println(e.toString());
				}
			if(fr!=null)
				try
				{
					fr.close();
				}
				catch (IOException e)
				{
					System.out.println(e.toString());
				}
		}
	}
}

IO缓冲区

缓冲区的出现是为了提高流的操作效率而出现的。

所以在创建缓冲区之前，必须要先有流对象。

写入缓冲区

该缓冲区提供了一个跨平台的换行符。

import java.io.*;
class BufferedWriterDemo{
	public static void main(String[] args)throws IOException{
		// 创建一个字符写入流对象
		FileWriter fw = new FileWriter("buf.txt");
		//为了提高字符写入流的效率，加入了缓冲技术，只要将需要被提高效率的流对象作为传递给缓冲区的构造函数即可。
		BufferedWriter btw = new BufferedWriter(fw);
		btw.write("dasdASd");
		btw.newLine();
		btw.write("3333");
		//只要用到缓冲区，就要记得刷新。
		btw.flush();
		//其实关闭缓冲区，就是关闭缓冲区中的流对象。
		btw.close();
	}
}

字符读取缓冲区：

该缓冲区提供了一个一次读一行的方法 readLine，方便对文本数据的获取。

当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。

import java.io.*;
class  BufferedReaderDemo{
	public static void main(String[] args)throws IOException{
		//创建一个读取流对象和文件关联。
		FileReader fr = new FileReader("buf.txt");
		BufferedReader bfr = new BufferedReader(fr);
		String line = null;
		while((line=bfr.readLine())!=null){
			System.out.println(line);
		}
		bfr.close();
	}
}

使用缓冲区复制文本文件

import java.io.*;
class CopyByBuf{
	public static void main(String[] args){
		//定义缓冲区引用
		BufferedReader bfr = null;
		BufferedWriter bfw = null;
		try
		{
			//建立缓冲区
			bfr = new BufferedReader(new FileReader("buf.txt"));
			bfw = new BufferedWriter(new FileWriter("buf_copyByBuf.txt"));
			String line = null;
			while((line = bfr.readLine())!=null){
				bfw.write(line);
				bfw.newLine();
				bfw.flush();
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally{
			if(bfw!=null)
				try
				{
					bfw.close();
				}
				catch (IOException e)
				{
					throw new RuntimeException("读写失败");
				}
			if(bfr!=null)
				try
				{
					bfr.close();
				}
				catch (IOException e)
				{
					throw new RuntimeException("读写失败");
				}
		}
	}
}

装饰模式

装饰者模式：

当想要对已有的对象进行功能增强时，

可以定义类，将已有对象传入，基于已有的功能，并提供如加强功能。

那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被修饰的对象。

并基于被修饰的对象的功能，提供更强的功能。

/*
装饰者模式：
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供如加强功能。
那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被修饰的对象。
并基于被修饰的对象的功能，提供更强的功能。
*/
class Person{
	public void study(){
		System.out.println("学java");
	}
}
//可以定义类，将已有对象传入，基于已有的功能，并提供如加强功能。
class SuperPerson{
	//装饰类通常会通过构造方法接收被修饰的对象。
	private Person p;
	SuperPerson(Person p){
		this.p=p;
	}
	//并基于被修饰的对象的功能，提供更强的功能。
	public void superStudy(){
		System.out.println("准备java");
		System.out.println("学习java");
		System.out.println("使用java");
	}
}

class PersonDemo{
	public static void main(String[] args){
		Person p = new Person();
		SuperPerson sp = new SuperPerson(p);
		sp.superStudy();
	}
}

装饰者模式与继承：

MyReader 专门用于读取数据的类

|----MyTextReader

|----MyBufferTextReader

|----MyMediaReader

|----MyBufferMediaReader

|----MyDataReader
|----MyBufferDataReader

class MyBufferReader{

MyBufferReader(MyTextReader text){}

MyBufferReader(MyMediaReader media){}

}

上面这个类的扩展性很差。

找到其参数的共同类型。通过更多的形式，可以提高扩展性。

class MyBufferReader extends MyReader{

private MyReader r;

MyBufferReader(MyReader r){}

}

MyReader 专门用于读取数据的类

|----MyTextReader

|----MyMediaReader

|----MyDataReader
|----MyBufferReader

装饰模式灵活，避免了继承体系的臃肿。而且降低了类与类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的。只不过提供了更强的功能。

所以装饰类和被装饰类通常处于一个体系中。

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详情请查看：http://edu.csdn.net

硅与神经键

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员------IO流（No.1）（IO流概述、Reader、Writer、BufferedReader、BufferedWriter、装饰设模式）

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- IO流概述 IO流用来处理设备间的数据传输java对数据的操作是通过流的方式java用于操作流的对象都在IO包中流按照操作数组分为两种：字节流与字符流流按流向分：输入流和输出流字节流的抽象基类：
复制链接

扫一扫