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[
4000
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"));系统信息打印在指定文件

 }

}