字节流,高效流

* OutputStream: 所有字节输出流的抽象父类,在java.io包下面,里面常用的子类是:FileOutputStream;
* 使用步骤:
* 1. 导入包: import java.io.FileOutputStream;
* 2. 创建对象,构造方法
* public FileOutputStream(File pathName);
* public FileOutputStream(String pathName);
*
* 3. 成员方法
* public void write(int b); 写入单个字节到文件中
* public void write(byte[]buf); 写一个字节数组到文件中
* public void write(byte[]buf, int offset, int len); 写字节数组的一部分到文件中
* public void flush();
* public void close();
*
* 注意点:
* 1. 在使用字节流向文件中写数据的时候,写入的97是一个字节,但是文件会自动进行翻译所以看到的是a
* 2. 一个字符在java的内存中占用的是两个字节,但是在文件中占用几个字节取决于操作系统

FileOutputStream中常用的成员方法:
* public void write(int b); 写入单个字节到文件中
* public void write(byte[]buf); 写一个字节数组到文件中
* public void write(byte[]buf, int offset, int len); 写字节数组的一部分到文件中
* public void flush();
* public void close();
*
*
* 注意点:
* 1. 使用字节流写文件的时候,没有缓冲区,所以不需要刷新
* 2. 任何流,使用完成之后都应当将资源释放掉(close)

* 如何需要将一个字符串输出到文件中该怎么办?
* 答: 需要将字符串转成字节数组
*
* 1. 字符串转成字节数组,使用String类的 getBytes方法
* public byte[] getBytes();
*
* 2. 字节数组转成字符串,使用字符串的构造方法
* public String(byte[]buf);
* public String(byte[]buf, int offset, int len);


* 在使用字节流向文件中输出内容的时候如何进行换行?
* 平台(操作系统) 换行符
* windows \r\n
* MacOS \r
* Linux \n
* 注意点: 一般写在第一行数据的结尾,第二行数据的开头
*
* 在使用字节流向文件中输出内容的时候,如何进行续写(追加写)?
* 需要使用另外一个构造方法:
* public FileOutputStream(File pathName, boolean append);
* public FileOutputStream(String pathName, boolean append);
* pathName:表示数据要输出的目的地
* append: 如果为true可以追加写, 如果为false不能追加(覆盖之前的内容)


*********** InputStream: 是所有字节输入流的抽象父类,在java.io包下面, 需要使用子类FileInputStream;
* 使用步骤:
* 1. 导入包, import java.io.FileInputStream;
* 2. 创建对象,使用构造方法
* public FileInputStream(String pathName);
* public FileInputStream(File pathName);
* 3. 使用成员方法
* public int read(); 读取单个字节
* public int read(byte[]buf); 将读取到的内容存储到buf数组中, 返回实际读取到的长度(个数)



* public int read(byte[]buf); 将读取到的内容存储到buf数组中, 返回实际读取到的长度(个数)
*
* 字节流是专门用来做文件的拷贝操作的, 不是读取来给程序员看的.




* BufferedOutputStream: 缓冲输出流对象,也是OutputStream的子类, 在java.io包中,默认缓冲区大小是8k
* 使用步骤:
* 1. 导入包, import java.io.BufferedOutputStream;
* 2. 创建对象, 使用构造方法
* public BufferedOutputStream(OutputStream out);
* out:需要传入一个字节流对象, 所以可以传入FileOutputStream;
*
* 3. 成员方法;
* 和FileOutputStream完全一样. write(单个字节/ 字节数组/ 字节数组一部分)


* BufferedInputStream: 缓冲字节输入流对象, 也是InputStream的子类,在java.io包下面,默认缓冲区8k
* 使用步骤:
* 1. 导入包, import java.io.BufferedInputStream;
* 2. 创建对象, 构造方法
* public BufferedInputStream(InputStream in);
* in: 需要InputStream类型的参数, 可以传入FileInputStream对象;
* 3. 使用成员方法
* 和FileInputStream完全一样
* public int read() 读取单个字节
* public int read(byte[]buf); 将读取的内容存储到buf中, 返回实际读取到的个数

package cn.itcast.demo01;

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

/*
* 四种拷贝文件的方式选择:
* 1. 普通流,一次读取单个字节方式拷贝
* 2. 普通流,一次读取字节数组方式拷贝
* 3. 缓冲流,一次读取单个字节方式拷贝
* 4. 缓冲流,一次读取字节数组方式拷贝
* 
* 选择顺序: 4 > 2 > 3 > 1
* 
*/
public class Demo10CopyStyleFour{

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

long startTime = System.currentTimeMillis();

// 1. 普通流,一次读取单个字节方式拷贝
//method1();// 用时45945毫秒

//2. 普通流,一次读取字节数组方式拷贝
//method2();//用时83毫秒

//3. 缓冲流,一次读取单个字节方式拷贝
//method3();//用时572毫秒

//4. 缓冲流,一次读取字节数组方式拷贝
//method4();//用时39毫秒

long endTime = System.currentTimeMillis();

System.out.println("用时"+(endTime - startTime)+"毫秒");
}

// 1. 普通流,一次读取单个字节方式拷贝
public static void method1() throws IOException{
//1.创建对象, 绑定源文件
FileInputStream fis = new FileInputStream("水浒传.txt");

// 创建对象,绑定目的地
FileOutputStream fos = new FileOutputStream("水浒传1.txt");

//2.循环读取
int b;
while((b = fis.read()) != -1){
fos.write(b);
}

//3.关闭流
fos.close();
fis.close();
}

// 2. 普通流,一次读取字节数组方式拷贝
public static void method2() throws IOException {
// 1.创建对象, 绑定源文件
FileInputStream fis = new FileInputStream("水浒传.txt");

// 创建对象,绑定目的地
FileOutputStream fos = new FileOutputStream("水浒传2.txt");

// 2.循环读取
byte[]buf = new byte[1024];
int len;
while ((len = fis.read(buf)) != -1) {
fos.write(buf,0,len);
}

// 3.关闭流
fos.close();
fis.close();
}

// 3. 缓冲流,一次读取单个字节方式拷贝
public static void method3() throws IOException{
//1.创建对象, 绑定源文件
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("水浒传.txt"));

// 创建对象,绑定目的地
BufferedOutputStream fos =new BufferedOutputStream( new FileOutputStream("水浒传3.txt"));

//2.循环读取
int b;
while((b = fis.read()) != -1){
fos.write(b);
}

//3.关闭流
fos.close();
fis.close();
}

//4. 缓冲流,一次读取字节数组方式拷贝
public static void method4() throws IOException{
//1.创建对象, 绑定源文件
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("水浒传.txt"));

// 创建对象,绑定目的地
BufferedOutputStream fos =new BufferedOutputStream( new FileOutputStream("水浒传4.txt"));

//2.循环读取
byte[]buf = new byte[1024];
int len;
while((len = fis.read(buf)) != -1){
fos.write(buf,0,len);
}

//3.关闭流
fos.close();
fis.close();
}
}

 

* 异常和IO流的典型用法
* try{
* 创建IO流
* 拷贝操作
* }catch(异常类名 变量名){
* 打印提示信息
* }finally{
* 释放资源,关闭流
* }

package cn.itcast.demo01;

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

public class Demo12ExceptionIO {

public static void main(String[] args) {

FileInputStream fis = null;
FileOutputStream fos = null;

try {
fis = new FileInputStream("test11111.txt");
fos = new FileOutputStream("test1copy.txt");

int b;
while ((b = fis.read()) != -1) {
fos.write(b);
}

} catch (IOException e) {
System.out.println("IO流操作异常了....正在拼命处理...");
} finally {
/*
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}

if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
*/

// 简化
closeIO(fis,fos);
}
}

public static void closeIO(Closeable... io){
for (Closeable cs : io) {

if(cs != null){
try {
cs.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}

}