12.IO（一）【IO流概述】【字符流】【字符流缓冲区】【装饰设计模式】【字节流】

最新推荐文章于 2022-08-04 11:37:24 发布
最新推荐文章于 2022-08-04 11:37:24 发布
阅读量1k 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011374699/article/details/14104157
版权


一、IO流概述

1.        IO，是InputOutput的缩写。

2.        流，是传递数据信息的载体，是程序中的数据所经历的路径。

3.        流分为输入流和输出流。输入流是将数据从数据源传递给程序。输出流是将数据从程序传递到目标的地方，如硬盘，内存，网络等。

4.        Java语言操作数据就是通过流的方式。

5.        Java中的IO流库提供了大量的流库，均包含在IO包中，要使用这些流类必须先用import语句引入。

6.        根据输入输出的数据类型，流可以分为字节流（Byte）和字符流（Chracter），他们处理信息的基本单位分别是字节和字符。

 

二、字符流

1.        字符流主要用于操作文本数据，使用字符流读取文字字节数据时，不直接操作，而是先查编码表，获取对应的文字，再进行操作。

简单说，字符流==字节流+编码表。

2.        如果要操作文本数据，优先考虑字符流。

3.        个人理解：Java中的字符流融合了编码表，默认的编码表是当前系统的编码表。中文是Unicode编码表，是双字节的。InputStream处理数据时以字节为基本单位，在处理文本数据时，不是很方便，处理比较慢，所以Java为处理字符提供了一套专门的类，简化编程。

4.        字符流的两个顶层抽象父类：Reader和Writer。每次读取或写入16位字符。Reader是读取输入流，Writer是写出输出流。

5.        Writer的常用子类为FileWriter，用于操作文件。Reader常用的操作文件的子类为FileReader。

注意：基类的子类都是以父类作为后缀名，前缀为要实现的功能。如FileWriter，前缀为File，说明该子类专门用于操作文件的写出。

6.        使用字符流读取数据的步骤：

l 创建FileReader对象，与数据相关联。在创建读取流对象时，必须要明确被读取的文件，而且该文件一定是存在的。否则会抛出FileNotFoundException异常。

l 调用流的read()方法读取数据。intread()方法，读取单个字符。在字符可用、发生 I/O错误或者已到达流的末尾前，此方法一直阻塞。如果已达到结尾，返回-1.

read(char[] buf):将字符读入数组。buf，目标缓冲区。

l 关闭流：close();关闭流后，将不能再读取数据。

<span style="font-size:18px">import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

//读取一个文本文件，将读取到的字符打印到控制台。

public class FileReaderDemo {

	public static void main(String[] args) throws IOException {

		//1.创建读取字符数据的流对象
		/*
		 * 在创建读取流对象时，必须要明确被读取的文件，一定要确定该文件是存在的。
		 * 
		 * 用一个读取流关联一个已存在文件。
		 */
		FileReader fr = new FileReader("demo.txt");
	
		int ch = 0;
		while((ch = fr.read())!=-1){
			System.out.print((char)ch);
		}
		fr.close();
	}

}
</span>

 

例2：读取一个文本文件，将读取到的字符打印到控制台。

<span style="font-size:18px">import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo2 {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("demo.txt");//文件里的字符为abcdw
		/*
		 * 使用read(char[]) 读取文本文件数据。
		 * 
		 * 先创建字符数组。
		 */
		char[] buf = new char[1024];
		int len = 0;//因为数量一直在变，所以可以定义变量。
		while((len=fr.read(buf))!=-1){
			System.out.println(new String(buf));
		}
//		method_1(fr, buf);
		fr.close();
	}

	/**
	 * @param fr
	 * @param buf
	 * @throws IOException
	 */
	public static void method_1(FileReader fr, char[] buf) throws IOException {
		int num = fr.read(buf);//将读取到的字符存储到数组中。
		System.out.println(num+":"+new String(buf));
		/*
		 * 数组容量为3，所以num=3,
		 */
		
		int num1 = fr.read(buf);
		System.out.println(num1+":"+new String(buf));
		/*
		 * 文件里剩下两个字符：dw。再次读取时，读取到的dw重新存到数组，覆盖了ab，num1 = 2，同时c没被覆盖。
		 * 所以这次输出dwc
		 */
		int num2 = fr.read(buf);
		System.out.println(num2+":"+new String(buf));
		/*
		 * 文件里没有字符，返回-1.所以num = -1, 
		 * 数组里的字符没有被覆盖，所以输出dwc，和第二次一样。
		 */
	}
}
</span>


 

7.        使用字符流写出数据的步骤：

l 创建FileWriter对象，与数据相关联。创建该对象时，必须要明确存储数据的目的地。如果文件不存在，则会自动创建。如果文件存在，则会覆盖原来的文件。

l 调用write(String str):写入字符串到目的地，如果要续写，可以写为write(String str ,true),这样就不会覆盖原文件，而且会在文件末尾处添加数据。Write(char[]buf,int off, int len)，写入数组的某一部分。

l 调用flush()方法，将缓冲区的数据写入到目的地中。刷新之后还可以继续写数据到目的地。

l close（）方法，用于关闭流。关闭资源之前，会刷新缓冲区。关闭之后，不能再写入数据到目的地中，否则会抛出异常。

例子：将一些文字存储到硬盘中的文件。

<span style="font-size:18px">import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
	private static final String LINE_SEPARATOR = System.getProperty("line.separator");

	public static void main(String[] args) throws IOException {

		//创建一个可以往文件中写入字符数据的输出流对象。
		
		FileWriter fw = new FileWriter("demo.txt");//加入true,续写。
		
		fw.write("advasdf"+LINE_SEPARATOR+"lala");//换行
		fw.write(LINE_SEPARATOR+"haha");
		/*
		 * 进行刷新，将数据直接写到目的地中。刷新后还可以继续操作流。
		 */
//		fw.flush();
		
		/*
		 * 关闭流，关闭资源，关闭之前先刷新，其实就是close方法调用了flush方法。关闭之后就不能再操作当前流、
		 */
		fw.close();
		
//		fw.write("sfeg");//java.io.IOException: Stream closed
		
	}
}
</span>


 

练习：从E:\eclipse\day20e中复制文件demo.txt的内容到E:\目录的democopy。txt文件中。

思路：
  既然是复制文件内容，那么先读取文件。优先考虑字符输入流。FileReader
  读取文件后再写入到新文件中。FileWriter
  
  步骤：
  1.创建要进行复制的文件对象和保存复制后的文件对象。
  new FileReader()
  new FileWriter()
  
  2.读取文件内容，一个一个复制过去，或者建立字符数组，一次性读取。
  3.频繁读写操作。
  4.关闭流。

<span style="font-size:18px">import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileCopyTest_2 {
	public static void main(String[] args)  {
		FileReader copyBy = null;
		FileWriter copy = null;
		try {
			String readerPath = "IO流_2.txt";//要复制的文件路径。
			String writerPath = "testcopy_2.txt";//复制到目标文件。
			
			copyBy = new FileReader(readerPath);
			copy = new FileWriter(writerPath);
			
			char[] file = new char[1024];//定义字符数组。
			
			int len = 0;
			while((len=copyBy.read(file))!=-1){//读取字符到数组
				
				copy.write(file,0,len);//从字符中写入目标文件。
			}
		} catch (Exception e) {
			throw new RuntimeException("读写失败！");
		}finally{
			if(copyBy!=null)//被创建成功，需要关闭
				try {
					copyBy.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			if(copy!=null)
				try {
					copy.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
		}
	}
}</span>

 

三、字符流缓冲区

概述

字符流缓冲区分为输入流缓冲区和输出流缓冲区，即

BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

                                    可以指定缓冲区大小，或者可以使用默认大小。一般情况下，默认大小就足够了。

                                    提供了readLine()方法，从而实现行的高效读取。

BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

                                    该类提供了newLine()方法，他使用了平台自己的分隔符，从而实现换行。

1.      缓冲区的原理：

假设内存中有一数组buf，缓冲区调用继承来的bufr.read(buf)，从硬盘读取一些数据到内存。

从内存中读取数据时，调用:这个read是从缓冲区中的取出的字符数据。所以覆盖了父类中的read方法。这个read本身就是一个高效的read().直接从缓冲区读取，不用到硬盘中读取。

 

用bufr.read()读取字符后，就可以操作字符了，根据文本的行特点，可以按照行读取，所以进行了下一步的动作，就有了新的方法readLine().

2.      readLine（）方法的原理：

在缓冲区中，bufr.read()从存储字符的容器读取字符后，不直接操作，而是在缓冲区开辟另一个临时容器，将字符装入，然后继续读取，直到读取换行符\r,终止符\n，并且不包含换行符，这时候才从临时容器中一次性读取存储的有效字符。这就是readLine()原理。临时容器可以是StringBuilder，因为最终返回的是字符串。只是在read()基础上加了一个判断换行标记。

简单说，readLine()方法：使用了缓冲区的read方法，将读取到的字符进行缓冲并判断换行标记，将标记前的缓存数据编程字符串输出。

     BufferedWriter示例：

    

<span style="font-size:18px">import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
	public static final String LINE_SEPARATOR = System.getProperty("line.separator");
	public static void main(String[] args) throws IOException {
		FileWriter fw = new FileWriter("buf.txt");
		
		//为了提高写入效率，使用字符流的缓冲区。
		//创建一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联。
		BufferedWriter bufw = new BufferedWriter(fw);
		
		//使用缓冲区的写入方法将数据写入缓冲区中。
//		bufw.write("你好"+LINE_SEPARATOR+"你好two");
//		bufw.write("你好！");
//		bufw.newLine();
//		bufw.write("我不好！");
		for (int i = 0; i < 4; i++) {
			bufw.write("早安世界"+i);
			bufw.newLine();
			bufw.flush();
		}
		//使用缓冲区的刷新方法将数据刷入目的地中。
		bufw.flush();
	
		//关闭缓冲区，其实就是关闭被缓冲的流对象。
		bufw.close();
	}
}
</span>

      

      BufferedReader示例：

     

<span style="font-size:18px">import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {

	public static void main(String[] args) throws IOException {

//		demo();
		FileReader fr = new FileReader("buf.txt");
		BufferedReader bufr = new BufferedReader(fr);
		/*
		 * 行的读取。
		 * readLine()：一行一行的读取。
		 */
		
		String line = null;
		while((line=bufr.readLine())!=null){
			System.out.println(line);
		}
		
		/*
		String line1 = bufr.readLine();
		System.out.println(line1);
		
		String line2 = bufr.readLine();
		System.out.println(line2);
		
		String line3 = bufr.readLine();
		System.out.println(line3);
		
		String line4 = bufr.readLine();
		System.out.println(line4);
		String line5 = bufr.readLine();
		System.out.println(line5);
		*/
		bufr.close();
	}

	/**缓冲字符数组
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	public static void demo() throws FileNotFoundException, IOException {
		FileReader fr = new FileReader("buf.txt");
		char[] buf = new char[1024];
		int len = 0;
		while((len=fr.read(buf))!=-1){
			System.out.println(new String(buf,0,len));
		}
		fr.close();
	}
}
</span>

       

自定义读取缓冲区：

自定义的读取缓冲区，其实就是模拟一个BufferedReader。
  

分析：
  缓冲区中无非就是封装了一个数组，
  并对外提供了更多的方法对数组进行访问。
  其实这些方法最终操作的都是数组的角标。
  
缓冲的原理：
  从源中获取一批数据装进缓冲区中。
  再从缓冲区不断的取出一个一个数据。
  
  在此次取完后，再从源中继续取一批数据进缓冲区。
  当源中的数据取完时，用-1作为结束标记。

<span style="font-size:18px">import java.io.FileReader;
import java.io.IOException;

public class MyBufferReader {

	private FileReader r;
	
	//定义一个数组作为缓冲区
	private char[] buf = new char[1024];
	
	//定义一个指针，用于操作数组元素，操作到最后一个元素时，指针归0.
	private int pos = 0;
	
	//定义一个计数器，用于记录缓冲区的数据个数，当该数据减到零时，就从源中继续获取数据到缓冲区中。
	private int count = 0;
	
	MyBufferReader(FileReader r){
		this.r = r;
	}

	public int myRead() throws IOException{
		if(count==0){
			count = r.read(buf);
			pos = 0;
		}
		if(count<0)
			return -1;
		char ch = buf[pos];
		pos++;
		count--;
		return ch;

		/*
		//1.从源中获取数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据。
		if(count==0){
			count = r.read(buf);
			
		//每次获取数据到缓冲区后，角标归零。
		pos = 0;
		char ch = buf[pos];
		
		pos++;
		count--;
		
		return ch;
			
		}
		
		if(count<0)
			return -1;
		
		else{
			
			char ch = buf[pos];
			
			pos++;
			count--;
			
			return ch;
		}
		*/
		
	}
	
	public String myReadLine() throws IOException{
		
		StringBuilder sb = new StringBuilder();
		
		int ch = 0;
		
		while((ch=myRead())!=-1){
			
			if(ch=='\r')
				continue;
			if(ch=='\n')
				return sb.toString();
			
			sb.append((char)ch);
			
		}
		
		//健壮性判断
		/*
		 * 因为假如“早安世界3”这一行字符最后没有换行字符“\n”,虽然数据存储到缓冲区中，
		 * 但是没有写入文件。所以要判断。
		 */
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}

	public void close() throws IOException {
		r.close();
	}
</span>

 

四、装饰设计模式（wrapper）

1． 概述

    当想对一组对象功能进行增强时，可以自定义一个增强功能的类，将已有对象传递给增强功能类的构造函数。

    基于已有对象的功能，添加想增强的功能。那么自定义的类称为装饰类。这种设计模式称为装饰设计模式。

2． 装饰的特点：

    装饰类和被装饰类都必须所属同一个接口或者父类。

3． 继承和装饰都能实现功能的扩展，两者有什么区别呢？

首先有一个继承体系：

writer

|--TextWriter:用于操作文本。

|--MediaWriter:用于操作媒体。

想要对操作的动作进行效率的提高。按照面向对象，可以通过继承对具体的进行功能的扩展。

效率提高需要加入缓冲技术。

可以通过继承实现功能的扩展。

Writer

|--TextWriter:用于操作文本。

           |--BufferedTextWriter:加入了缓冲技术的操作文本的对象。

|--MediaWriter:用于操作媒体。

           |--BufferedMediaWriter

 

但是通过继承不理想：如果这个体系进行功能的扩展，又增加流对象。

那么这个流要提高效率，也要产生子类。就会发现只为提高功能而进行继承，导致继承体系越来越臃肿。不够灵活。

 

既然加入的都是同一种技术，继承是让缓冲和具体的对象相结合，可不可以将缓冲进行单独封装，哪个对象需要缓冲就将哪个对象和缓冲相关联。

class Buffer{

Buffer(TextWriter w)

{

}

Buffer(MediaWriter w)

{

}

}        

class BufferWriter extends Writer{

BufferWriter(Writer w){

}

}

 

这样，原来的体系就变成了：

writer

           |--TextWriter:用于操作文本。

           |--MediaWriter:用于操作媒体。

           |--BufferWriter:用于提高效率。

总结：

  •  装饰比继承更灵活。避免了体系因继承而臃肿，并且降低了类和类之间的耦合。
  •  从继承结构转为装饰的组合结构。
  •  装饰类要增强已有对象的功能，具备和原来对象的功能，而且又有自己增强的功能。

注意：要增强功能时，多用装饰类，少用继承。装饰类更灵活。

   示例：人有吃饭的功能，现在想人多了两项功能：吃饭前喝开胃酒，饭后吃甜点。

   

<span style="font-size:18px">public class PersonDemo {
	public static void main(String[] args) {
		Person p = new Person();
		p.chifan();
		
		//装饰
		NewPerson p1 = new NewPerson(p);
		p1.chifan();
		
		//继承
		NewPerson_2 p2 = new NewPerson_2();
		p2.chifan();
	}
}

class Person{
	void chifan(){
		System.out.println("吃饭");
	}
}

//这个类的出现是为了增强Person而出现的。装饰
class NewPerson{
	private Person p;
	NewPerson(Person p){
		this.p = p;
	}
	
	public void chifan(){
		System.out.println("开胃酒");
		p.chifan();
		System.out.println("甜点");
	}
}

//通过继承实现功能增强
class NewPerson_2 extends Person{
	public void chifan(){
		System.out.println("开胃酒");
		super.chifan();
		System.out.println("甜点");
	}
}
</span>


五、字节流

1.      概述

用于操作字节数据，每次读取或者写入8位。字节流能操作文本数据，也可以操作其他媒体文件。

2.      字节流的两个基类：

InputStream输入流，用于读取数据。

OutputStream输出流，用于写入数据。

3.      由于媒体文件数据都是以字节存储，所以字节流对象可以直接操写入数据到文件，不用再进行刷新动作。

为什么不用进行刷新流的动作呢？

因为字节流操作的是字节，是数据的最小单位，不用像字符流一样需要转换为字节，可直接将字节数据写入到文件。

4.      InputStream特有方法：

int available();返回文件的字节大小。

注意：可以调用此方法来获取字节大小，从而创建一个和文件大小一致的数组，从而省去循环判断。

          但是如果文件过大，超过了虚拟机分配的默认内存64M，此数组长度所占内存空间就会溢出。

          所以，此方法适用于文件较小的时候。

   例子：复制图片

   

<span style="font-size:18px">import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//复制图片
public class copyPic {
	public static void main(String[] args) {
		copyPicMethod1();
		copyPicMethod2();
	}
	
	//avaliable方法
	public static void copyPicMethod2() {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("F:\\我的女孩.jpg");
			fos = new FileOutputStream("F:\\我的女孩1.jpg");
			//调用avaliable方法，获取字节数大小，创建字节数组
			byte[] buf = new byte[fis.available()];
			
			fis.read(buf);//复制数据
			fos.write(buf);//黏贴文件到指定路径。
		} catch (IOException e) {
			throw new RuntimeException("复制图片失败！");
		}finally{
			if(fis!=null){
				try {
					fis.close();
				} catch (IOException e) {
					throw new RuntimeException("读取图片失败！");
				}
			}
			
			if (fos!=null) {
				try {
					fos.close();
				} catch (IOException e) {
					throw new RuntimeException("写入图片失败！");
				}
			}
		}
	}

	// 创建字符数组作为缓冲区
	public static void copyPicMethod1() {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("F:\\我的女孩.jpg");
			fos = new FileOutputStream("F:\\我的女孩1.jpg");

			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{
			if(fis!=null){
				try {
					fis.close();
				} catch (IOException e) {
					throw new RuntimeException("读取图片失败！");
				}
			}
			
			if (fos!=null) {
				try {
					fos.close();
				} catch (IOException e) {
					throw new RuntimeException("写入图片失败！");
				}
			}
		}
	}

}
</span>



                             

炳烛以期明
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IO流所涉及到的Decorator设计模式
07-29
在Java编程语言中，IO流（Input/Output Stream）是处理数据输入和输出的主要机制，而Decorator设计模式是一种结构型设计模式，它允许我们在运行时动态地给对象添加新的行为或责任。这两种概念的结合使得Java IO系统...
字符流缓冲流等1
08-04
装饰者设计模式是一种结构型设计模式，允许在运行时给对象添加新的行为或责任。在Java IO流中，通过装饰者模式，我们可以动态地给流增加功能，而无需修改原有代码。 总结来说，理解并熟练掌握这些流的概念和用法...
黑马程序员_<<字符流的缓冲技术和装饰类(BufferedWriter,BufferedReader,LineNumberReader)>>...
ithome
10-01 100
--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ -------------------- 1.BufferedWriter BufferedWriter是利用的缓冲技术，操作的是输入流，把Writer对象构造函数的参数传入，首先是把信息读取到缓冲流中，然后再刷新缓冲流，把读到的文件信息传到目的地。这提高了写入...
字节流，缓冲流，字符流
chan_fan的博客
12-17 231
今天晚上学习了文件采用字节流和缓冲流的读写运作机制，甚是开心，特来和大家分享。 在此之前大家大致要懂一下文件操作，不会也没关系。 在Java中一般会根据IO流把文件分为下面两类 ...
心得---字符流、缓冲流、装饰模式
weixin_30411997的博客
05-15 153
1. Reader类和Writer类用来专门处理字符流。这两个类都是抽象类，从他们派生出了许多子类，增强功能、提高效率，实现各种不同要求的字符输入/输出流的处理。 IO体系中的子类名后缀都是父类名称，而前缀都是体现子类功能的名字。字符流用于存储和检索文本。两者的使用方法与InputStream类和OutputStream类基本相同，不同的是，这两个类以Unico...
字符流的缓冲区和装饰模式
望不见彼岸，情不离此岸
09-14 616
一、字符流缓冲区  1. 为什么要缓冲区？ 程序频繁地操作一个资源（如文件），则性能会很低，此时为了提升性能，就可以将一部分数据暂时读入到内存的一块区域中，以后直接从此区域中读取数据即可，因为读内存速度比较快，这样提高性能。在IO中引入缓冲区，主要是提高流的读写效率。 2. 缓冲技术
J2SE中带缓冲的字符流与装饰设计模式
lijizh1013的专栏
10-21 1152
缓冲的字符流BufferedReader/BufferedWriter 采用缓冲处理是为了提高效率，如果没有缓存，例如FileReader对象，每次调用read()方法进行读操作时，都会直接去文件中读取字节，转换成字符并返回，这样频繁的读取文件效率很低。   缓冲的字符流的出现提高了对流的操作效率，原理就是将数组进行封装。   在使用缓冲的字符流对象时，缓冲的存在是为了增强流的功能，因此
java io流PPT课件.pptx
10-07
Java的I/O设计遵循了一种称为“装饰者模式”的组织模式，允许在不改变原有类的基础上增加新的功能。 在进行I/O操作时，一般需要以下步骤： 1. 创建一个与特定介质（如文件、网络连接等）相关的输入/输出对象。 2. ...
JavaIO的常用方法.docx
12-02
根据操作的数据单位不同，流又分为字节流（Byte Stream）和字符流（Character Stream）。字节流可以处理任意类型的数据，而字符流则主要用于处理文本数据。 1. 字节流： - 字节输入流（InputStream）：InputStream...
java基础知识IO流讲解和练习.rar
最新发布
11-01
Java IO流还支持过滤流（Filter Stream）的概念，这是一种设计模式，允许我们在已存在的流上添加额外的功能，例如BufferedInputStream和BufferedReader可以提供缓冲功能，提高读写性能；DataInputStream和...
字符流的缓冲区
qq_44543430的博客
04-25 1327
作者：杨裙 本次任务完成时间：2019年4月25日 开发工具与关键技术：MyEclipse 10、Java 1、 拥有缓冲区的流称为缓冲流。缓冲流的最大特点就是，可以提高写入数据和读取数据的效率。相比较而言，直接在文件读取数据和写入数据，那么比在缓冲区读取数据要慢很多。所以，当读取文件的时候，用缓冲流来读取和写入数据，其读写的效率会大大提升，这就是使用缓冲区的好处。 2、 字符流的缓冲流有Buff...
【java笔试系列六】I/O整理
生命奇迹泉的专栏
06-27 562
一、简介 Java IO主要在java.io包下，分为四大块近80个类： 1、基于字节操作的I/O接口：InputStream和OutputStream 2、基于字符操作的I/O接口：Writer和Reader 3、基于磁盘操作的I/O接口：File 4、基于网络操作的I/O接口：Socket（不在java.io包下） 影响IO性能的无非就是两大因素：数据的
JavaSE进阶 | 深入理解Java IO流（缓冲流、转换流、数据流、标准输出流、File类）
m0_61933976的博客
08-04 1114
缓冲流、转换流、数据流、标准输出流、File类的理解
Java的IO（输入输出）详谈——字符流
monkey_wei的博客
05-15 166
Java还提供了字符流，用于操作字符。与字节流相似，字符流也有两个抽象基类，分别是Reader和Writer。Reader是字符输入流，用于从目标文件读取字符；Writer是字符输出流，用于向目标文件写入字符。 其中FileReader和FileWriter是两个很常用的子类，FileReader类用来从文件中读取字符，操作文件的字符输入流。 接下来用一个案例来说明： import java.io.File; import java.io.FileReader; import java.io.IOExcep
字节流/字符流-缓冲区类
weixin_34236869的博客
06-20 126
2019独角兽企业重金招聘Python工程师标准>>> ...
File类&I/O流：字节流，字符流，缓冲流总结
weixin_51094637的博客
12-08 1253
目录 一，File类 1.概述以及构造方法 1） 概述 2）构造方法 2.创建文件/目录的（三个方法） 3.判断和获取功能的方法 1）判断功能 2）获取功能 4.删除 二，I/O流 1.概述 2.I/O流分类（三种） 2.字节流 3.字符流 小结 一，File类 在学习I/O流之前我们需要先了解File,知道如何创建文件/目录，如何判断和获取功能，如何删除文件/文件夹。 1.概述以及构造方法 1） 概述 ...
Java 字节字符转换流
Rainary
05-25 967
InputStreamReader OutputStreamWriter 不同的输入输出流是为了适应不同的场景。字节字符转换流的适用场景为：数据是以字节形式在网络中传输的。对于输入流，从网络上读取二进制字节数据，然后需要将读取的字节转换为字符。对于输出流也是这样的，读取字符数据，然后将字符数据转换为字节数据，并写入到网络中。Java import java.io.FileInputStream;
100.有哪些类型的缓冲流？缓冲流简介，什么是缓冲流？
嘻哈怪才的博客
01-18 974
有哪些类型的缓冲流？缓冲流简介，什么是缓冲流？ 【类型】 <1>BufferedInputStream 字节缓冲输入流 <2>BufferedOutputStream 字节缓冲输出流 <3>BufferedReader 字符缓冲输入流 <4>BufferedWriter 字符缓冲输出流 【简介】 <1>缓冲流是java提供的系统缓冲，底层都是一个缓冲数组，根据处理的数据方式不同，提供的数据有字节缓冲数组和字符缓冲数组； <2>字节
理解Java中字符流与字节流的区别
weixin_30670151的博客
04-21 774
1. 什么是流 Java中的流是对字节序列的抽象，我们可以想象有一个水管，只不过现在流动在水管中的不再是水，而是字节序列。和水流一样，Java中的流也具有一个“流动的方向”，通常可以从中读入一个字节序列的对象被称为输入流；能够向其写入一个字节序列的对象被称为输出流。 2. 字节流 Java中的字节流处理的最基本单位为单个字节，它通常用来处理二进制数据。Java...
Java I/O流详解：字节流、字符流与缓冲流
处理流通过装饰者设计模式实现，可以叠加在已有流上，提供更高级的功能，而实际的数据读写仍然由底层的节点流完成。 5. **缓冲流** - 缓冲流（如BufferedInputStream、BufferedReader）是处理流的一个重要类别，它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值