黑马程序员——IO流（二）

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

-学习字节流操作

字节写入流：FileOutputStream

字节输出流：FileInputStream

基本操作与字符流类相同，但它不仅可以操作字符，还可以操作其他媒体文件。

常见操作例子：

package day19_IO;

import java.io.*;

/**
 * 学习字节流操作
 * @author Administrator
 *
 */
public class Day19_11_ByteStream {
	
	FileInputStream fis = null;
	FileOutputStream fos = null;
	
	public static void main(String[] args) { 
		inputStreamRead_3();
		//inputStreamRead_2();
		//inputStreamRead_1();
		//outputStream();
	}
	
	//学习了解FileInputStream 中的available()方法
	public static void inputStreamRead_3(){
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("OutputStreamDemo.txt");
			
			//获取fis对象所指定文件数据的字节数
			int num = fis.available();
			
			System.out.println("num= "+num);
			
			byte[] b = new byte[num];//要慎用，因为太大的话会超出内存大小
			int len = 0;
			while((len=fis.read(b))!=-1){
				System.out.println(new String(b,0,len));
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if(fis!=null)
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	//字节读取流方式2
	public static void inputStreamRead_2(){
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("OutputStreamDemo.txt");
			byte[] cbuf = new byte[1024];
			int count = 0;
			while((count=fis.read(cbuf))!=-1){
				System.out.println(new String(cbuf,0,count));
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if(fis!=null)
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	//字节读取流方式1
	public static void inputStreamRead_1(){
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("OutputStreamDemo.txt");
			int ch= 0;
			while((ch=fis.read())!=-1){
				System.out.print((char)ch);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if(fis!=null)
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	//字节写入流
	public static void outputStream(){
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("OutputStreamDemo.txt",true);
			fos.write("  / hello new world".getBytes());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if(fos!=null)
					fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
}

-通过字节流复制一个文本文件的例子

package day19_IO;

import java.io.*;

/**
 * 学习字节流操作,通过字节流复制一个文本文件
 * @author Administrator
 *
 */
public class Day19_11_ByteStream1 {
	public static void main(String[] args) {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try {
			fis = new FileInputStream("demo.txt");
			fos = new FileOutputStream("outputStreamDemo.txt");
			
			//fos.write("hello outputStream".getBytes());
			
			int ch  = 0;
			while((ch=fis.read())!=-1){
				fos.write(ch);//-与FileWriter的write方法是有什么区别？
				//System.out.print((char)ch);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if(fis!=null)
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(fos!=null)
					fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

-学习字节流缓冲区

为了提高操作效率，字节流通过提高了字节流缓冲区技术：BufferedInputStream，BufferedOutputStream；

一个通过字节流缓冲区技术实现复制一张JPG图片文件的例子：

package day19_IO;

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

/**
 * 练习通过字节流来实现对图片文件的复制
 * @author Administrator
 *
 */
public class Day19_12_CopyImage {

	public static void main(String[] args) {
		//1：创建引用对象
		FileInputStream fis = null;
		FileOutputStream fos  = null;
		
		try {
			//2：实例化引用对象
			fis = new FileInputStream("initImage.jpg");
			fos = new FileOutputStream("copyImage.jpg");
			
			//3：为了提高效率，定义一个用于暂时存放数据的字节数组cbuf
			byte[] b = new byte[1024];
			int len = 0;
			while((len=fis.read(b))!=-1){
				fos.write(b, 0, len);
			}
		} catch (Exception e) {
			System.out.println("图片复制失败");
			e.printStackTrace();
		} finally {
			try {
				if(fis!=null)
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(fos!=null)
					fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

-System类中的字段：in，out

它们各代表了系统标准的输入和输出设备。

默认输入设备是键盘，输出设备是显示器。

System.in的类型是InputStream.

System.out的类型是PrintStream，它是OutputStream子类FileOutputStream的子类

-标准输入输出流示例：获取键盘录入数据，然后将数据流向显示器，那么显示器就是目的地。

通过System类的setIn，setOut方法对默认设备进行改变。

System.setIn(new FileInputStream(“1.txt”));//将源改成文件1.txt。

System.setOut(new FileOutputStream(“2.txt”));//将目的改成文件2.txt

因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。

BfferedReader bufr = 

new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw = 

new BufferedWriter(new OutputStreamWriter(System.out));

-通过键盘录入的经典练习：通过键盘录入一行数据，将小写字母变成大写字母，并打印到控制台，当录入为"over" 时，结束程序，停止录入。

（提示：一种是按照平常方式实现，一种是通过转换流 InputStreamReader -> BufferedReader，然后通过BufferedReader 中readLine()方法实现。）

package day19_IO;

import java.io.IOException;
import java.io.InputStream;

/**
 * 学习通过键盘读取录入
 * 		System.out：对应的是标准输出设备-控制台
 * 		System.in：对应的是标准输入设备- 键盘
 * 
 * 练习需求：
 * 		通过键盘录入数据，当录入一行数据后将该行数据转变为
 * 		大写字母后打印到控制台；如果录入的是over，则停止录入。	
 * @author Administrator
 *
 */
public class Day19_15_SystemIn {

	public static void main(String[] args) throws IOException {
		InputStream in = System.in;
		
		//创建一个StringBuilder容器
		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);
		}
	}

}

-学习读写转换流：InputStreamReader，OutputStreamWriter

转换流出现的主要原因和作用：

1:字符流与字节流之间转换的桥梁；

2：可以按照指定的编码表操作文件。

通过转换流完成上面那个小练习：

package day19_IO;

import java.io.*;

public class Day19_16_IOTransStream {

	public static void main(String[] args) throws IOException {
		//获取键盘录入对象
		//InputStream in = System.in;
		
		//将字节流对象转换为字符流对象，使用转换流- InputStreamReader
		//InputStreamReader isr = new InputStreamReader(in);
		
		//为了提高效率，将字符串进行缓冲区技术处理，使用BufferedReader
		//BufferedReader br =new BufferedReader(isr);
		
		//优化为一句,读入
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		//写入
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		String s = null;
		while((s=br.readLine())!=null){
			if("over".equals(s))
				break;
			bw.write(s.toUpperCase());
			bw.newLine();
			bw.flush();//得刷新！
			//System.out.println(s.toUpperCase());
		}
		br.close();
	}
}

-IO流操作规律总结

（1）明确操作源和目的

源：输入流，InputStream, Reader

目的：输出流，OutputStream, Writer

（2）操作的数据是否是纯文本

是：采用字符流

否：采用字节流

（3）明确体系后，在在根据情况确定使用哪个具体的操作对象

通过设备来进行区分

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

目的设备：内存，硬盘，操作台

字节流：（输入）InputStream, FileInputStream, BufferedInputStream

   （输出）OutputStream, FileOutputStream, BufferedOutputStream

字符流：（输入）Reader, FileReader, BufferedReader, InputStreamReader

    （输出）Writer, FileWriter, BufferedWriter, OutputStreamWriter