IO流的概念及使用方法二

package java学习;/** *  * @author zhaocx1 *  *//* * 缓冲区的出现是为了提高流的操作效率而出现的。 * 所以在创建缓冲区之前，就必须要先有流对象。 * 该缓冲区中提供了一个跨平台的换行符。 * newLine(); */import java.io.BufferedWriter;//导入IO流包中的类包import java.io.FileWriter;import java.io.IOException;public class BufferedDemo {public static void main(String[] args) throws IOException {//函数上抛出异常// 创建一个流对象。FileWriter fw = new FileWriter("buf.txt");// 为了提高字符写入流率，加入了缓冲技术。只要将被提高效率的流对象作为参数传递给缓冲区的构造函数即可。BufferedWriter bufw = new BufferedWriter(fw);for (int x = 1; x < 5; x++) {bufw.write("abcdefg" + x);//对读取的数据进行换行bufw.newLine();//刷新流资源bufw.flush();}// bufw.write("abc\r\ndefg");// 记住,只要用到缓冲区，就要记得刷新。// bufw.flush();// 其实关闭缓冲区就是在关闭关闭缓冲区中的流对象。bufw.close();}}

package java学习;/** *  * @author zhaocx1 *  *//* * readLine方法的原理： * 无论是读一行，获取多个字符，其实最终都是在硬盘上一个一个读取，所以最宠使用的还是read方法一次读一个的方法。 */public class readLineDemo {public static void main(String[] args){System.out.println("hello");}}

package java学习;/** *  * @author zhaocx1 *  *//* * 通过缓冲区复制一个.java文件。 * ReadLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。 */import java.io.BufferedReader;//导入IO流包中的类包import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class BufferedCopyFileDemo {public static void main(String[] args) {BufferedReader bufr = null;// 定义一个缓冲区读取流，初始化值空BufferedWriter bufw = null;// 定义一个缓冲区写入流，初始化值为空try {// 对IO流中的方法操作进行异常处理//通过缓冲区读取一个文件bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));//通过缓冲区写入一个文件bufw = new BufferedWriter(new FileWriter("bufWriter.txt"));//定义一个字符串初始化值为空，作用是存储读到的数据String line = null;//对缓冲区中的数据进行读取while ((line = bufr.readLine()) != null) {//将读取的数据写入文件中bufw.write(line);//对写入的数据进行换行bufw.newLine();//刷新流资源bufw.flush();}} catch (IOException e) {throw new RuntimeException("读写失败");} finally {//后面是一定要执行的语句，可以用来关闭流资源try {if (bufr != null)bufr.close();//关闭流资源} catch (IOException e) {throw new RuntimeException("读取关闭失败");}try {if (bufw != null)bufw.close();} catch (IOException e) {throw new RuntimeException("写入关闭失败");}}}}

package java学习;/** *  * @author zhaocx1 *  *//* * 装饰设计模式： * 当想要对已有的对象进行功能增强时，可以定义一个类，将已有对象传入， * 基于已有的功能，并提供加强功能。 * 那么，自定义的该类成为装饰类。 *  * 装饰类通常会通过构造方法接受被装饰的对象。 * 并基于被装饰的对象的功能，提供更强的功能。 */class Person {//定义一个对象public void chifan() {//定义对象的方法System.out.println("吃饭");}}class SuperPerson {//定义一个类private Person p;//私有化已有的对象SuperPerson(Person p) {//对本类对象进行构造函数，将已有的对象作为参数传递到现有对象this.p = p;}public void superChifan() {//定义本类方法System.out.println("开胃酒");//输出打印内容p.chifan();//调用被装饰对象中的方法System.out.println("甜点");System.out.println("水果");}}public class ZhuangShiSheJiDemo {public static void main(String[] args) {Person p = new Person();//new一个对象，对对象进行实例化p.chifan();SuperPerson sp = new SuperPerson(p);//new一个对象，对对象进行实例化，并将已有对象传入sp.superChifan();}}

package javaStudy;/** *  * @author zhaocx1 *  *//* * MyReader//专门用于读取数据的类。 *       1--MyTextReader *          --MyBufferTextReader *       1--MyMediaReader *          --MyBufferMediaReader *       1--MyDataReader *          --MyBufferDataReader *  * class MyBufferReader  * { *      MyBufferReader(MyBufferdTextReader text){} *      MyBufferReader(MyBufferdMediaReader media){} * } * 上面这个类扩展性很差， * 找到其参数的共同类型，通过多态的形式，可以提高扩展性。 * class MyBufferReader extends MyReader * { *     private MyReader r; *     MyBufferReader(MyReader r){} * } *  * MyReader//专门用于读取数据的类。 *       1--MyTextReader *       1--MyMediaReader *       1--MyDataReader *       1--MyBufferDataReader *  * 装饰模式比继承要灵活，避免了继承体系臃肿。 * 而且降低了类与类之间的关系。 *  * 装饰类因为是增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能， * 所有装饰类和被装饰类通常都属于一个体系中的。 */public class ZhuangShiAndExtend {public static void main(String[] args){System.out.println("hello world");}}

package javaStudy;/** *  * @author zhaocx1 *  */import java.io.FileReader;//导入IO流包中的类包import java.io.IOException;import java.io.LineNumberReader;public class LineNumberReader1 {public static void main(String[] args) throws IOException {//函数上抛出异常，函数内可以不用进行处理//定义一个文件读取流读取一个文件FileReader fr = new FileReader("PersonDemo.java");        //将文件读取流作为参数传递到LineNumberReader对象中LineNumberReader lnr = new LineNumberReader(fr);String line = null;//设置从某一行开始读取数据lnr.setLineNumber(100);//讲读取到的数据放到字符串中while ((line = lnr.readLine()) != null) {//输出打印内容System.out.println(lnr.getLineNumber() + ":" + line);}lnr.close();//关闭流资源}}

package javaStudy;/** *  * @author zhaocx1 *  *//* * 字符流： * FileReader * FileWriter  *  * BufferedReader * BufferedWriter *  * 字节流：操作图片 * InputStream(读）  OutputStream(写，输出都是写) *  * 需求：想要操作图片数据，这时就要用到字节流。 */import java.io.FileInputStream;//导入IO流包中的类包import java.io.FileOutputStream;import java.io.IOException;public class InputStreamFileDemo {public static void main(String[] args) throws IOException {//主函数抛出异常readFile3();//调用静态方法}public static void readFile3() throws IOException {//定义一个静态方法抛出异常//定义字节流文件读取一个文件FileInputStream fis = new FileInputStream("for.txt");// int num=fis.available();byte[] buf = new byte[fis.available()];// 定义一个刚刚好的缓冲区，不用再循环了。        //将文件的数组读到数组中fis.read(buf);// System.out.println("num=="+num);System.out.println(new String(buf));//输出打印独到的数组，以字符串形式fis.close();//关闭流资源}public static void readFile2() throws IOException {//定义一个静态方法抛出异常//定义字节流文件读取一个文件FileInputStream fis = new FileInputStream("for.txt");//定义一个byte类型的数组，用于存储独到的数组byte[] buf = new byte[1024];int len = 0;while ((len = fis.read(buf)) != -1) {//输出打印文件中的内容System.out.println(new String(buf, 0, len));}fis.close();//关闭流资源}public static void readFile1() throws IOException {//定义一个静态方法抛出异常//定义字节流文件读取一个文件FileInputStream fis = new FileInputStream("for.txt");        //对文件中的数据进行读取int ch = 0;while ((ch = fis.read()) != -1) {System.out.println((char) ch);}fis.close();//关闭流资源}public static void writeFile() throws IOException {//定义一个静态方法抛出异常//定义字节流文件写入FileOutputStream fos = new FileOutputStream("for.txt");fos.write("abcdef".getBytes()); // 把字符串变成字节数组。        //关闭流资源fos.close();}}

package javaStudy;/** *  * @author zhaocx1 *  *//* * 复制图片 * 思路： * 1.用字节读取流对象和图片关联。 * 2.用字节写入流创建一个图片文件，用于存储获取到的图片数据。 * 3.通过循环读写，完成数据的存储。 * 4.关闭资源。 */import java.io.FileInputStream;//导入IO流包中的类包import java.io.FileOutputStream;import java.io.IOException;public class CopyPictureDemo {public static void main(String[] args) {        //定义一个字节流读取流FileInputStream fis = null;//定义一个字节写入流FileOutputStream fos = null;try {//对字节流操作方法进行异常处理//通过字节流读取读片fis = new FileInputStream("d:\\1.JPG");//通过字节写入流创建一张图片fos = new FileOutputStream("d:\\2.JPG");//定义一个byte类型的数组用于存储读到 的数组byte[] buf = new byte[1024];int len = 0;while ((len = fis.read(buf)) != -1) {//对数据进行一个一个读取fos.write(buf, 0, len);//将读到的数据写入到创建的图片中}} catch (IOException e) {//catch后面跟的是异常对象throw new RuntimeException("复制文件失败");} finally {//finally后面的内容一定执行的到try {if (fis != null)fis.close();//关闭流资源} catch (IOException e) {//对相应的读取流进行处理throw new RuntimeException("读取关闭失败");//抛出异常}try {if (fos != null)fos.close();//关闭流资源} catch (IOException e) {//对相应的写入流进行处理throw new RuntimeException("写入关闭失败");//抛出异常}}}}

package javaStudy;import java.io.BufferedInputStream;//导入IO流包中的类包import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;/** *  * @author zhaocx1 *  *//* * 演示mp3的复制，通过缓冲区。 *  * BufferdOutputStream BufferedInputStream */public class InputStreamBufferedDemo {public static void main(String[] args) throws IOException {// 函数上抛出异常long start = System.currentTimeMillis();// 定义方法开始操作的时间copy_1();long end = System.currentTimeMillis();// 定义操作方法结束的事件System.out.println((end - start) + "毫秒");// 输出打印公共多长时间}// 通过字节流的缓冲区完成复制。public static void copy_1() throws IOException {// 通过字节流缓冲区读取一个MP3BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("d:\\小苹果.mkv"));// 通过字节流缓冲区创建一个MP3用于存储读到的数据BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:\\小苹果_copy.mkv"));int by = 0;while ((by = bufis.read()) != -1) {// 对数据进行读取bufos.write(by);}bufos.close();// 关闭流资源bufis.close();}}

package javaStudy;/** *  * @author zhaocx1 *  *//* * 读取键盘录入。 * System.out:对应的是标准的输出设备，控制台。 * System.in：标准的输入设备，键盘。 *  * 需求：  * 通过键盘录入数据。 * 当录入一行数据后，就将改行数据进行打印。 * 如果录入的数据是over，那么停止录入。 *  * 通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行原理。 * 也就是readLine方法。 * 能不能直接使用readLine方法来完成键盘录入一行数据的读取呢？ * readLine方法是字符流BufferedReader类中的方法。 *  * 而键盘录入的read方法是字节流InputStream的方法。 * 那么能不能将字节流转成字符流在使用字符流缓冲区的readLine方法呢？ */import java.io.*;public class KeyDemo {public static void main(String[] args) throws IOException {//函数上抛出异常// 获取键盘录入对象。<span style="white-space:pre"></span><span style="white-space:pre"></span>//InputStream in = System.in;<span style="white-space:pre"></span>// 将字节流对象转成字符流对象，使用转换流，InputStreamReader.<span style="white-space:pre"></span>//InputStreamReader isr = new InputStreamReader(in);<span style="white-space:pre"></span>// 为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader.<span style="white-space:pre"></span>//BufferedReader bufr = new BufferedReader(isr);<span style="white-space:pre"></span><span style="white-space:pre"></span>BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));//键盘录入  一定要记住<span style="white-space:pre"></span>BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));//键盘输出  一定要记住<span style="white-space:pre"></span><span style="white-space:pre"></span><span style="white-space:pre"></span>String line = null;<span style="white-space:pre"></span>while ((line = bufr.readLine()) != null) {<span style="white-space:pre"></span>if("over".equals(line)) <span style="white-space:pre"></span>break; //定义一个键盘结束标记。<span style="white-space:pre"></span>System.out.println(line.toUpperCase());<span style="white-space:pre"></span>}<span style="white-space:pre"></span>bufr.close();<span style="white-space:pre"></span>}}

package javaStudy;/** *  * @author zhaocx1 *  */import java.io.BufferedReader;//导入IO流包中的类包import java.io.BufferedWriter;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;/* * 流操作的基本规律： * 最痛苦的就是流对象有很多，不知道该用哪一个。 *  * 通过三个明确来完成： * 1.明确操作源和目的。 *     源：输入流。 InputStream  Reader *     目的：输出流。 OutputStream Writer * 2.操作的数据是否是纯文本。 *     是：用字符流。 *     不是：字节流。 * 3.当体系明确后，再明确使用哪个具体的对象。 *     通过设备来进行区分： *     源设备：内存，硬盘，键盘。 *     目的设备：内存，硬盘，控制台。 *  * 1，将一个文本文件中的数据存储到另一个文件中，复制文件。 *     源：因为是源，所以使用读取流，InputStream Reader *        因为是操作文本文件，所以选择Reader *        此时体系明确。 *      *     接下来明确要使用该体系中的哪个对象。 *     明确设备：硬盘。 *     Reader体系中可以操作的文件的对象是FileReader. *      *     是否需要提高效率，是！ 加入Reader体系中的BufferedReader. *     FileReader fr=new FileReader("a.xt");  *     BufferedReader bufr=new BufferedReader(fr); *      *   目的：OuputStream  Writer *       因为此时是纯文本文件，使用Writer *       设备：硬盘，一个文件。 *       Writer体系中可以操作文件的对象是FileWriter. * *      是否需要提高效率，是！ 加入Writer体系中的BufferedWriter. *      FileWriter fw=new FileWriter("b.txt"); *      BufferedWriter bufw=new BufferedWriter("fw.txt"); *       * 练习：将一个图片文件中数据存储到另一个文件中，复制文件，要按照以上格式自己完成三个明确。 */public class IOCaoZuoDemo1 {public static void main(String[] args) throws IOException {// 通过键盘录入在读取文件中的数据BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("字符读取流缓冲区.java")));// 通过键盘输出读取文件中的数据BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter((System.out)));String line = null;while ((line = bufr.readLine()) != null)//对文件中的数据一行行进行读取{if ("over".equals(line))//定义一个标记用于结束录入的信息break;bufw.write(line.toUpperCase());//将读取的数据以大写形式写入控制台;bufw.newLine();//对写入的数据进行换行System.out.println(line.toUpperCase());//以大写形式输出打印读到的信息}bufr.close();//关闭流资源bufw.close();}}

package javaStudy;/** *  * @author zhaocx1 *  */import java.io.FileInputStream;//导入IO流包中的类包import java.io.IOException;import java.io.PrintStream;/* * 2.需求：将键盘录入的数据保存到一个文件中。 *     这个需求中有源和目的的存在。那么分别分析： *     源：InputStream  Reader *     因为是纯文本，所以使用Reader *  *     设备：键盘，对应的对象是System.in.cc *     不是选择Reader吗？System.in.对应的不是字节流吗？ *     为了操作键盘的文本呢数据方便，转成字符流按照字符串操作是最方便的。 *     所以既然明确了Reader，那么就将System.in转换成字符流Reader。 *     用到Reader体系中的转换流，InputStreamReader *      *     InputStreamReader isr=new InputStreamReader(System.in); *      *     需要提高效率吗？需要!BufferedReader  *     BufferedReader bufr=new BufferedReader(isr); *      *     FileWriter fw=new FileWriter("c.txt"); *     需要提高效率吗？需要。 *     BufferedWriter  bufw=new BufferedWriter(fw); *      *      *     扩展一下，想要把录入的数据按照指定的编码表（utf-8）,将数据存到文件中。 *     目的：OutputStreamWriter *     是否是纯文本呢？是 Writer! *     设备：硬盘，一个文件，使用FileWriter. *     但是FileWriter是使用的默认编码表，GBK. *      *     但是存储时，需要加入指定编码表utf-8，而指定的编码表只有转换流可以指定。 *     所以使用的对象是OutputStreamWriter. *     而该转换流对象要接受一个字节输出流，而且还可以操作的文件的字节输出流，FileOutputStream *      *     OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt),"UTF-8"); *     需要高效吗？需要 *     BufferedWriter bufw=new BufferedWriter(osw); *      *     所以，记住，    */public class IOCaoZuoDemo2 {public static void main(String[] args)throws IOException{System.setIn(new FileInputStream("a.txt"));//改变标准输入设备System.setOut(new PrintStream("b.txt"));//改变标准输出设备}}