java基础整理十九（IO流一）

 
第十九天
缓冲区:
字符输入流缓冲区:
缓冲区的出现是为了提高流的操作效率而出现的 所以在创建缓冲区之前要先有流对象
newLine();缓冲区提供的跨平台换行符
import java.io.*;
class Demo
{
 public static void main(String[]args)throws IOException
 {
  FileWriter fw = new FileWriter("demo.txt");创建流对象
  为了提高字符书写效率加入缓冲技术,将需提高效率的流对象作为参数传给缓冲区构造函数即可
  BufferedWriter bw = new BufferedWriter(fw);
  bw.write("fjoefjei");
  bw.newLine();
  bw.flush();只要用到缓冲区就要刷新操作
  bw.close();此时关闭的是缓冲区内的流对象,所以流对象不用再进行关闭操作了
 }
}
字符读取流缓冲区:
该缓冲区提供了一个一次读一行的方法readLine返回一个Sting,方便于对文本数据的获,取当返回为null时表示已读到文件末尾
import java.io.*;
class Demo
{
 public static void main(String[]args)throws IOException
 {
  FileReader fr = new FileReader("demo.txt");创建一个流对象和文件相关联
  为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲区构造函数
  BufferedReader br = new BufferedReader(fr);
  String line = null;
  while ((line = br.readLine())!=null)
  {
   System.out.println(line);
  }
  br.close();
 }
}
通过缓冲区复制一个。java文件
import java.io.*;
class Demo
{
 public static void main(String[]args)
 {
  copy();
 }
 public static void copy()
 {
  FileReader fr = null;
  BufferedReader br = null;
  FileWriter fw = null;
  BufferedWriter bw =null;
  try
  {
   fr = new FileReader("11.java");
   br = new BufferedReader(fr);
   fw = new FileWriter("copy11.java");
   bw = new BufferedWriter(fw);
   String line = null;
   while ((line = br.readLine())!=null)
   {
    bw.write(line);
    bw.newLine();
    bw.flush();
   }
  }
  catch (IOException e)
  {
   throw new RuntimeException("无法运行");
  }
  finally
  {
   try
   {
    if(br!=null)
    br.close();
    if(bw!=null)
    bw.close();
   }
   catch (IOException e)
   {
   }
  }
 }
}

自定义一个类中包含功能和readLine一致的方法，模拟BufferedReader
import java.io.*;
class MyBufferedReader extends Reader
{
 private FileReader r;
 MyBufferedReader(FileReader r)
 {
  this.r = r;
 }
 public String myReadLine()throws IOException 定义一次读一行数据的方法
 {
  定义一个临时容器。原BufferReader封装的是字符数组
  为演示,且最终将数据变成字符串,定义一个StringBuilder容器，
  StringBuilder sb = new StringBuilder();
  int ch = 0;
  while((ch = r.read())!=-1)
  {
   if(ch=='\r')
    continue;
   if(ch=='\n')
    return sb.toString();缓冲区内字符返回存储
   else
    sb.append((char)ch);
  }
  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();
 }
}
class Demo
{
 public static void main(String[]args)throws IOException
 {
  FileReader fr = new FileReader("demo.txt");
  MyBufferedReader mb = new MyBufferReader(fr);创建对象的同时构造函数内传入读取流对象
  String line = null;
  while((line=mb.myReadLine())!=null)
  {
   System.out.println(line);
  }
  mb.close();
 }
}

装饰设计模式:
对已有对象功能增强。可以定义类将已有对象传入，基于已有的功能提供增强功能，这个类就为装饰类
装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰对象功能提供更强功能
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("吃水果");
 }
}
class Demo
{
 public static void main(String[]args)
 {
  Person p = new Person();
  SuperPerson sp = new SuperPerson(p);
  sp.superchifan();
 }
}
装饰设计模式与继承模式的区别:
装饰设计模式比继承模式要灵活,避免了继承体系的臃肿,降低了类与类之间的关系
装饰类因为增强已有对象已具备的功能,所以具备和已有对象相同的功能,只是功能更强
因此装饰类和被装饰类通常都属于一个体系,即相同的父类或接口

LineNumberReader:带行号的缓冲区
import java.io.*;
class LineNumberReaderDemo
{
 public static void main(String[]args)throws IOException
 {
  FileReader fr = new FileReader("demo.txt");
  LineNumberReader lnr = new LineNumberReader(fr);
  String line = null;
  lnr.setLineNumber(20);设置行号开始值为21
  while ((line=lnr.readLine())!=null)
  {
   System.out.println(lnr.getLineNumber()+":"+line);获取行号
  }
  lnr.close();
 }
}
自定义LineNumberReader
import java.io.*;
class MyLineNumberReader
{
 private Reader r;
 private int lineNumber;
 MyLineNumberReader(Reader r)
 {
  super()r;
 }
 public String myReadLine()throws IOException
 {
  lineNumber++;
  StringBuilder sb = new StringBuilder();
  int ch = 0;
  while((ch=r.read())!=-1)
  {
   if(ch=='\n')
    continue;
   if(ch=='\r')
    return sb.toString();
   else
   sb.append((char)ch);
  }
  if(sb.length()!=0)
   return sb.toString();
  return null;
 }
 public void setLineNumber(int lineNumber)
 {
  this.lineNumber = lineNumber;
 }
 public int lineNumber()
 {
  return lineNumber;
 }
 public void myClose()throws IOException
 {
  r.close();
 }
}
class MyLineNumberReaderDemo
{
 public static void main(String[]args)throws IOException
 {
  FileReader fr = new FileReader("demo.txt");
  MyLineNumberReader mylnr = new MyLineNumberReader(fr);
  String line = null;
  while ((line=mylhr.myReadLine())!=null)
  {
   System.out.println(my.getLineNumber()+":"+line);
  }
  mylnr.myClose();
 }
}

字节流:写入流:OutputStream 读取流:InputStream
操作文件:
import java.io.*;
class FileStreamDemo
{
 public static void main(String[]args)throws IOException
 {
 }
 public static void writeStream()throws IOException字节流写入方法无需刷新操作
 {
  FileOutputStream fos = new FileOutputStream("demo.txt");
  fos.write("avljfgri".getByte());
  fos.close();
 }
 public static void readStream_1()throws IOException
 {
  FileInputStream fis = new FileInputStream("demo.tzt");
  int ch = 0;
  while((ch=fls.read())!=-1)
  {
   System.out.println((char)ch);
  }
  fls.close();
 }
 public static void readStream_2()throws IOException
 {
  FileInputStream fls = new FileInputStream("demo.txt");
  byte[] by = new byte[1024];
  int len = 0;
  while ((len=fls.read(by))!=-1)
  {
   System.out.println(new String(by,0,len));
  }
  fls.close();
 }
 public static void readStream_3()throws IOException 字节流特有读取方法,有局限性数据不大时可用
 {
  FileInputStream fls = new FileInputStream("demo.txt");
  byte[]by = new byte[fls.available()];读取出文件内字节长度
  fls.read(by);
  System.out.println(new String(by));
  fls.close();
 }
}

复制图片
思路:
1,字节读取流关联对象 2,字节输入流创建对象存储数据 3,循环写入 4,关闭资源
import java.io.*;
class Demo
{
 public static void main(String[]args)throws IOException
 {
  FileInputStream fis = new FileInputStream("ppq.jpg");
  FileOutputStream fos = new FileOutputStream("copyppq.jpg");
  byte[]by =new byte[1024];
  int ch = 0;
  while ((ch=fis.read(by))!=-1)
  {
   fos.write(by,0,ch);
  }
  fis.close();
  fos.close();
  
 }
}

通过缓冲区复制MP3文件:
import java.io.*;
class Demo
{
 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
 {
  BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("demo.mp3"));
  BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("demo_1.mp3"));
  int by = 0;
  while ((by=bufis.read())!=-1)
  {
   bufos.write(by);
  }
  bufos.close();
  bufis.close();
 }
}
自定义字节流缓冲区:
import java.io.*;
class MyBufferedInputStream
{
 private InputStream in;
 private byte[]buf = new byte[1024];
 private int pos = 0,count = 0;
 MyBufferedInputStream(InputStream in)
 {
  this.in=in;
 }
 public int myRead()throws IOException
 {
  if(count==0)当字节数组内元素都取完后再存入
  {
   count=in.read(buf);
   if(count<0)
    return -1;
   pos=0;
   byte b=buf[pos];
   count--;
   pos++;
   return b&255;
  }
  else if(count>0)内部有数据继续取出
  {
   byte b = buf[pos];
   count--;
   pos++;
   return b&255;
  }
  return -1;
 }
 public void myClose()throws IOException
 {
  in.close();
 }
}
键盘录入数据录入一行打印一行 录入over停止录入
import java.io.*;
class Demo
{
 public static void main(String[]args)throws IOException
 {
  InputStream in = System.in;
  StringBuilder sb =new StringBuilder();
  while (true)
  {
   int ch = in.read();
   if(ch=='\r')
    continue;
   if(ch=='\n')
   {
    String s = sb.toString();
    if("over".equals(s))
     break;
    System.out.println(s.toUpperCase());
    sb.delete(0,sb.length());
   }
   else
    sb.append((char)ch);
  }
 }
}
将字节流转成字符流使用字符流readLine方法,
import java.io.*;
class TransStreamDemo
{
 public static void main(String[]args)
 {
  简写:
  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
  
  InputStream in = System.in;获取键盘录入对象
  InputStreamReader isr = new InputStreamReader(in);将字节流对象转成字符流对象,使用转换流InputStreamReader
  BufferedReader bufr = new BufferedReader(isr);提高效率进行缓冲技术处理BufferedReader
  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();
  }
  bufr.close();
  bufw.close();
 }
}

流操作的基本规律:
1,明确源和目的.
 源:输入流 InputStream Reader
 目的:输出流 OutputStream Writer
2,操作的数据是否为纯文本
 是:字符流操作
 不是:字节流操作
3,体系明确后再明确具体使用对象
 通过设备进行区分
 源设备:内存,硬盘,键盘
 目的设备:内存,硬盘,控制台

实习1,将一个文本文件中数据存储到另一个文件中,复制文件

源:因为是源采用读取流InputStream Reader
操作对象为文本对象采用Reader
设备为硬盘上一个文件,Reader体系中操作文件对象的是FileReader
为提高效率应用Reader体系中缓冲区BufferedReader
FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);

目的:OutputStream Writer
操作对象为纯文本选用Writer,设备为硬盘内文件选用Writer体系中操作文件对象的FileWriter
为提高效率应用Writer体系缓冲区BufferedWriter
FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);

实习2，将键盘录入的数据保存到一个文件中

源:InputStream Reader纯文本选用Reader
设备为键盘,对应System.in需要将其利用InputStreamReader方法由InputStream方法转化为Reader方法
提高效率应用BufferedReader
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader bufr = new BufferedReader(isr);

目的:OutputStream Writer 纯文本选用Writer
设备为硬盘,一个文件选用FileWriter,提高效率应用BufferedWriter
FileWriter fw = new FileWriter("a.txt");
BufferedWriter bufw = new BufferedWriter(fw);
扩展:
当录入操作需要指定编码表时.纯文本操作选用Writer,但是指定编码表只有转换流可以指定
转换流需要接收一个操作文件的字节输出流即FileOutputStream
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8");
提高效率
BufferedWriter bufw = new BufferedWriter(osw);
注意:转换流什么时候使用,他为字符流与字节流之间的桥梁,当涉及到字符编码转换时会用到

import java.io.*;
class TransStreamDemo
{
 public static void main(String[]args)
 {
  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter("a.txt"));
  String line = null;
  while ((line=bufr.readLine())!=null)
  {
   if("over".equals(line))
    break;
   bufw.write(line.toUpperCase());
   bufw.newLine();
   bufw.flush();
  }
  bufr.close();
  bufw.close();
 }
}
System.setIn("a.txt");改键盘输入为a.txt System.setOut("z.txt");改控制台输出为z.txt 设置改变输入输出设备

异常日志信息:
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
 public static void main(String[]args)
 {
  try
  {
   int[]arr=new int[3];
   System.out.println(arr[3]);
  }
  catch (Exception e)
  {
   try
   {
    Date d = new Date();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String s = sdf.format(d);
    PrintStream ps = new PrintStream("Exception.log");
    ps.println(s);
    System.setOut(ps);
   }
   catch (IOException ex)
   {
    throw new RuntimeException("日志文件创建失败");
   }
   e.printStackTrace(System.out);
  }
 }
}

log4j网上专门提供的异常记录工具

系统信息显示:
import java.io.*;
import java.util.*;
class SystemInfo
{
 public static void main(String[]args)
 {
  Properties prop = System.getProperties();
  prop.list(new PrintStream("sysinfo.txt"));系统信息打印在指定文件
 }
}