黑马程序员——Java基础——IO流（一）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

IO流：

package cn.fuxi._06io;/** * IO流: * IO流用来处理设备之间数据的传输,Java对数据的操作是通过流的方式.Java用于 * 操作流的对象都在IO包中. * 输入流和输出流相对于内存设备而言. *  * 将外设中的数据读取到内存中:输入. * 将内存的数据写入到外设中:输出. *  * 流按操作数据分为两种:字节流和字符流. *  * 字符流的由来: * 其实就是:字节流读取文字字节数据后,不直接操作,而是先查指定的编码表,获取对应的文字. * 再对这个文字经行操作. * 简单说:字节流+编码表 *  *  * IO常用基类-字符流: * 字节流的抽象基类:InputStream,OutputStream. * 字符流的抽象基类:Reader,Writer. *  * P.S. * 由着四个类派生出来的子类名称都是以其父类名作为子类名的后缀. * 如:InputStream的子类FileInputStream. * 如:reader的子类FileReader. *//* * 需求:将一些文字存储到硬盘一个文件中. * 注意:如果要操作文字数据,优先考虑字符流. * 而且要将数据从内存写到硬盘上,要使用字符输出流:Writer. * 硬盘的数据基本体现是文件,希望找到一个可以操作文件的Writer:FileWriter. *  */import java.io.*;public class _01FileWriterDemo {public static void main(String[] args) {//创建一个可以往文件中写入字符数据的字符输出流对象//既然是往一个文件中写入文字数据,那么在创建对象时,就必须明确该文件用于存储数据的目的.//如果文件不存在,则会自动创建//如果文件存在,则会被覆盖try {FileWriter fw = new FileWriter("IoDemo.txt");//调用Writer对象中的write(String s)方法,写入数据//数据暂时被写入到临时存储缓冲区中fw.write("我不会告诉你我的马甲名字其实就是传说中的传奇查");//进行刷新,将数据直接写入到目的地中fw.flush();//关闭流,关闭资源,在关闭前会先调用flush刷新缓冲中数据到目的地.fw.close();} catch (IOException e) {e.printStackTrace();}finally{}}}

输出结果：

package cn.fuxi._06io;/** * 如果构造函数中加入true,可以实现对文件进行续写. */import java.io.*;public class _02FileWriterDemo{public static void main(String[] args){try {FileWriter fw = new FileWriter("IoDemo.txt",true);fw.write("\r\n我传奇查有100种方法让你在IT界混不下去!");fw.flush();fw.write("糖宝~");fw.flush();fw.close();} catch (IOException e) {e.printStackTrace();}}}

输出结果：

package cn.fuxi._06io;/** * IO流的异常处理方式:为防止代码异常导致流无法关闭,因此在finally中对流经行关闭 */import java.io.*;public class _03FileWriterDemo {public static void main(String[] args) {FileWriter fw = null;try {fw = new FileWriter("IoDemo.txt",true);fw.write("啦啦啦~种太阳~");fw.flush();} catch (IOException e) {e.printStackTrace();}finally{try {fw.close();} catch (IOException e) {throw new RuntimeException("关闭失败");}}}}

package cn.fuxi._06io;/** * 需求:读取一个文件,将读取的字符打印到控制台(使用FileReader) * 第一种读取方式:使用read()方法读取文本文件数据. */import java.io.*;public class _04FileReaderDemo {public static void main(String[] args) {FileReader fr =null;try {fr = new FileReader("IoDemo.txt");//用Reader中的read()方法读取字符int ch = 0;while((ch = fr.read())!=-1){//作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 System.out.print((char)ch);}} catch (IOException e) {e.printStackTrace();}finally{try {fr.close();} catch (IOException e) {e.printStackTrace();}}}}

输出结果：

我不会告诉你我的马甲名字其实就是传说中的传奇查
我传奇查有100种方法让你在IT界混不下去!糖宝~啦啦啦~种太阳~

package cn.fuxi._06io;/** * 第二种读取方式:使用read(char[])方法读取文本文件数据. */import java.io.*;public class _05FileReaderDemo {public static void main(String[] args) {FileReader fr = null;try {fr = new FileReader("IoDemo.txt");//使用read(char[])读取文本文件数据//先穿件字符数组char[] buf = new char[1024];int len = 0;while((len=fr.read(buf))!=-1){System.out.println(new String(buf,0,len));}} catch (Exception e) {e.printStackTrace();}finally{try {fr.close();} catch (IOException e) {e.printStackTrace();}}}}

输出结果：

我不会告诉你我的马甲名字其实就是传说中的传奇查
我传奇查有100种方法让你在IT界混不下去!糖宝~啦啦啦~种太阳~

package cn.fuxi._06io;/** * 练习: * 将d盘的一个文本文件复制到c盘 * 分析:读取d盘的IoDemo.txt文件中的数据,将这些数据写入到c盘copyText_1.txt文件中. * 既然是操作文本数据,使用字符流. * 方式1:使用read()读取文本文件数据. * 方式2:使用read(char[])读取文本文件数据. */import java.io.*;public class _06FileReaderTest {public static void main(String[] args) {method_1();method_2();}public static void method_1(){FileReader fr = null;FileWriter fw = null;try {fr = new FileReader("IoDemo.txt");fw = new FileWriter("Copy_IoDemo.txt");int ch;while((ch = fr.read())!=-1){fw.write(ch);//可以看到,字符型数据传输的本质本质也是数字传输,ch的类型为Int}} catch (Exception e) {e.printStackTrace();}finally{try {fw.close();} catch (IOException e) {e.printStackTrace();}try {fr.close();} catch (IOException e) {e.printStackTrace();}}}public static void method_2(){FileReader fr = null;FileWriter fw = null;try {fr = new FileReader("IoDemo.txt");fw = new FileWriter("Copy2_IoDemo.txt");char[] ch = new char[1024];int len = 0;while((len=fr.read(ch))!=-1){fw.write(ch,0,len);}} catch (IOException e) {e.printStackTrace();}finally{try{fw.close();}catch(IOException e){e.printStackTrace();}try{fr.close();}catch(IOException e){e.printStackTrace();}}}}

输出结果：

package cn.fuxi._06io;/** * 字符串缓冲区 * 缓冲区的出现提高了对数据的读写效率. *  * 对应类: * BufferedWriter * BufferedReader *  * P.S. * 缓冲区要结合流才可以使用. *  * 作用:在流的基础上对流的功能进行了增强.提高写入效率,使用缓冲区. */import java.io.*;public class _07BufferedWriter {public static void main(String[] args) throws IOException {FileWriter fw = new FileWriter("buff.txt");//为了提高写入效率,使用字符流的缓冲区.//创建了一个字符写入流的缓冲区对象,并且指定与要被缓冲的流对象想关联BufferedWriter bufw = new BufferedWriter(fw);for (int i = 0; i <= 4; i++) {//使用缓冲区的写入方法,将数据写入到缓冲区中.bufw.write("abcdef"+i);//写入内容换行方法:newLine();bufw.newLine();bufw.flush();}//使用缓冲区的刷新方法将数据刷入目的地中bufw.flush();//关闭缓冲区,其实关闭的就是被缓冲的流对象fw.close();}}

输出结果：

package cn.fuxi._06io;/** * 提高读取效率,使用缓冲区 */import java.io.*;public class _08BufferedReader {public static void main(String[] args) throws IOException {FileReader fr = new FileReader("buff.txt");BufferedReader bf = new BufferedReader(fr);String line = null;while((line = bf.readLine())!=null){System.out.println(line);}bf.close();}}

输出结果：

abcdef0
abcdef1
abcdef2
abcdef3
abcdef4

package cn.fuxi._06io;/** * 字符流缓冲区: * 写入换行使用BufferedWriter类中的newLine()方法. * 读取一行数据使用BufferedReader类中的readLine()方法. *  * br.read():这个read方法是从缓冲区中读取字符数据,所以覆盖了父类中的read方法. * br.readLine():另外开辟了一个缓冲区,存储的是原缓冲区一行的数据,不包含换行符. *  * 原理:使用了读取缓冲区的read方法,将读取到的字符进行缓冲并判断换行标记,将标记前 * 的缓冲数据变成字符串返回. *  */import java.io.*;public class _09BufferedReaderWriter {public static void main(String[] args) throws Exception{FileReader fr = new FileReader("buff.txt");BufferedReader br = new BufferedReader(fr);FileWriter fw = new FileWriter("Copy_buff.txt");BufferedWriter bw = new BufferedWriter(fw);//方式一:一行一行读写/*String line = null; while((line=br.readLine())!=null){bw.write(line);bw.newLine();//写一行要换一行,不然会黏在一起bw.flush();;}*///方式二:一个一个读写int ch=0;while((ch=br.read())!=-1){bw.write(ch);bw.flush();//flush不写会空白}bw.close();br.close();}}

输出结果：

package cn.fuxi._06io;/** * LineNumberReader * 跟踪行号的缓冲字符输入流.此类定义了方法setLineNumber(int)和getLineNumber(); * 他们可分别用于设置和获取当前行号. */import java.io.*;public class _10LineNumberReader {public static void main(String[] args) throws IOException{FileReader fr = new FileReader("D:\\develop\\workspace\\fuxi4\\src\\cn\\fuxi\\_06io\\_10LineNumberReader.java");LineNumberReader lnr = new LineNumberReader(fr);String line = null;lnr.setLineNumber(100);while((line = lnr.readLine())!=null){System.out.println(lnr.getLineNumber()+":"+line);}lnr.close();}}

输出结果：

101:package cn.fuxi._06io;
102:/**
103: * LineNumberReader
104: * 跟踪行号的缓冲字符输入流.此类定义了方法setLineNumber(int)和getLineNumber();
105: * 他们可分别用于设置和获取当前行号.
106: */
107:import java.io.*;
108:
109:public class _10LineNumberReader {
110: public static void main(String[] args) throws IOException{
111: FileReader fr = new FileReader("D:\\develop\\workspace\\fuxi4\\src\\cn\\fuxi\\_06io\\_10LineNumberReader.java");
112: LineNumberReader lnr = new LineNumberReader(fr);
113:
114: String line = null;
115: lnr.setLineNumber(100);
116: while((line = lnr.readLine())!=null){
117: System.out.println(lnr.getLineNumber()+":"+line);
118: }
119: lnr.close();
120: }
121:}

package cn.fuxi._06io;/** * 对原有类进行了功能的改变,增强. */class Person{void chiFan(){System.out.println("吃饭啦!!!");}}//采用装饰的方式增强Person类//这个类的出现是为了增强Person而出现的class NewPerson{private Person p;NewPerson(Person p){this.p = p;}public void chiFan(){System.out.println("开胃菜");p.chiFan();System.out.println("甜点");}}//采用继承的方式增强Person类class NewPerson2 extends Person{public void chiFan(){System.out.println("来瓶1982的拉菲!");super.chiFan();System.out.println("来瓶卡斯特!");}}public class _11ZhuangShiDemo {public static void main(String[] args) {Person p = new Person();p.chiFan();System.out.println("-------------------");NewPerson np = new NewPerson(p);np.chiFan();System.out.println("-------------------");NewPerson2 np2 = new NewPerson2();np2.chiFan();}}/* *装饰和继承都可以对功能进行拓展,两者之间有何区别呢? *装饰较为灵活,可以不产生继承关系. *装饰像缓冲一样可以和具体对象相结合 *可以将缓冲功能进行单独的封装,哪个对象需要缓冲就关联哪个对象  */ 

输出结果：

吃饭啦!!!
-------------------
开胃菜
吃饭啦!!!
甜点
-------------------
来瓶1982的拉菲!
吃饭啦!!!
来瓶卡斯特!

package cn.fuxi._06io;/** * 首先由一个继承体系: * Writer * |--TextWriter:用于操作文本. * |--MediaWriter:用于操作媒体. * 如果想要对操作的动作进行效率的提高,按照面向对象,可以通过继承的方式对具体的 * 对象进行功能的拓展,那么就需要加入缓冲技术. * Writer * |--TextWriter:用于操作文本. * |--BufferTextWriter:加入了缓冲技术的操作文本的对象. * |--MediaWriter:用于操作媒体 * |--BufferMediaWriter:加入了缓冲技术的操作媒体的对象. * 以上方式并不理想,如果这个体系需要再进行功能扩展,又多了更多流对象. * 这样就好发现只为了提高功能,导致继承体系越来越臃肿,不够灵活. *  * 重新思考问题: * 既然都是加入的同一种技术----缓冲. * 前一种是让缓冲和自己的流对象相结合. * 可不可以将缓冲经行单独的封装,哪个对象需要缓冲就将哪个对象和缓冲相关联. *//*import java.io.*;class Buffer{Buffer(TextWriter w){}Buffer(MediaWriter w){}}//简化为class BufferedWriter extends Writer{BufferedWriter(Writer){}}*//** * Writer * |--TextWriter:用于操作文本 * |--MediaWriter:用于操作媒体 * |--BufferedWriter:用于提高效率 *  * 可见:装饰比继承更灵活. * 特点:装饰类和被装饰类都必须所属同一个接口或父类. */

<pre name="code" class="java">package cn.fuxi._06io;/** * 练习: * 自定义一个读取缓冲区类,模拟一个BufferedReader. * 分析: * 缓冲区中无非就是封装了一个数组,并对外提供了更多的方法对数组经行访问 * 其实这些方法最终操作的都是数组的角标. * 缓冲的原理: * 其实就是从源中获取一批数据到缓冲区中,再从缓冲区中不断的取出一个一个数据. * 在此次取完后,再从源中继续取一批数据进入缓冲区,当源中的数据被取完时,用-1作为结束标记. */import java.io.*;class MyBufferedReader{private Reader r;//定义一个数组作为缓冲区private char[] buf = new char[1024];//定义一个指针用于操作这个数组中的元素,当操作到最后一个元素后,指针应该归零private int pos = 0;//定义一个计数器用于记录缓冲区中的数据个数,当该数据减到0;//就从源中继续获取数据到缓冲区中.private int count = 0;MyBufferedReader(Reader r){this.r = r;}//该方法从缓冲区中一次取一个字符public int myRead() throws IOException{//从源中获取一批数据到缓冲区中,需要先做判断,只有计数器为0时,才需要//从源中获取数据.if(count == 0){count = r.read(buf);//每次获取数据到缓冲区后,角标归零pos = 0;}if(count<0)return -1;char ch = buf[pos];pos++;count--;return ch;}public String myReadLine() throws IOException{StringBuilder sb = new StringBuilder();int ch = 0;while((ch=myRead())!=-1){if(ch=='\r')continue;if(ch=='\n')return sb.toString();//从缓冲区读取到的字符,存储到缓冲行的缓冲区中sb.append((char)ch);}if(sb.length()!=0){return sb.toString();}return null;}public void myClose() throws IOException{r.close();}}public class _13BufferTest {public static void main(String[] args) throws IOException {FileReader fr = new FileReader("IoDemo.txt");MyBufferedReader mbr = new MyBufferedReader(fr);String line = null;while((line=mbr.myReadLine())!=null){System.out.println(line);}mbr.myClose();}}

输出结果：

我不会告诉你我的马甲名字其实就是传说中的传奇查
我传奇查有100种方法让你在IT界混不下去!糖宝~啦啦啦~种太阳~

package cn.fuxi._06io;/** * IO流常用基类-字节流 * 基本操作与字符流类相同.但它不仅可以操作字符,还可以操作其他媒体文件. */import java.io.*;public class _14FileOutputStream {public static void main(String[] args) throws IOException {demo_write();}public static void demo_write() throws IOException{//1.创建字节流输出对象,用于操作文件FileOutputStream fos = new FileOutputStream("IoDemo.txt",true);//2.写数据,直接写入到了目的地中fos.write("ssdlajs".getBytes());//3.关闭资源~fos.close();}}

输出结果：

package cn.fuxi._06io;/** * FileInputStream */import java.io.*;public class _15FileInputStream {public static void main(String[] args) throws IOException{demoRead1();demoRead2();demoRead3();}//读取方式一:全部一次性用数组读取public static void demoRead1() throws IOException{//创建一个读取流对象,和指定文件关联FileInputStream fis = new FileInputStream("IoDemo.txt");//打印字符字节大小,不过要少用,文件太大,可能内存溢出byte[] buf = new byte[fis.available()];fis.read(buf);System.out.println(new String(buf));fis.close();}//方式二:推荐使用数组缓冲public static void demoRead2() throws IOException{FileInputStream fis = new FileInputStream("IoDemo.txt");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 demoRead3() throws IOException{FileInputStream fis = new FileInputStream("IoDemo.txt");InputStreamReader isr = new InputStreamReader(fis);int ch = 0;while((ch = isr.read())!=-1){System.out.print((char)ch);}fis.close();}}/* * FileOutputStream,FileInputStream的flush方法为空,没有任何实现,调用没有意义. * 字节流的缓冲区,同样是提高字节流的读写效率. */

输出结果：

我不会告诉你我的马甲名字其实就是传说中的传奇查
我传奇查有100种方法让你在IT界混不下去!糖宝~啦啦啦~种太阳~ssdlajs
我不会告诉你我的马甲名字其实就是传说中的传奇查
我传奇查有100种方法让你在IT界混不下去!糖宝~啦啦啦~种太阳~ssdlajs
我不会告诉你我的马甲名字其实就是传说中的传奇查
我传奇查有100种方法让你在IT界混不下去!糖宝~啦啦啦~种太阳~ssdlajs

package cn.fuxi._06io;/** * 练习: * 通过几种方式对MP3经行拷贝,比较它们的效率. */import java.io.*;public class _16Mp3CpoyTest {public static void main(String[] args) throws IOException{method_Int();method_Array();}public static void method_Int() throws IOException{long l1 =System.currentTimeMillis();FileInputStream fis = new FileInputStream("澤野弘之 - aLIEz (instrumental).flac");FileOutputStream fos = new FileOutputStream("Copy - aliez.flac");int ch = 0;while((ch = fis.read())!=-1){fos.write(ch);}fos.close();fis.close();long l2 = System.currentTimeMillis();System.out.println(l2-l1);}public static void method_Array() throws IOException{long l1 = System.currentTimeMillis();FileInputStream fis = new FileInputStream("澤野弘之 - aLIEz (instrumental).flac");FileOutputStream fos = new FileOutputStream("Copy2 - aliez.flac");byte[] buf = new byte[1024];int len = 0;while((len = fis.read(buf))!=-1){fos.write(buf,0,len);}fos.close();fis.close();long l2 = System.currentTimeMillis();System.out.println(l2-l1);}}

输出结果：

162982
277