黑马程序员---Java基础---字节流和字符流

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

一、字节流

1、IO流概述：

IO流用来处理设备之间的数据传输，上传文件和下载文件

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

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

2、IO流分类：

按照数据流向

输入流 读入数据

输出流 写出数据

按照数据类型

字节流

字符流

3、IO流的层次结构

字节流：可以操作二进制文件、文本文件

1).输出流：OutputStream(抽象类)

FileOutputStream(类):

2).输入流：InputStream(抽象类)

FileInputStream(类):

字符流：只能操作文本文件

1).输出流：Writer(抽象类)

2).输入流：Reader(抽象类)

二、字节流

1、字节输出流 FileOutputStream

构造方法：文件可以不存在，会自动创建

FileOutputStream(String fileName) ：创建一个向具有指定名称的文件中写入数据的输出文件流。 

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

FileOutputStream(String name, boolean append)  创建一个向具有指定 name 的文件中写入数据的输出文件流。 

FileOutputStream(File file, boolean append)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 

输出的方法：

write(int n):输出一个字节；

write(byte[] b):输出一个字节数组；

write(byte[] b,int off,int len):输出一个字节数组的一部分；

成员方法

close():关闭流

package cn.hebei.sjz_字节输出流;

import java.io.File;
import java.io.FileOutputStream;

/*
 * FileOutputStream构造方法
 */
public class Demo {
	public static void main(String[] args) {
		try {
			// 构造方法1
			FileOutputStream out = new FileOutputStream("demo3.txt");
			// 构造方法2
			// File file = new File("demo.txt");
			// FileOutputStream out = new FileOutputStream(file);
			// 构造方法3
			FileOutputStream out2 = new FileOutputStream("demo2.txt", true);
			// 构造方式4
			// File file = new File("demo2.txt");
			// FileOutputStream out2 = new FileOutputStream(file,true);

			// 输出一个字节
			out.write(97);//a
			// 追加写入
			out2.write("你好".getBytes());
			out2.write("我好".getBytes());
			out2.write("\r\n".getBytes());
			// 输出一个字节数组
			byte[] byteArray = { 97, 98, 99 };
			out.write(byteArray);
			// 输出字节数组的一部分
			out.write(byteArray, 1, 2);
			// 输出字符串
			out.write("我是谁".getBytes());
			// 释放资源
			out.close();
			out2.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

2、字节输入流 FileInputStream

构造方法：文件必须存在，否则运行时异常；

FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。 

FileInputStream(File file) ：通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。 

读取的方法：

int read():读取一个字节

int read(byte[] byteArray):读取若干个字节，填充参数的byte[]数组；

package cn.hebei.sjz_字节输入流;

import java.io.File;
import java.io.FileInputStream;

/*
 * 字节输入流  FileInputStream
 */
public class Demo {
	public static void main(String[] args) {
		try {
			// 构造方法1
			FileInputStream in = new FileInputStream("demo3.txt");
			// 构造方法2
			// File file = new File("demo2.txt");
			// FileInputStream in = new FileInputStream(file);

			// 一次读取一个字节
			/*
			 * int n = in.read(); while (n != -1) { System.out.println("读取的字节" +
			 * n); System.out.println("转换为字符" + (char)n); n = in.read();
			 */
			// 另一种写法
			/*int n = 0;
			while ((n = in.read()) != -1) {
				System.out.println("读取的字符" + (char) n);
			}*/
			//一次读取一个字节数组
			byte[] byteArray = new byte[4];
			int n = in.read(byteArray);
			while(n != -1){
				System.out.println("读取的内容：" + new String(byteArray,0,n));
				n = in.read(byteArray);
			}
			//第二种常用的遍历方法
			/*byte[] byteArray = new byte[4];
			int n = 0;
			while((n = in.read(byteArray)) != -1){
				System.out.println("读取的内容：" + new String(byteArray,0,n));
			}*/
			// 释放资源
			in.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

三、字节缓冲流
1、BufferedOutputStream(类--缓冲字节输出流):

构造方法：

BufferedOutputStream(OutputStream out) :

输出的方法：

无特有的，都是继承的：三种输出的方法

2、BufferedInputStream(类--缓冲字节输入流):

构造方法：

BufferedInputStream(InputStream in):

读取的方法：

无特有的，都是继承的：两种读取的方法

package cn.hebei.sjz_缓冲流;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 缓冲输出字节流BufferedOutputStream
 * 缓冲输入字节流BufferedInputStream
 */
public class Demo {
	public static void main(String[] args) throws IOException {
		// 缓冲输出字节流
		BufferedOutputStream out = new BufferedOutputStream(
				new FileOutputStream("demo2.txt"));

		out.write("nihao".getBytes());
		out.write("wohao".getBytes());

		out.close();

		// 缓冲输入字节流
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(
				"demo2.txt"));
		// 一次读取一个字节
		/*
		 * int n = 0; while ((n = in.read()) != -1) { System.out.println("读取的字节"
		 * + n); }
		 */
		// 一次读取一个字节数组
		byte[] byteArray = new byte[1024];
		int n = 0;
		while ((n = in.read(byteArray)) != -1) {
			System.out.println(new String(byteArray, 0, n));
		}
		in.close();

	}
}

四、转换流

字符输出流  OutputStreamWriter(类--转换流)：是字符流通向字节流的桥梁

构造方法：

OutputStreamWriter(OutputStream s):使用平台默认字符集

输出的方法(五种)：

1).write(int n):输出一个字符

2).write(char[] c):输出一个字符数组

3).write(char[] c ,int off, int len):输出字符数组的一部分；

4).write(String str):输出一个字符串

5).write(String str,int off, int len):输出字符串的一部分；

字符输入流   InputStreamReader(类--转换流):是字节流通向字符流的桥梁

构造方法：

InputStreamReader(InputStream in)：使用平台默认字符集

读取的方法(两个):

int read():读取一个字符：返回值：读取的"字符"

int read(char[] c):读取一个字符数组；返回值：读取的"字符数量"

package cn.hebei.sjz_字符转换流;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/*
 * 字符转换输出流   OutputStreamWriter
 * 字符转换输入流   InputStreamReader
 */
public class Demo {
	public static void main(String[] args) throws IOException {
		// 字符输出流
		OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(
				"demo2.txt"));
		// 输出一个字符
		out.write('a');
		// 输出一个字符数组
		char[] charArray = { 'a', 'b', 'c' };
		out.write(charArray);
		// 输出一个字符数组的一部分
		out.write(charArray, 1, 2);
		// 输出一个字符串
		out.write("zheshishui");
		// 输出一个字符串的一部分
		String s = "zheshiwo";
		out.write(s, 2, 2);
		out.close();

		// 字符输入流
		InputStreamReader in = new InputStreamReader(new FileInputStream(
				"demo2.txt"));
		/*
		 * int n = 0; while ((n = in.read()) != -1) { System.out.println(n); }
		 */
		char[] charArray1 = new char[2];
		int n = 0;
		while ((n = in.read(charArray1)) != -1) {
			for (char c : charArray1) {
				System.out.println(c);
			}
		}

	}
}

五、字符流

FileWriter(类--纯字符流):

构造方法：

1).FileWriter(File file)根据给定的 File 对象构造一个 FileWriter 对象。 

2).FileWriter(File file, boolean append) 根据给定的 File 对象构造一个 FileWriter 对象。 

3).FileWriter(String fileName) 根据给定的文件名构造一个 FileWriter 对象。 

4).FileWriter(String fileName, boolean append) 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。 

输出的方法：

无特有方法，都是继承：五种

FileReader(类--纯字符流):

构造方法：

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

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

读取的方法：

无特有方法，都是继承：两种

package cn.hebei.sjz_字符流;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 字符流复制文件
 */
public class Demo {
	public static void main(String[] args) throws IOException {
		FileReader in = new FileReader("Demo.txt");
		FileWriter out = new FileWriter("Demo_copy.txt");
		//一次写一个字符
		/*int n = 0;
		while((n = in.read()) != -1){
			out.write(n);
		}*/
		
		//一次写一个字符数组
		char[] charArray = new char[1024];
		int n1 = 0;
		while((n1 = in.read(charArray)) != -1){
			out.write(charArray,0,n1);
		}
		in.close();
		out.close();
		System.out.println("程序结束");
	}
}

六、字符缓冲流

BufferedWriter(字符流--缓冲流):

构造方法：

BufferedWriter(Writer out):创建一个使用默认大小输出缓冲区的缓冲字符输出流。

输出方法：

无特有方法，都是从父类继承的：五种

特有成员方法：

void newLine():输出一个换行符；

BufferedReader(字符流--缓冲流):

构造方法：

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

读取的方法：

继承父类：两种

String readLine():读取一行数据(不读取换行符)

<pre name="code" class="java">package cn.hebei.sjz_字符缓冲流;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 字符缓冲流
 */
public class Demo {
	public static void main(String[] args) throws IOException {
		// 使用缓冲流复制文件
		BufferedReader in = new BufferedReader(new FileReader("demo2.txt"));
		// 输出流
		BufferedWriter out = new BufferedWriter(new FileWriter("demo2.txt"));
		// 一次写一个字符
		int n = 0;
		while ((n = in.read()) != -1) {
			out.write(n);
		}
		// 一次读写一个字符数组
		char[] charArray = new char[1024];
		int len = 0;
		while ((len = in.read(charArray)) != -1) {
			out.write(charArray, 0, len);
		}
		// 一次读写一行
		String row = null;
		while ((row = in.readLine()) != null) {
			out.write(row);
			out.newLine();// 换行符
		}
		in.close();
		out.close();
	}
}