黑马程序员09_IO

时间：2023-02-18 18:00:10

Java IO

IO概述

IO流用来处理设备之间的数据传输，Java对数据的操作是通过流的方式，用于操作流的对象都在IO包中。

  • IO框架体系:

 

IO流的分类

按数据流的方向

输入流Input

输出流OutPut

按处理数据单位

字节流

InputStream  OutputStream

字符流

Reader Writer

按数据流的功能

节点流

处理流（功能流）

 

输入流

可从对象中读数据

输出流

可将数据写入对象中

字节流

一次传输一个字节

字符流

一次传输一个字符（双字节，Unicode编码），可以解决字符编码问题

节点流

从特定的地方读写的流类，例如：磁盘或一块内存区域。

处理流

使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或输出流连接创建的。

 

转换流

InputStreamReader

可将采用特殊字符编码的字符数据转化为Unicode编码的字符数据

OutputStreamWriter

可将采用Unicode编码的字符数据，转化为特殊字符编码的字符数据

 

  • 字节和字符流讲解：

二者仅仅是操作单位不一样。

InputStream和Reader是所有输入流的基类

一般来说处理字符或字符串时使用字符流，处理字节或二进制对象时应使用字节流；

备注：字符流必须关闭资源，因为它中间有缓冲区！而字节流不需要！但是一般都会（最后）关闭资源！

 

字节流

字节流主要是操作byte(字节)的类型数据:

字节输出流：OutputStream

字节输入流：InputStream

字符流

Java中的字符是Unicode编码,是双字节的,1个字符 等于 2个字节;

使用字节来处理字符文本就不太方便了,此时可以考虑使用字符流;

字符流主要是操作char的类型数据:

字符输出流：Writer

字符输入流：Reader

  • 字节流和字符流的区别

字节流和字符流在使用上的代码结构都是非常类似的，但是其内部本身也是有区别的，因为在进行字符流操作的时候会使用到缓冲区（内存中），而字节流操作的时候是不会使用到缓冲区的。

在输出的时候，OutputStream类即使最后没有关闭内容也可以输出。但是如果是Writer的话，则如果不关闭，最后一条内容是无法输出的，因为所有的内容都是保存在了缓冲区之中，每当调用了close()方法就意味着清空缓冲区了。那么可以证明字符流确实使用了缓冲区：

字节流：程序 → 文件

字符流：程序 → 缓冲区（内存中） → 文件

如果现在字符流即使不关闭也可以完成输出的话，则必须强制性清空缓冲区：

方法：public void flush() throws IOException

 

 

 

fileWriter

 

知识点一：建立

步骤：

1、建立流  FileWriter fw = new FileWriter("demo.txt") 

2、输入    fw.write("abcde");

3、清空    fw.flush();

4、关闭    fw.close();

import java.io.*;
class  test
{
	public static void main(String[] args) throws IOException
	{
		//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
		//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
		//其实该步就是在明确数据要存放的目的地。
		FileWriter fw = new FileWriter("demo.txt");

		//调用write方法，将字符串写入到流中。
		fw.write("abcde");

		//刷新流对象中的缓冲中的数据。
		//将数据刷到目的地中。
		//fw.flush();


		//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
		//将数据刷到目的地中。
		//和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
		fw.close();
	}
}

知识点二：需要异常处理

代码：

import java.io.*;
class  FileWriterDemo2
{
	public static void main(String[] args) 
	{
		FileWriter fw = null;
		try
		{
			fw = new FileWriter("demo.txt");  
			fw.write("abcdefg");

		}
		catch (IOException e)
		{
			System.out.println("catch:"+e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null)
					fw.close();				
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
			
		}		
	}
}

知识点三：对已有文件续写

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

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

知识点四：换行

      fw.write("nihao\r\nxiexie");

  • 练习：
import java.io.*;
class  FileWriterDemo3
{
	public static void main(String[] args) throws IOException
	{

		//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
		FileWriter fw = new FileWriter("demo.txt",true);

		fw.write("nihao\r\nxiexie");

		fw.close();
	}
}


 

 

 

fileReader

 

知识点一：read()

方法fr.read()为int型，字符编码，一次读一个字符。而且会自动往下读。到末尾返回-1 

知识点二：读文件中的数据

  • 读的方法1：

　　while((ch=fr.read())!=-1)
		{
			System.out.println("ch="+(char)ch);
		}

  • 读方法2：

定义一个字符数组。用于存储读到字符。再用read(char[])，返回的是读到字符个数。

如：

　　FileReader fr = new FileReader("demo.txt");
		//定义一个字符数组。用于存储读到字符。
		//该read(char[])返回的是读到字符个数。
		char[] buf = new char[1024];
		int num = 0;
		while((num=fr.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,num));
		}
		fr.close();

  • 方法3:位于BufferedReader中

while((line=bufr.readLine())!=null)   
		{
			System.out.print(line);
		}
		bufr.close();
  • 练习：读取一个.java文件，并打印在控制台上。 
import java.io.*;
class FileReaderTest 
{
	public static void main(String[] args) throws IOException
	{
		FileReader  fr = new FileReader("DateDemo.java");
		char[] buf = new  char[1024];
		int num = 0;
		while((num=fr.read(buf))!=-1)
		{
			System.out.print(new String(buf,0,num));
		}
		fr.close();
	}
}
  • 练习

：将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()
	{
	
		try
		{
			FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
			//与已有文件关联。
			FileReader fr = new FileReader("RuntimeDemo.java");


			char[] buf = new char[1024];
			int len = 0;
　　//访法2：从C盘读一个字符串，就往D盘写一个字符串。
			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)
				{
				}
		}
	}

	//方法1：从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

 

缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要先有流对象。

知识点一：newLine()该缓冲区中提供了一个跨平台的换行符。

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

知识点二：readLine方法

字符读取流缓冲区：BufferedReader

该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。当返回null时，表示读到文件末尾。

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

原理：

import java.io.*;
class  BufferedReaderDemo
{
	public static void main(String[] args) throws IOException
	{
		//创建一个读取流对象和文件相关联。
		FileReader fr = new FileReader("buf.txt");
		//为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
		BufferedReader bufr = new BufferedReader(fr);
		String line = null;
		while((line=bufr.readLine())!=null)    //读数据的方法3
		{
			System.out.print(line);
		}
		bufr.close();
	}

　

 

 

 

LineNumberReader

 

读功能跟BufferedReader差不多，只是增加了行标

代码如下：

import java.io.*;
class LineNumberReaderDemo 
{
	public static void main(String[] args)throws IOException 
	{
		FileReader fr = new FileReader("PersonDemo.java");
		LineNumberReader lnr = new LineNumberReader(fr);
		String line = null;
		lnr.setLineNumber(100);  //设置起始行，即从100行计数
		while((line=lnr.readLine())!=null)
		{
			System.out.println(lnr.getLineNumber()+":"+line);//读出的内容带行标
		}
		lnr.close();
	}

 

 

 

FileInputStream

FileOutputStream

 

知识点一：写

接收的是字节或者字节数组。

如：

FileOutputStream fos = new FileOutputStream("fos.txt");

fos.write("abcde".getBytes()); //字符串转换成字节数组

        fos.close();

注意：无需刷新

知识点二：读 

  • 方法1：一个字节一个字节   

  • 方法2：用字节数组缓冲

方法2示例：

public static void readFile_2()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=fis.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,len));
		}
		fis.close();
	}

知识点三：available()文件中的字节总数，包括换行字符，可用于定义刚刚好的缓冲区。

该方法慎用，容易内存溢出。

public static void readFile_3()throws IOException
	{
		FileInputStream fis = new FileInputStream("fos.txt");
	    int num = fis.available();
		byte[] buf = new byte[fis.available()];
        //定义一个刚刚好的缓冲区。不用在循环了。
		fis.read(buf);
		System.out.println(new String(buf));
		fis.close();
	}

练习1：复制一个图片.

想要操作图片数据。这时就要用到字节流。

思路：1、用字节读取流对象和图片关联。

  2、用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。

  3、通过循环读写，完成数据的存储。

  4、关闭资源。

import java.io.*;
class  CopyPic
{
	public static void main(String[] args) 
	{ 
		try
		{
			FileOutputStream fos = new FileOutputStream("c:\\2.bmp");
			FileInputStream 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("写入关闭失败");
			}
		}
	}
}

知识点四：想要操作图片数据。这时就要用到字节流。字符流用于处理文字。

练习2：mp3的复制。

通过缓冲区。

BufferedOutputStream
BufferedInputStream
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:\\9.mp3"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\3.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:\\0.mp3"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));
		int by = 0;
		while((by=bufis.read())!=-1)
		{
			bufos.write(by);  		}
		bufos.close();
		bufis.close();
	}
}

　

 

 

InPutStreamReader  OutPutStreamWriter

 

字符和字节之间的桥梁，通常，涉及到字符编码转换时，需要用到转换流。

练习3：读取键盘录入。

System.out:对应的是标准输出设备，控制台。

System.in:对应的标准输入设备：键盘。

需求：

通过键盘录入数据。

当录入一行数据后，就将该行数据进行打印。

如果录入的数据是over，那么停止录入。

  • 形式1:一个字节一个字节的读

import java.io.*;
class  ReadIn
{
	public static void main(String[] args) throws IOException
	{
		InputStream in = System.in;
		StringBuilder sb = new StringBuilder();
		while(true)
		{
			int ch = in.read();
			if(ch=='\r')
				continue;
			if(ch=='\n')
			{
				String s = sb.toString();
				if("over".equals(s))
					break;
				System.out.println(s.toUpperCase());
				sb.delete(0,sb.length());
			}
			else
				sb.append((char)ch);
		}
	}
}

  • 形式2：一行一行的读

import java.io.*;
class test
{
	public static void main(String[] args) throws IOException
	{
		public static void main(String[] args) throws IOException
	{
		//获取键盘录入对象。
		//InputStream in = System.in;

		//将字节流对象转成字符流对象，使用转换流。InputStreamReader
		//InputStreamReader isr = new InputStreamReader(in);

		//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

		//BufferedReader bufr = new BufferedReader(isr);


		//键盘的最常见写法。
		BufferedReader bufr = 
				new BufferedReader(new InputStreamReader(System.in));
		while((str=br.readLine())!=null)
		{
				if("over".equals(str))
					break;
				else
					System.out.println(str);
					
		}
		br.close();
	}
}

知识点一： 

  • InputStreamReader：提供从字节流到字符流的转换

代码如：

InputStream in = System.in;
InputStreamReader isr = new InputStreamReader(in);
  • OutputStreamReader：提供从字节流到字符流的转换

代码如：

OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
然后System.out.println(line)转换为：osw.write(line);
此时记得flush()

总体代码如下：

import java.io.*;
class  TransStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		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();//缓冲区记得flush()
		}
		bufr.close();
	}
}

　　

知识点二：System.setIn()和System.setOut()

System.setIn用于指定输入的源头，如System.setIn(new FileInputStream("PersonDemo.java"));原来键盘是源头，现在变为文件是源头

System.setOut用于指定输出的目的，如ystem.setOut(new PrintStream("zzz.txt"));原来控制台是目的，现在文件时目的。

合起来就变为复制文件。

 

 

 

ObjectInputStream

ObjectOutputStream

 

对对象的操作，即对象的序列化与反序列化

知识点一：对象的序列化

操作的对象需要是实现Serializable接口，已启动其序列化功能，该接口没有方法，为标记接口

import java.io.*;
public class ObjectStreamDemo {
	public static void main(String[] args) throws  IOException {
		ObjectOutputStream objStream = new ObjectOutputStream(new FileOutputStream("ObjectStream.txt"));
		Person p1 = new Person("陈潞",24);
		objStream.writeObject(p1);
		objStream.close()；
	}
}

class Person//自定义类，用于创建对象实例
{
	private String name;
	 int age;
	Person(String name,int age,String country)
	{
		this.name = name;
		this.age = age;
	}
	public String toString()
	{
		return name+":"+age；
	}
}
编译失败：

类实现Serializable接口，系统会自动的产生这个类的序列号，在对象反序列化时需保证读取的对象序列化编码与之前的.class一致：

import java.io.*;
class Person implements Serializable
{
	
	//public static final long serialVersionUID = 42L;
　　//自定义固定的类的序列号
	private String name;
	 int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public String toString()
	{
		return name+":"+age;
	}
}

　　

知识点二：对象的反序列化

利用objStream.readObject()返回对象

ObjectInputStream objStream = new ObjectInputStream(new FileInputStream("ObjectStream.txt"));
		Person p1 = (Person)objStream.readObject();
//此时p1的序列号与写入的时候一致，也就是说，new出p1之后，Person类不能改变
		System.out.println(p1);

知识点三：

静态的属性不可序列化，即序列化的相应字节码相同，序列不同的对象，反序列读出的该静态属性相同。如需要让非静态的属性不可序列化，加修饰符transient即可，如：transient int age

 

 

 

PipedInputStream 

PipedOutputStream

 

管道流：用connection方法连接，使其输入输出在同一管道中进行。多线程又实现同时读取

import java.io.*;
public class PipedDemo {

	public static void main(String[] args) throws Exception //连接并读取
	{
		//Thread(new write(new PipedOutputStream())).start();
		PipedOutputStream out = new PipedOutputStream();
		PipedInputStream in = new PipedInputStream();
		out.connect(in); //连接读取
		new Thread(new write(out)).start();
		new Thread(new read(in)).start();//实现同时读取
	}
}
  

class read implements Runnable//定义线程实现PipedInputStream的读功能
{
	private PipedInputStream in;
	read(PipedInputStream in)
	{
		this.in = in;
	}
	public void run()//读方法的是实现
	{
		byte[] buf = new byte[1024];
		try {
			int len = in.read(buf);
			String str = new String(buf,0,len);
			System.out.println(str);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}


class write implements Runnable//定义线程实现PipedInputStream的写功能
{
	private PipedOutputStream  out;
	write(PipedOutputStream out)
	{
		this.out = out;
	}
	public void run()// 写方法的实现
	{
	
		try {
			out.write("黑马，hello！".getBytes());
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

 

 

 

RandomAcceFile

 

概述：

随机访问文件,自成一派。该类不是算是IO体系中子类。而是直接继承自Object。但是它是IO包中成员。因为它具备读和写功能。内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。其实完成读写的原理就是内部封装了字节输入流和输出流。通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读r，读写rw等。 如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。

如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

RandomAccessFile(File file, String mode)

"r"

以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。

"rw"

打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。

"rws"

打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。

"rwd"  

打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备。

此类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读取字节，并随着对字节的读取而前移此文件指针。如果随机访问文件以读取/写入模式创建，则输出操作也可用；输出操作从文件指针开始写入字节，并随着对字节的写入而前移此文件指针。写入隐含数组的当前末尾之后的输出操作导致该数组扩展。该文件指针可以通过 getFilePointer 方法读取，并通过 seek 方法设置。

 

import java.io.*;
public class RandomFileDemo {
	
	public static void main(String[] args) throws Exception {
		read();
	
	}
	public void write() throws Exception
	{
		RandomAccessFile out = new RandomAccessFile("Rand.txt","rw");
		out.write("陈潞".getBytes());
		//out.write(97);//打开文件，内容为：陈潞a，因为write方法只写最低八位
		out.writeInt(97);//文件里内容为陈潞   a；97分为四个字节
		
		out.write("张三".getBytes());
		out.writeInt(98);
		
		out.close();
	}
	
	public static void read() throws Exception
	{
		RandomAccessFile in = new RandomAccessFile("Rand.txt","rw");
		in.seek(8*1);//调整指针，如果没有这句，指针从0开始
		byte[] buf = new byte[4];
		int len = in.read(buf);
		String str = new String(buf,0,len);
		int age = in.read();
		print("name:"+str);
		print("age:"+age);        
	}
	
	public static void print(Object o){System.out.println(o);}
}

 

　

 

 

DataInputStream

DataOutputStream

 

方便操作基本数据类型的数据的流对象

知识点一：对基本数据类型的基本操作

简单例子：

public static void main(String[] args) throws Exception
	{
			write();
			read();
	}
	
	public static void write() throws Exception
	{
		DataOutputStream out = new DataOutputStream(new FileOutputStream("date.text"));
		out.writeInt(22);//写了4个字节，打开文件看不懂的字符，因为文本按照两个字节读取
		out.writeDouble(22.9888);//写了8个字节
		out.writeBoolean(true);//写了1个字节
	}
	public static void read() throws Exception//按照顺序读取，否则乱码
	{
		DataInputStream in = new DataInputStream(new FileInputStream("date.text"));
		in.readInt();
		in.readDouble();
		in.readBoolean();
	}

　　

知识点二：readUTF()方法，汉字按三个字节读写

用writeUTF写数据，就必须用相应的readUTF读数据

 

public static void readUTFDemo()throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("readutf.txt"));
		String s = dis.readUTF();//一次三个字节的读取
		System.out.println(s);
		dis.close();
	}



 public static void writeUTFDemo()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("writeutf.txt"));
		dos.writeUTF("你好");//汉字按3个字节写入
		dos.close();

		/*OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
		用转换流也可实现同样的功能
		osw.write("你好");
		osw.close();*/
	}

 

　

 

 

ByteArrayInputStream 

ByteArrayOutputStream 

 

ByteArrayInputStream 

ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。把源数据都放在了数组里。

关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。 没有调用底层资源。

在构造的时候，需要接收数据源，而且数据源是一个字节数组。

ByteArrayOutputStream

此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。不用flush

关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。

这就是数据目的地。

 

可用于解释操作流的规律：

源设备：

键盘 System.in，硬盘 FileStream，内存 ArrayStream。

目的设备：

控制台 System.out，硬盘FileStream，内存 ArrayStream。

import java.io.*;
public class ByteArrayDemo {

	public static void main(String[] args) 
	{
		ByteArrayInputStream in = new ByteArrayInputStream("陈潞".getBytes());
		
		ByteArrayOutputStream out = new ByteArrayOutputStream();//目的为字节数组
		int a = 0;
		while((a=in.read())!=-1)
		{
			out.write(a);
		}
		System.out.println(out.size());//结果为：4
		System.out.println(out.toString());//结果为陈潞
	}
}

　　

 

 

IO操的基本规律总结：

 

最痛苦的就是流对象有很多，不知道该用哪一个。

通过三个明确来完成。

  • 1、明确源和目的。

源：输入流。InputStream  Reader

目的：输出流。OutputStream  Writer。

  • 2、操作的数据是否是纯文本。

是：字符流。

不是：字节流。 

  • 3、当体系明确后，在明确要使用哪个具体的对象。

通过设备来进行区分：

源设备：内存，硬盘。键盘

目的设备：内存，硬盘，控制台。

举例说明：将一个文本文件中数据存储到另一个文件中。复制文件。

源：因为是源，所以使用读取流。InputStream Reader 

是不是操作文本文件。是！这时就可以选择Reader这样体系就明确了。接下来明确要使用该体系中的哪个对象。

明确设备：硬盘。上一个文件。

Reader体系中可以操作文件的对象是 FileReader

是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.

FileReader fr = new FileReader("a.txt");

BufferedReader bufr = new BufferedReader(fr);

 

目的：OutputStream Writer

是否是纯文本。是！Writer。

设备：硬盘，一个文件。

Writer体系中可以操作文件的对象FileWriter。

是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter

FileWriter fw = new FileWriter("b.txt");

BufferedWriter bufw = new BufferedWriter(fw);

举例说明：将键盘录入的数据保存到一个文件中。

这个需求中有源和目的都存在。

那么分别分析

源：InputStream Reader

是不是纯文本？是！Reader

 

设备：键盘。对应的对象是System.in.

不是选择Reader吗？System.in对应的不是字节流吗？

为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。

所以既然明确了Reader，那么就将System.in转换成Reader。

用了Reader体系中转换流,InputStreamReader

InputStreamReader isr = new InputStreamReader(System.in);

需要提高效率吗？需要！BufferedReader

BufferedReader bufr = new BufferedReader(isr);

 

目的：OutputStream  Writer

是否是存文本？是！Writer。

设备：硬盘。一个文件。使用 FileWriter。

FileWriter fw = new FileWriter("c.txt");

需要提高效率吗？需要。

BufferedWriter bufw = new BufferedWriter(fw);

 

 

扩展：想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。

GBK与utf-8的区别：gbk包括全部中文字符，一个汉字2个字节；utf-8则包括含全世界所有国家所需要的字符，英文占8位1个字节，中文占24位3个字节。

 

 

标签：

相关文章