(42)Java学习笔记——IO流 / 字节流

IO流

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

Java对数据传输采用流的方式

Java中IO流的分类：

流向分 ：

--------| 输入流

--------| 输出流

数据类型分：

--------| 字节流

--------| 字符流 （为了方便操作文本数据）

IO流的常用基类：

字节流的抽象基类：

InputStream  ,   OutputStream

字符流的抽象基类

Reader   ,   Writer  

由于是抽象类，所以要通过其子类来实例化。

每一种基类的子类都是以父类名作为后缀名。XXXReader , XXXWriter 等

FileOutputStream类的构造方法

FileOutputStream(File  file)

FileOutputStream(String  name)

字节流写数据的方式：

public void write(int b) //写一个字节

public void write(byte[ ] b)   //写一个字节数组

public void wirte(byte[ ] b,int off , int len)   //写一个字节数组的一部分

字节流输出流操作步骤：

A : 创建字节输出流对象

B: 写数据

C: 释放资源

范例：

package cn.itcast_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：往一个文本文件中输入一句话"hello,io"
 * 分析：
 * 要往文件中写一句话，所以采用字节输出流
 */
public class IODemo {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		//FileOutputStream(String name)
		FileOutputStream fos = new FileOutputStream("fos.txt");
		
		//调方法写数据
		//先把字符串hello,io转字节数组
		String s = "hello,io";
		byte[] chs = s.getBytes();
		fos.write(chs);
		
		//释放资源（关闭输出流，释放系统资源）不关闭就可以一直使用
		fos.close();
		
	}
}

字节输出流实现数据换行

             加入换行符\r\n

字节输出流实现数据的追加写入 

            用构造方法带第二个参数true，即可

FileOutputStream fos = new FileOutputStream("fos2.txt",true);  //加入true参数，追加写入

FileOutputStream写数据加入异常处理：

范例：

package cn.itcast_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 加入异常处理的字节输出流操作
 * 
 */
public class FileOutputStreamDemo_02 {
	public static void main(String[] args) {
		//分开做异常处理
		//创建字节流对象
		FileOutputStream fos =null;   //注意这个null
		try {
			fos = new FileOutputStream("fos3.txt");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		
		//写入数据
		try {
			fos.write("java".getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		try {
			fos.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
}

FileInputStream 字节流
字节输入流操作步骤：

A / 创建字节流输入流对象

B/ 调用read()方法读取数据，并把数据显示在控制台

C / 释放资源

构造函数

FileInputStream(String name)

读取数据的方式：

A / int read()   // 一次读取一个字节

B / int read(byte[ ] b)   // 一次读取一个字节数组

范例：

package cn.itcast_02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * 字节输入流操作步骤：
A / 创建字节流输入流对象
B/ 调用read()方法读取数据，并把数据显示在控制台
C / 释放资源

读取数据的方式：
A / int read()
B / int read(byte[ ] b)
 */
public class InputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节流输入流对象
		FileInputStream fis = new FileInputStream("fis.txt");
		
/*		//调用read()方法读取数据，并把数据显示在控制台
		//第一次读取
		int by = fis.read();
		System.out.println((char)by);
		//第二次读取
		int by2 = fis.read();
		System.out.println((char)by2);
		//第三次读取
		int by3 = fis.read();
		System.out.println((char)by3);
		
		System.out.println("---------------------");
		*/
/*		//用循环改进，如何控制循环条件？
		int by = fis.read();
		while(by != -1){
			System.out.print((char) by);
			by = fis.read();
		}
		*/
		//标准版代码
		int by = 0;
		//读取，赋值，判断
		while ((by = fis.read()) != -1 ){
			System.out.print((char) by);
		}
		//释放资源
		fis.close();
	}
}

字节流复制文件：

单字节复制：

package cn.itcast_03;

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

/*
 * CopyFile
 * 从哪里来，到哪里去
 * 范例：
 * 从a.txt ------读取数据------FileInputStream
 * 到 b.txt------写数据------FileOutputStream
 * 
 */
public class CopyFileDemo {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("f:\\a.txt");
		
		//封装目的地
		FileOutputStream fos = new FileOutputStream("g:\\b.txt");
		
		//循环读取数据
		int by = 0;
		while ((by=fis.read())!= -1){
			fos.write(by);
		}
		
		//释放资源
		fos.close();
		fis.close();
	}
}

字节数组复制：

package cn.itcast_03;

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

/*
 * 需求：把f:\\a.txt 内容复制到g:\\b.txt中
 * 
 * 数据源：f:\\a.txt ----读取数据-----FileInputStream
 * 目的地：g:\\b.txt----写入数据------FileOutputStream
 */
public class CopyFileDemo_02 {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("f:\\a.txt");
		FileOutputStream fos = new FileOutputStream("g:\\b.txt");
		
		//复制数据
		byte[] bys =new byte[1024];
		int len = 0;
		while((len = fis.read(bys))!=-1){
			fos.write(bys, 0, len);
		}
		
		//释放资源
		fos.close();
		fis.close();
	}
}

字节流复制图片：

package cn.itcast_03;

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

/*
 * CopyFile复制图片
 * 数据源：F:\\马士兵.jpg------读取-----FileInputStream
 * 数据源：g:\\msb.jpg-----写出-----FileOutputStream
 */
public class CopyFileDemo_03 {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("F:\\马士兵JAVA.jpg");
		FileOutputStream fos = new FileOutputStream("g:\\msb.jpg");
		
		//复制数据
		byte[] bys = new byte[1024];
		int len = 0;
		while((len = fis.read(bys))!=-1){
			fos.write(bys, 0, len);
		}
		
		//释放资源
		fos.close();
		fis.close();
	}
}

___________________________________

字节缓冲区流

BufferedOutputStream  字节缓冲输出流

构造方法：

BufferedOutputStream(OutputStream out)
不传递一个具体的文件或者文件路径，传递的是一个OutputStream抽象类对象。

字节缓冲区流仅仅提供缓冲区，真正的读写操作还得靠基本的流对象实现。

范例：

package cn.itcast_04;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * BufferedOutputStream
 * 
 */
public class BufferedOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		//BufferedOutputStream(OutputStream out)  构造方法，传递的是抽象类
/*		FileOutputStream fos = new FileOutputStream("bos.txt");
		BufferedOutputStream bos = new BufferedOutputStream(fos);*/
		//简单写法：
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("bos.txt"));
		
		//写数据
		bos.write("hello".getBytes());
		
		//释放资源
		bos.close();
		
	}
}

BufferedInputStream   字节缓冲输入流

构造方法：

BufferedInputStream(InputStream in)

不传递一个具体的文件或者文件路径，传递的是一个InputStream抽象类对象。

字节缓冲区流仅仅提供缓冲区，真正的读写操作还得靠基本的流对象实现。

范例：

package cn.itcast_04;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * BufferedInputStream
 */
public class BufferedInputStreamDemo {
	public static void main(String[] args) throws IOException {
		//BufferedInputStream(InputStream in)
		BufferedInputStream bis = new BufferedInputStream(
				new FileInputStream("bos.txt"));
		
		//读取数据
		byte[] bys = new byte[1024];
		int len = 0;
		while((len = bis.read(bys))!= -1){
			
			System.out.print(new String(bys,0,len));
		}

		
		//释放资源
		bis.close();
		
	}
}