百木园IO流的分类：
* 流向：
* 输入流 读取数据
* 输出流 写出数据
* 数据类型：
* 字节流
* 字节输入流 读取数据 InputStream
* 字节输出流 写出数据 OutputStream
* 字符流
* 字符输入流 读取数据 Reader
* 字符输出流 写出数据 Writer
*
* 注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
package cn.itcast_01; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /* * IO流的分类： * 流向： * 输入流 读取数据 * 输出流 写出数据 * 数据类型： * 字节流 * 字节输入流 读取数据 InputStream * 字节输出流 写出数据 OutputStream * 字符流 * 字符输入流 读取数据 Reader * 字符输出流 写出数据 Writer * * 注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。 * * 需求：我要往一个文本文件中输入一句话：\"hello,io\" * * 分析： * A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。 * B:由于我是要往文件中写一句话，所以我们要采用字节输出流。 * * 通过上面的分析后我们知道要使用：OutputStream * 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。 * 所以，我们要找一个具体的子类。 * 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。 * 文件是哪个单词：File * 然后用的是字节输出流，联起来就是：FileOutputStream * 注意：每种基类的子类都是以父类名作为后缀名。 * XxxOutputStream * XxxInputStream * XxxReader * XxxWriter * 查看FileOutputStream的构造方法： * FileOutputStream(File file) * FileOutputStream(String name) * * 字节输出流操作步骤： * A:创建字节输出流对象 * B:写数据 * C:释放资源 */ public class FileOutputStreamDemo { public static void main(String[] args) throws IOException { // 创建字节输出流对象---并直接给出创建的文件姓名 // FileOutputStream(File file) // File file = new File(\"fos.txt\"); // FileOutputStream fos = new FileOutputStream(file); // FileOutputStream(String name) FileOutputStream fos = new FileOutputStream(\"fos.txt\"); /* * 创建字节输出流对象了做了几件事情： * A:调用系统功能去创建文件 * B:创建fos对象 * C:把fos对象指向这个文件 */ //写数据 //public void write(byte[] b) //throws IOException将 b.length 个字节从指定 byte 数组写入此文件输出流中。 //public byte[] getBytes()使用平台的默认字符集将此 String 编码为 byte 序列， // 并将结果存储到一个新的 byte 数组中 fos.write(\"hello,IO\".getBytes()); fos.write(\"java\".getBytes()); //释放资源 //关闭此文件输出流并释放与此流有关的所有系统资源。 fos.close(); /* * 为什么一定要close()呢? * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了 * B:通知系统去释放跟该文件相关的资源 */ //java.io.IOException: Stream Closed //fos.write(\"java\".getBytes()); } }
/*
* 字节输出流操作步骤：
* A:创建字节输出流对象
* B:调用write()方法
* C:释放资源
*
* public void write(int b):写一个字节
* public void write(byte[] b):写一个字节数组
* public void write(byte[] b,int off,int len):写一个字节数组的一部分
*/
1 package cn.itcast_01; 2 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 6 /* 7 * 字节输出流操作步骤： 8 * A:创建字节输出流对象 9 * B:调用write()方法 10 * C:释放资源 11 * 12 * public void write(int b):写一个字节 13 * public void write(byte[] b):写一个字节数组 14 * public void write(byte[] b,int off,int len):写一个字节数组的一部分 15 */ 16 public class FileOutputStreamDemo2 { 17 public static void main(String[] args) throws IOException { 18 // 创建字节输出流对象 19 // OutputStream os = new FileOutputStream(\"fos2.txt\"); // 多态 20 FileOutputStream fos = new FileOutputStream(\"fos2.txt\"); 21 22 // 调用write()方法 23 //fos.write(97); //97 -- 底层二进制数据 -- 通过记事本打开 -- 找97对应的字符值 -- a 24 // fos.write(57); 25 // fos.write(55); 26 27 //public void write(byte[] b):写一个字节数组 28 byte[] bys={97,98,99,100,101}; 29 fos.write(bys); 30 31 //public void write(byte[] b,int off,int len):写一个字节数组的一部分 32 fos.write(bys,1,3); 33 34 //释放资源 35 fos.close(); 36 } 37 }
FileOutPutStream写出数据实现换行和数据追加写入
package cn.itcast_01; import java.io.FileOutputStream; import java.io.IOException; /* * 如何实现数据的换行? * 为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。 * 如何实现呢?写入换行符号即可呗。 * 刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢? * 因为不同的系统针对不同的换行符号识别是不一样的? * windows:\\r\\n * linux:\\n * Mac:\\r * 而一些常见的个高级记事本，是可以识别任意换行符号的。 * * 如何实现数据的追加写入? * 用构造方法带第二个参数是true的情况即可 */ public class FileOutputStreamDemo3 { public static void main(String[] args) throws IOException { // 创建字节输出流对象 // FileOutputStream fos = new FileOutputStream(\"fos3.txt\"); // 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。 FileOutputStream fos = new FileOutputStream(\"fos3.txt\", true); // 写数据 for (int x = 0; x < 10; x++) { fos.write((\"hello\" + x).getBytes()); fos.write(\"\\r\\n\".getBytes()); } // 释放资源 fos.close(); } }
FileOutputStream---加入异常处理的字节输出流操作
package cn.itcast_01; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /* * 加入异常处理的字节输出流操作 */ public class FileOutputStreamDemo4 { public static void main(String[] args) { // 分开做异常处理 // FileOutputStream fos = null; // try { // fos = new FileOutputStream(\"fos4.txt\"); // } catch (FileNotFoundException e) { // e.printStackTrace(); // } // // try { // fos.write(\"java\".getBytes()); // } catch (IOException e) { // e.printStackTrace(); // } // // try { // fos.close(); // } catch (IOException e) { // e.printStackTrace(); // } // 一起做异常处理 // try { // FileOutputStream fos = new FileOutputStream(\"fos4.txt\"); // fos.write(\"java\".getBytes()); // fos.close(); // } catch (FileNotFoundException e) { // e.printStackTrace(); // } catch (IOException e) { // e.printStackTrace(); // } // 改进版 // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值 FileOutputStream fos = null; try { // fos = new FileOutputStream(\"z:\\\\fos4.txt\"); fos = new FileOutputStream(\"fos4.txt\"); fos.write(\"java\".getBytes()); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { // 如果fos不是null，才需要close() if (fos != null) { // 为了保证close()一定会执行，就放到这里了 try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } } }
FileOutputStream----读取文件数据
package cn.itcast_02; import java.io.FileInputStream; import java.io.IOException; /* * 字节输入流操作步骤： * A:创建字节输入流对象 * B:调用read()方法读取数据，并把数据显示在控制台 * C:释放资源 * * 读取数据的方式： * A:int read():一次读取一个字节 * B:int read(byte[] b):一次读取一个字节数组 */ public class FileInputStreamDemo { public static void main(String[] args) throws IOException { // FileInputStream(String name) // FileInputStream fis = new FileInputStream(\"fis.txt\"); FileInputStream fis = new FileInputStream(\"FileOutputStreamDemo.java\"); // // 调用read()方法读取数据，并把数据显示在控制台 // // 第一次读取 // int by = fis.read(); // System.out.println(by); // System.out.println((char) by); // // // 第二次读取 // by = fis.read(); // System.out.println(by); // System.out.println((char) by); // // // 第三次读取 // by = fis.read(); // System.out.println(by); // System.out.println((char) by); // // 我们发现代码的重复度很高，所以我们要用循环改进 // // 而用循环，最麻烦的事情是如何控制循环判断条件呢? // // 第四次读取 // by = fis.read(); // System.out.println(by); // // 第五次读取 // by = fis.read(); // System.out.println(by); // //通过测试，我们知道如果你读取的数据是-1，就说明已经读取到文件的末尾了 // 用循环改进 // 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(); } }
IO（字节流复制文本文件案例）
package Day20; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; /* * IO流复制文本文件 * /* * 复制文本文件。 * * 数据源：从哪里来 * a.txt -- 读取数据 -- FileInputStream * * 目的地：到哪里去 * b.txt -- 写数据 -- FileOutputStream * * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。) * * 这一次复制中文没有出现任何问题，为什么呢? * 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。 * 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。 * 它会自己做转换。 */ public class IO4 { public static void main(String[] args) throws IOException { //创建字节输入对象---用来读取文件数据--- //此时创建对象的同时，系统不会自动创建该文件---只能自己给出 FileInputStream file = new FileInputStream(\"zhao.txt\"); //创建字节输出流对象---用来接受读取的数据将其写入 //创建输出流对象的同时---也会自动创建其文件 FileOutputStream file1 = new FileOutputStream(\"zhu.txt\"); //将读出的数据进行写入 //首先进行读取数据 int bys = 0; while((bys=file.read())!=-1){ //进行写入的数据---写入的数据是读取的字节数据 file1.write(bys); } //释放资源 file1.close();//===输出流 file.close();//-===输入流 } }
计算机是如何识别两个字节拼接成中文的
package cn.itcast_03; import java.util.Arrays; /* * 计算机是如何识别什么时候该把两个字节转换为一个中文呢? * 在计算机中中文的存储分两个字节： * 第一个字节肯定是负数。 * 第二个字节常见的是负数，可能有正数。但是没影响。 */ public class StringDemo { public static void main(String[] args) { // String s = \"abcde\"; // // [97, 98, 99, 100, 101] String s = \"我爱你中国\"; // [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6] byte[] bys = s.getBytes(); System.out.println(Arrays.toString(bys)); } }
字节流复制文本文件（案例2）
package Day20; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; // 需求：把c盘下的a.txt的内容复制到d盘下的b.txt中 public class IO5 { public static void main(String[] args) throws IOException { //首先创建字节输入流对象==给出要读出的文件==具体的文件路径 FileInputStream file = new FileInputStream(\"C:\\\\hhh\\\\a.txt\"); //创建字节输出流对象====给出要写入的具体文件路径-----此对象也同时可以创建一个文件 FileOutputStream file1 = new FileOutputStream(\"D:\\\\YY\\\\b.txt\"); //将读出的数据进行写入 //首先进行读取数据 //public int read()throws IOException从此输入流中读取一个数据字节---返回值为-1时，则数据读取完毕 int bys = 0; while((bys = file.read())!=-1){ //进行数据的写入 file1.write(bys); } //释放资源 file1.close(); file1.close(); } }
字节流复制图片案例
package Day20; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; //需求：把D:\\\\屏幕截图(1).png内容复制到当前项目目录下的mn.png中 public class IO6 { public static void main(String[] args) throws IOException { //创建字节输入流对象----给出绝对路径 FileInputStream file = new FileInputStream(\"D:\\\\屏幕截图(1).png\"); //创建字节流输出对象--创建对象的同时也创建其未创建的文件 FileOutputStream file1 = new FileOutputStream(\"mn.png\"); //读写数据 int bys =0; while((bys=file.read())!=-1){ //进行读数据的写入 file1.write(bys); } //释放资源 file.close(); file1.close(); } }
字节流复制视频
package cn.itcast_03; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; /* * 需求：把e:\\\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中 * * 数据源： * e:\\\\哥有老婆.mp4--读取数据--FileInputStream * 目的地： * copy.mp4--写出数据--FileOutputStream */ public class CopyMp4Demo { public static void main(String[] args) throws IOException { // 封装数据源 FileInputStream fis = new FileInputStream(\"e:\\\\哥有老婆.mp4\"); // 封装目的地 FileOutputStream fos = new FileOutputStream(\"copy.mp4\"); // 复制数据 int by = 0; while ((by = fis.read()) != -1) { fos.write(by); } // 释放资源 fos.close(); fis.close(); } }
FileInputSteram读取数据一次一个字节数组
package Day20; import java.io.FileInputStream; import java.io.IOException; //FileInputStream一次读取一个字节数组 public class IO7 { public static void main(String[] args) throws IOException { //定义一个字节输入流对象---给出读取文件的具体路径 FileInputStream file = new FileInputStream(\"zhao.txt\"); //一次读取一个字节数组 byte [] bys = new byte[1024]; int len= 0; //读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。 while((len=file.read(bys))!=-1){ //读取时已经给出换行符则不需要给出--------调用构造方式此处使用匿名对象 //public String(byte[] bytes,int offset,int length)通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String //bytes - 要解码为字符的 byt ------offset - 要解码的第一个 byte 的索引-------length - 要解码的 byte 数 System.out.print(new String(bys,0,len)); } //释放资源 file.close(); } }
FileInputSteram读取数据一次一个字节数组（复制文本文件）
1 package Day20; 2 3 import java.io.FileInputStream; 4 import java.io.FileOutputStream; 5 import java.io.IOException; 6 7 //需求：把c:\\\\a.txt内容复制到d:\\\\b.txt中 8 //采用一次复制一个字节数组的方式 9 public class IO8 { 10 public static void main(String[] args) throws IOException { 11 //首先定义一个字节输入流对象----数据源 12 FileInputStream file = new FileInputStream(\"C:\\\\hhhh\\\\a.txt\"); 13 14 //定义一个字节输出流对象----目标源 15 FileOutputStream file1 = new FileOutputStream(\"D:\\\\YY\\\\b.txt\"); 16 17 18 //定义一个字节数组 19 byte [] bys = new byte[1024]; 20 //初始化文件写入位置为0 21 int len=0; 22 //public int read(byte[] b)throws IOException 23 //从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中 24 //读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。 25 while((len=file.read(bys))!=-1){ 26 //public void write(byte[] b,int off,int len) 27 //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流 28 file1.write(bys,0,len); 29 } 30 31 //释放内存 32 file1.close(); 33 file.close(); 34 35 } 36 }
BufferedOutputStream---* 写数据：BufferedOutputStream
通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
* 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
* 这种类被称为：缓冲区类(高效类)
* 写数据：BufferedOutputStream
* 读数据：BufferedInputStream
*
* 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
*
* 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
* 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
package cn.itcast_05; import java.io.BufferedOutputStream; import java.io.FileOutputStream; import java.io.IOException; /* * 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。 * 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。 * 这种类被称为：缓冲区类(高效类) * 写数据：BufferedOutputStream * 读数据：BufferedInputStream * * 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。 * * 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢? * 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。 */ 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(); } }
自写版
package Day20; import java.io.BufferedOutputStream; import java.io.FileOutputStream; import java.io.IOException; /* * BufferOutputStream---* 写数据：BufferedOutputStream * * * */ public class IO9 { public static void main(String[] args) throws IOException { BufferedOutputStream file = new BufferedOutputStream(new FileOutputStream(\"qing.txt\")); //写入数据---将写入的字符串---转化为字节 file.write(\"hello\\n\".getBytes()); file.write(\"hasdiasjbcdajscnasc\".getBytes()); //释放资源 file.close(); } }
BufferedInputStream----读数据：BufferedInputStream
package cn.itcast_05; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.IOException; /* * 注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。 */ public class BufferedInputStreamDemo { public static void main(String[] args) throws IOException { // BufferedInputStream(InputStream in) BufferedInputStream bis = new BufferedInputStream(new FileInputStream( \"bos.txt\")); // 读取数据 // int by = 0; // while ((by = bis.read()) != -1) { // System.out.print((char) by); // } // System.out.println(\"---------\"); byte[] bys = new byte[1024]; int len = 0; while ((len = bis.read(bys)) != -1) { System.out.print(new String(bys, 0, len)); } // 释放资源 bis.close(); } }
自写版
package Day20; import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.IOException; //BufferInputStream----读数据：BufferedInputStream public class IO10 { public static void main(String[] args) throws IOException { //创建字节缓冲区类 BufferedInputStream file = new BufferedInputStream(new FileInputStream(\"qing.txt\")); // // //进行读数据 // //方式一---一次读取一个字节 // int by =0; // while((by=file.read())!=-1){ // //将读取的字节--转换为字符类型进行输出 // System.out.println((char)by); // } // // //释放资源 // file.close(); //进行读数据 //方式二---一次读取一个字节数组 byte [] bys = new byte[1024]; int len =0; while((len=file.read(bys))!=-1){ //public String(byte[] bytes,int offset,int length)通过使用平台的默认字符集解码指定的 byte 子数组， // 构造一个新的 String System.out.println(new String(bys,0,len)); } //释放资源 file.close(); } }
字节流四种方式复制速度对比
package cn.itcast_06; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; /* * 需求：把e:\\\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中 * * 字节流四种方式复制文件： * 基本字节流一次读写一个字节： 共耗时：117235毫秒 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒 * 高效字节流一次读写一个字节： 共耗时：1141毫秒 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒 */ public class CopyMp4Demo { public static void main(String[] args) throws IOException { long start = System.currentTimeMillis(); // method1(\"e:\\\\哥有老婆.mp4\", \"copy1.mp4\"); // method2(\"e:\\\\哥有老婆.mp4\", \"copy2.mp4\"); // method3(\"e:\\\\哥有老婆.mp4\", \"copy3.mp4\"); method4(\"e:\\\\哥有老婆.mp4\", \"copy4.mp4\"); long end = System.currentTimeMillis(); System.out.println(\"共耗时：\" + (end - start) + \"毫秒\"); } // 高效字节流一次读写一个字节数组： public static void method4(String srcString, String destString) throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream( srcString)); BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(destString)); byte[] bys = new byte[1024]; int len = 0; while ((len = bis.read(bys)) != -1) { bos.write(bys, 0, len); } bos.close(); bis.close(); } // 高效字节流一次读写一个字节： public static void method3(String srcString, String destString) throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream( srcString)); BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream(destString)); int by = 0; while ((by = bis.read()) != -1) { bos.write(by); } bos.close(); bis.close(); } // 基本字节流一次读写一个字节数组 public static void method2(String srcString, String destString) throws IOException { FileInputStream fis = new FileInputStream(srcString); FileOutputStream fos = new FileOutputStream(destString); byte[] bys = new byte[1024]; int len = 0; while ((len = fis.read(bys)) != -1) { fos.write(bys, 0, len); } fos.close(); fis.close(); } // 基本字节流一次读写一个字节 public static void method1(String srcString, String destString) throws IOException { FileInputStream fis = new FileInputStream(srcString); FileOutputStream fos = new FileOutputStream(destString); int by = 0; while ((by = fis.read()) != -1) { fos.write(by); } fos.close(); fis.close(); } }
来源：https://www.cnblogs.com/ztg-java-xuexi/p/16079831.html
本站部分图文来源于网络，如有侵权请联系删除。