/* 字符流的缓冲区。自己MyBufferReader的readLine方法。装饰设计模式。字节流。自定义一个缓冲区模拟BufferedInputStream。读取键盘 录入。转换流。流操作的基本规律 */ /* 字符流的缓冲区 缓冲区的出现提高了对流数据的操作效率 对应类 BufferedWriter BufferedReader 缓冲区要结合流才可以使用 在流的基础上对流的功能进行了增强 很多软件都有自己的缓冲区。比如迅雷。 二个构造方法必须有参数，必须有流才能使用。 BufferedWriter缓冲区中提供了一个跨平台的换行符。newLine(); /r/n不跨平台。 */ import java.io.*; class BufferWriter { public static void main(String[] args) throws IOException { bufWriter(); /* //创建一个字符写入流对象 FileWriter fw = new FileWriter("buf.txt"); //为了提高字符写入流的效率，加入了缓冲技术。 //缓冲原理：对象里面封装了数组 //只要将需要被提高效率的流对象作为参数传递给 //缓冲区的构造方法就可。 BufferedWriter bufw =new BufferedWriter(fw); bufw.write("abcde"); //记住，只要用到BufferedWriter缓冲区，就要记得刷新 bufw.flush(); //其实关闭缓冲区，就是在关闭缓冲区中的流对象 bufw.close(); */ } public static void bufWriter() throws IOException { FileWriter fw = new FileWriter("demo.txt"); BufferedWriter bufw = new BufferedWriter(fw); for (int x= 0;x<5 ;x++) { bufw.write("abcd"+x); bufw.newLine();//跨平台的换行。 bufw.flush(); } bufw.close(); } } /* 字符读取流缓冲区：BufferReader 该缓冲区提供了一个一次读一行的方法：readLine(), 方便于对文本数据的获取，当读到null时，表示读到文件的末尾。 readLine()方法返回的时候只返回回车符之前的数据内容，并不返回回车符。 所以我们自己写的时候要加newLine(); 原理：无论是读一行，获取读取多个字符，其实最终都是在硬盘上一个一个 读取，所以最终还是使用read()一次读一个方法。 */ import java.io.*; class BufferReader { public static void main(String[] args) throws IOException { //创建一个读取流对象和文件相关联 FileReader fr = new FileReader("demo.txt"); //为了提高效率。加入缓冲技术，将字符读取流对象 //作为参数传递给缓冲对象的构造函数 BufferedReader bufr = new BufferedReader(fr); String s1 = null; while((s1=bufr.readLine())!=null) { System.out.println("s1="+s1); } bufr.close(); } } /*练习 通过缓冲区复制一个.java文件 */ import java.io.*; class BufferCopyJava { public static void main(String[] args) { BufferedReader bufr = null; BufferedWriter bufw = null; try { bufr = new BufferedReader(new FileReader("BufferWriter.java")); bufw = new BufferedWriter(new FileWriter("CopyBufferJava.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("写入关闭失败"); } } } } /* 定义一个自己MyBufferReader的readLine方法 原理：无论是读一行，获取读取多个字符，其实最终都是在硬盘上一个一个 读取，所以最终还是使用read()一次读一个方法。 */ import java.io.*; class MyBufferReader { private FileReader r; MyBufferReader(FileReader r) { this.r = r; } public String myReadLine() throws IOException { //定义一个临时容器，源程序中封装的是字符数组。 //这里为了演示方便，定义一个StringBuilder容器，因为最终还要是将数据变成字符串 StringBuilder sb = new StringBuilder(); int buf = 0; while((buf=r.read())!= -1) { if (buf=='\r') { continue; } if (buf=='\n') { return sb.toString(); //sb.delete(0,sb.length());？？？ //是因为return后,sb会自己清空。生命周期。 //还是每次都新一个new StringBuilder？？ } else sb.append((char)buf); } if (sb.length()!=0) { return sb.toString(); } return null; } public void myClose()throws IOException { r.close(); } } class MyBuffer { public static void main(String[] args) throws IOException { FileReader fr = new FileReader("demo.txt"); MyBufferReader mbr = new MyBufferReader(fr); String s = null; while ((s = mbr.myReadLine())!=null) { //return s; System.out.println(s); } mbr.myClose(); } } /* 装饰设计模式： 当想要对已有的对象进行功能增强时， 可以定义一个类，将已有对象传入，基于 已有对象的功能，并提供加强功能 那么自定义的该类就称为装饰类 装饰类通常会通过构造方法接收被 装饰对象，并基于被装饰对象的功能 提供更强大的功能。 */ 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("开胃酒"); //System.out.println("吃饭"); p.chifan(); System.out.println("甜点"); System.out.println("来一根"); } } class PersonDemo { public static void main(String[] args) { Person p = new Person(); //p.chifan(); SupperPerson sp = new SupperPerson(p); sp.superChifan(); } } /* MyReader//专门用于读取数据的类 |--MyTextReader |--MyBufferTextReader |--MyMediaReader |--MyBufferMediaReader |--MyDateReader |--MyBufferDateReader class MyBufferReader { MyBufferReader(MyTextReader text){} MyBufferReader(MyMediaReader media){} }//这个类扩展类很差，可以找其参数的共同类型， //通过多态的形式，可以提高扩展性 class MyBufferReader extends MyReader { private MyReader r; MyBufferReader(MyReader r){} //从继承变结合结构 } 后来的体系 MYReader//专门用于读取数据的类 |--MyTextReader |--MyMediaReader |--MyDateReader |--MyBufferReader 装饰模式比继承更灵活，避免了继承体系的臃肿 而且降低了类之间的关系。 装饰类因为增强已有对象，具备的功能和已有对象是相同的， 只不过提供了更强的功能， 所以装饰类和被装饰类都属于一个体系中。 建设继承要写，但不要以继承为主，继承太多了会臃肿。 */ /* 自己定义一个模拟BufferedReader的方法readLine() 通过read()方法 */ import java.io.*; class MyBufferedReader extends Reader//继承 { private Reader r;//修改了FileReader，更具扩展性 MyBufferedReader( Reader r) { this.r = r; } public String myReadLine()throws IOException { int buf = 0; StringBuilder sb = new StringBuilder(); while ((buf = r.read())!=-1) { if(buf == '\r') { continue; } if(buf=='\n') { return sb.toString(); } else sb.append((char)buf); } if (sb.length()!=0) { return sb.toString(); } return null; } //覆盖Reader类中的二个抽象方法，继承必须复写 public int read(char[] cbuf,int off,int len)throws IOException { return r.read( cbuf, off,len);//子类肯定要实现，调用它就可以了。 } public void close()throws IOException { r.close(); } public void myClose()throws IOException { r.close(); } } class MyBufferedReaderDemo { public static void main(String[] args) throws IOException { FileReader fr = new FileReader("demo.txt"); MyBufferedReader mybuf = new MyBufferedReader(fr); String line = null; while ((line=mybuf.myReadLine())!=null) { System.out.println(line); } mybuf.myClose(); } } //练习。自定义一个带行号的readLine();LineNumberReader import java.io.*; class MyLineNumberReader { private Reader r ; private int lineNumber ; MyLineNumberReader(Reader r) { this.r = r; } public void setLineNumber(int lineNumber) { this.lineNumber = lineNumber; } public int getLineNumber() { return lineNumber; } public String myReaderLine()throws IOException { lineNumber++; StringBuilder sb = new StringBuilder(); int buf =0; while ((buf = r.read())!=-1) { if(buf=='\r') { continue; } if (buf=='\n') { return sb.toString(); } else sb.append(buf); } if(sb.length()!=0) return sb.toString(); return null; } public void myColse()throws IOException { r.close(); } } class MyLineNumberReaderDemo { public static void main(String[] args)throws IOException { FileReader fr = new FileReader("MyBuffer.java"); MyLineNumberReader mylnr = new MyLineNumberReader(fr); String line = null; while ((line = mylnr.myReaderLine())!=null) { System.out.println(mylnr.getlineNumber()+":::"+line); } mylnr.close(); } } /* class LineNumberReaderDemo { public static void main(String[] args) throws IOException {//第一次，这是java提供的。 FileReader fr = new FileReader("MyBuffer.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(); } } *///以上可以简化程序，因为父类已经提供了相关方法。这里我就不写了 /* 字符流 FileReader FileWriter BufferedReader BufferedWriter 字节流 InputStream OutputStream 需求：想要操作图片数据。这时就要用到字节流。 字节流不需要缓冲。不需要刷新。 但需要关闭资源。 */ import java.io.*; class FileStream { public static void main(String[] args) throws IOException { stream_3(); } public static void stream_1()throws IOException { FileOutputStream fo = new FileOutputStream("fos.txt"); fo.write("abcdef".getBytes()); FileInputStream fi = new FileInputStream("fos.txt"); int num = 0; while ((num = fi.read())!=-1) { System.out.println((char)num); } fi.close(); fo.close(); } public static void stream_2()throws IOException { FileInputStream fi = new FileInputStream("fos.txt"); byte[] buf = new byte[1024]; int len = 0; while ((len = fi.read(buf))!=-1) { System.out.println(new String(buf,0,len)); } fi.close(); } public static void stream_3()throws IOException { FileInputStream fi = new FileInputStream("fos.txt"); byte buf[] = new byte[fi.available()]; //字节流特有的，返回字符个数。换行符(\r\n)等于二个字节。 //定义一个刚刚好的缓冲区，不用循环了。 fi.read(buf); System.out.println(new String(buf)); fi.close(); } } /* 复制一个图片 思路： 1，用字节读取流对象和图片关联 2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。 3，通过循环读写，完成数据的存储 4，关闭资源。 最后问：用字符流可以复制吗？可以，但是有可能打不开。因为要去表里面查 字符，有可能这个字符没有，就用相似的表示了。所以不要用字符流拷贝媒体文件。 */ import java.io.*; class CopyPic { public static void main(String[] args) { FileInputStream fi = null; FileOutputStream fo = null; try { fi = new FileInputStream("c:\1.jpg"); fo = new FileOutputStream("c:\2.jpg"); byte[] buf = new byte[1024]; int len = 0; while ((len = fi.read(buf))!=-1) { fo.write(buf,0,len); } } catch (IOException e) { new RuntimeException("复制失败"); } finally { try { if (fi != null) { fi.close(); } } catch (IOException e) { new RuntimeException("1111复制失败"); } try { if (fo != null) { fo.close(); } } catch (IOException e) { new RuntimeException("222复制失败"); } } } } /* 演示MP3的复制,通过缓冲区 */ import java.io.*; class CopyMp3 { public static void main(String[] args) throws IOException { long start = System.currentTimeMillis(); copy1(); long end = System.currentTimeMillis(); System.out.println("end-start:"+ (end-start)+"毫秒"); } public static void copy1()throws IOException { BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\0.mp3")); BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\1.mp3")); int len = 0; while ((len = bufis.read())!=-1)//缓冲区里取。 { bufos.write(len);//字节流可以不用刷新。 } bufis.close(); bufos.close(); } } import java.io.*; /* 自定义一个缓冲区模拟BufferedInputStream myRead方法原理和具体实现。 myRead函数主要是把数据抓到缓冲区里，并从缓冲区里一次读一个字节 那么原理是定义一个数组，把流里面的数据抓到数据里面，但是数组长度固定，定义的数组可能装不下； 此时就要用循环读取，但是最后一次读的数组可能就不是数组的长度，此时要把数组里面元素的有效位数找到，通过read(byte[] b)方法。 用一个count变量记住一次读的字节的数量,每读myRead一次时，就把缓冲区里的字节赋值给一个变量，怎么赋值？这根把数组元素的值赋给变量一样， 并且每次赋值时，数组指针会随myRead读取次数向后移1位，故会有pos++，并且把count--(为了后面的count==0),并把变量处理后返回出去;当count为0时候， 此时又会调用一次read(byte[] b) 方法，如此循环，直到count小于(或等于(最后一次))自己定义的数组长度，当读到最后一次字节再往下读的时，此时count为0， 又会执行read(byte[] b) 方法，但此时的count返回-1，就不要在继续读取下去了。 需要注意的是：每读取一次myRead方法，就爱需要读取下一个字节，就需要pos++; int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。 */ class MyBufferedInputStream { private FileInputStream r; private int pos = 0,count = 0; byte[] buf = new byte[1024]; MyBufferedInputStream (FileInputStream r) { this.r = r; } public int myRead()throw IOException//返回int是为了避免出现byte为-1情况。 { //一次性全部读到缓冲区，不要再到硬盘里读，所以速度比较快。 if (count ==0) { count = r.read(buf); if (count < 0) { return -1; } pos = 0; byte b = buf[pos]; pos++; count--; return b&255; } if (count > 0) { byte b = buf[pos]; pos++; count--; return b&255; /*1111-1111———>提升了一个int类型，那不还是-1吗？是-1的原因是因为在前面补1的原因造成的。 那么我只要在前面补0,可以保留原字节数据不变，又可以避免-1出现。怎么补0呢？就是与上255. b&255;也可以写成b&0xff。 */ } return -1; } public void myClose()throw IOException { r.close(); } } class MyBufferedInputStreamDemo { public static void main(String[] args)throw IOException { long start = System.currentTimeMillis(); copy2();//这是一个比较快的复制文件的方法。自定义的读取流缓冲。 long end = System.currentTimeMillis(); System.out.println((end-start)+"毫秒"); } public static int copy2()throw IOException { FileInputStream fis = new FileInputStream("c:\0.mp3"); MyBufferedInputStream mybuf = new MyBufferedInputStream(fis); BufferedOutputStream bufout = new BufferedOutputStream(new FileOutputStream("c:\3.mp3")); int num = 0; while ((num = mybuf.myRead())!=-1) { bufout.write(num);//上面提升了4倍大小，byte->int...其实write在自动做一个强转动作。 } //把最低的八位写出去，其他的全部砍掉。 mybuf.myClose(); bufout.close(); } private static void copy3() throws IOException{//15最快啊。这是最快的复制文件的方法 BufferedInputStream bufin = new BufferedInputStream( new FileInputStream("1.mp3")); BufferedOutputStream bufout = new BufferedOutputStream( new FileOutputStream("2copy.mp3")); int i = 0; byte[] buf = new byte[1024]; while((i=bufin.read(buf))!=-1){//读一片，写一片。 bufout.write(buf,0,i); } bufout.close(); bufin.close(); } } /* 读取键盘录入 System.out:对应的是标准输出设备，控制台 System.in:对应的标准输入设备：键盘 需求： 通过键盘录入数据 当录入一行数据后，就将该行数据进行打印 如果录入的数据是over,那么停止录入 */ import java.io.*; class SystemOut { public static void main(String[] args) throws IOException { InputStream in = System.in;//键盘录入 StringBuilder sb = new StringBuilder(); while (true) { int num = in.read(); if (num == '\r') { continue; } if (num == '\n') { String s = sb.toString(); if (s.equals("over")) { break; } System.out.println(s.toUpperCase()); sb.delete(0,sb.length());//这里不是返回，所以要删除。 } else//为什么要写上这个over才会停止？break跳出当前循环 sb.append((char)num); } //int by = in.read();//阻塞式方法 //int by1 = in.read();//阻塞式方法 //System.out.println(by); //System.out.println(by1); //System.out.println('\r'+0);//验证'\r'的int /* int num = 0; while ((num = in.read())!=-1) { System.out.println(num);//这也是可以的，一个一个字节，还不能判断-1； } */ } } /*转换流 本来就有字节流，字符流可以更方便的操作字符数据，所以把转换流放到字符流里。 */ import java.io.*; class InputStreamReaderDemo { public static void main(String[] args) throws IOException { //获取键盘录入。 //InputStream in = System.in; //将字节流转换成字符流对象。 //InputStreamReader isr = new InputStreamReader(in); //缓冲 //BufferedReader bufr = new BufferedReader(isr); BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); OutputStream out = System.out; //输出 OutputStreamWriter osw = new OutputStreamWriter(out); BufferedWriter bufw = new BufferedWriter(osw); String line = null; while ((line = bufr.readLine())!=null) { if ("over".equals(line)) { break; } bufw.write(line.toUpperCase()); bufw.newLine(); bufw.flush();//字符输出流要刷新 } } } /* 流操作的基本规律 最痛苦的就是流对象有很多，不知道该用哪一个 通过三个明确来完成 1.明确源和目的 源：输入流。InputStream Reader 目的：输出流。OutputStream Writer. 2.操作的数据是否是纯文本。 是；字符流 不是：字节流。 3.当体系明确后，再明确要使用哪个具体的对象 通过设备来进行区分 源设备：内存，硬盘，键盘 目的设备：内存，硬盘，控制台 需求： 1.将一个文本文件中的数据存储到另一个文件中。复制文件。 源：输入流InputStream Reader，是一个文本文件，用Reader. 设备是硬盘，FileReader fr = new FileReader("a.txt"); 需要高效：BufferedReader bufr = new BufferedReader(fr); 目的：输出流。OutputStream Writer. 是一个文本，Writer 设备是硬盘，FileWriter fw = new FileWriter("b.txt"); 需要高效：BufferedWriter bufw = new BufferedWriter(); 2:将键盘录入的数据保存到一个文件中。 源：输入流InputStream Reader，是否纯文本？是！Reader. 设备是键盘，InputStream fis = System.in; 不是选择Reader吗？System.in对应的不是字节流吗？ 为了操作键盘的文本数据方便，转成字符流操作字符串最方便。 所以明确了Reader，那就将System.in转成字符流 用到Reader体系中的转换流。InputStreamReader InputStreamReader isr = new InputStreamReader(System.in); 提高效率：BufferedReader bufr = new BufferedReader(isr); 目的：输出流。OutputStream Writer.是一个文本，Writer. 设备：硬盘。FileWriter fw = new FileWriter("c.txt"); 高效：BufferedWriter bufw = new BufferedWriter(fw); --------------------------- 扩展一下，想要把录入的数据按照指定的编码表（UTF-8）， 将数据存入到文件中。 目的：输出流。OutputStream Writer.是一个文本，Writer. 设备：硬盘。FileWriter 。 但是！！！FileWriter 是使用的默认编码表。GBK 在存储时，要加入指定的编码表UTF- 8，指定编码表只有转换流可以。 所以指定的对象是OutputStreamWriter!!! 而转换流要接收一个字节输出流，而且是可以操作文件的字节输出流 FileOutputStream!!! FileOutputStream fos = new FileOutputStream("d.txt"); OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8"); 高效： BufferWriter bufw = new BufferedWriter(osw); 所以记住，转换流什么时候使用。 1.字符和字节之间的桥梁，通常涉及到编码表时，就要使用。 2.当源和目的是字节流时，而操作的是字符。！ */ /* System.setIn();改变输入 System.setOut();改变输出。如:System.setOut(new PrintStream("zz.txt")) */ import java.io.*; import java.text.*; import java.util.Date; //建立java异常信息。。。其实网络上有专门的工具。log4j class ExceptionInfo { public static void main(String[] args) throws IOException { int[] arr = new int[2]; Date date = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String s = sdf.format(date); try { System.out.println(arr[3]);//这里会出错。 } catch (Exception e) { //e.printStackTrace(); try { PrintStream ps = new PrintStream("b.txt"); //ps.write(date.toString().getBytes()); //ps.println(date.toString()); ps.println(s); System.setOut(ps); //System.out.println(s.toString()); } catch (IOException ex) { throw new RuntimeException("日志文件创建失败"); } e.printStackTrace(System.out); //e.printStackTrace(new PrintStream("exceptioninfo.txt")); } } } import java.io.FileNotFoundException; import java.io.PrintStream; import java.util.Properties; public class SystemInfo { /** * @param args * @throws FileNotFoundException */ public static void main(String[] args) throws FileNotFoundException { // TODO Auto-generated method stub Properties prop = System.getProperties(); //System.out.println(prop);//打印在控制台上 //prop.list(System.out);//自己的方法打印在控制台上 prop.list(new PrintStream("systemInfo.txt"));//改变输出的目的。 } }
/* 字符流的缓冲区。自己MyBufferReader的readLine方法。装饰设计模式。字
阅读背景：
day19字符流的缓冲区。自己MyBufferReader的readLine方法。装饰设计模式。字节流。自定义一个缓冲区模拟BufferedInputStream。读取键盘
来源：互联网
分享到：
