* 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(); } } } } }