IO流

IO流用来处理设备之间的数据传输，Java对数据的操作时通过流的方式

Java用于流的对象都包括在IO包中，流按操作流数据分为两种：字节流与字符流，按流向分为：输入流，输出流

字节流的抽象基类：

InputStream ,OutputStream

字节流的抽象基类：

Reader, Writer

由这四个类派生出来的子类名称都是以其父类名做为子类名的后缀，例如：InputStream的子类FileInputStream

package cn.baidu.com;import java.io.*;public class FileWriterDemo {public static void main(String[] args) throws IOException{// TODO Auto-generated method stub//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。//而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖//其实该步骤就是在明确要存放的目的地。FileWriter fw=new FileWriter("F:\\Demo.txt");//调用write方法，将字符串写入到流中fw.write("nidaye de");//刷新流对象中的缓冲中的数据//将数据刷到目的地中//fw.flush();//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据//将数据刷到目的地中//和flush的区别:flush刷新后，流可以继续使用，close刷新后，流会关闭fw.close();}}

IO 异常的处理方式

package cn.baidu.com;import java.io.*;public class FileWriterDemo2 {public static void main(String[] args) {FileWriter fw=null;try{fw=new FileWriter("F:\\Demo.txt");fw.write("sdafda");fw.close();}catch(IOException e){System.out.println("catch"+e.toString());}finally{try{if(fw!=null)fw.close();}catch(IOException e){System.out.println("catch"+e.toString());}}}}

在已有数据文件中续写：在文件中追加数据

package cn.baidu.com;import java.io.*;public class FileWriterDemo3 {public static void main(String[] args) {//传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行续写FileWriter fw=null;try{fw=new FileWriter("F:\\Demo.txt",true);fw.write("sdafda\r\nsdfs");}catch(IOException e){System.out.println("catch"+e.toString());}finally{try{if(fw!=null)fw.close();}catch(IOException e){System.out.println("catch"+e.toString());}}}}

读取文件

读取方式一：

package cn.baidu.com;import java.io.*;public class FileReaderDemo {public static void main(String[] args) {//创建一个文件读取流对象，和指定的名称相关联。//要保证该文件时已经存在的，如果不存在，会发生异常FileNotFoundExceptionFileReader fr=null;try {fr= new FileReader("F:\\Demow.txt");} catch (FileNotFoundException e) {try {//调用读取流对象的read()方法//read() 一次读取一个字符，而且会自动往下读。int ch=0;while((ch=fr.read())!=-1){System.out.println((char)ch);}} catch (IOException e1) {e1.printStackTrace();}}finally{try {fr.close();} catch (IOException e) {e.printStackTrace();}}}}

读取文件方式二：通过字符数组读取

package cn.baidu.com;import java.io.*;public class FileReaderDemo2 {public static void main(String[] args) throws IOException{FileReader fr=new FileReader("F:\\Demo.txt");//定义一个字符数组，用于存储读到的字符//该read(char[]) 返回的是读到的字符个数char[] buf=new char[1024];int num =0;while((num =fr.read(buf))!=-1){System.out.println(new String(buf,0,num));}fr.close();}}

读取一个JAVA文件，并显示在控制台上

package cn.baidu.com;import java.io.*;public class FileReaderDemo2 {public static void main(String[] args) throws IOException{FileReader fr=new FileReader("F:\\Demo.txt");//定义一个字符数组，用于存储读到的字符//该read(char[]) 返回的是读到的字符个数char[] buf=new char[1024];int num =0;while((num =fr.read(buf))!=-1){System.out.println(new String(buf,0,num));}fr.close();}}

文件的复制

package cn.baidu.com;import java.io.*;public class CopyText {public static void main(String[] args) throws IOException {copy_2();}public static void copy_1() throws IOException{//创建文件FileWriter fw=new FileWriter("F:\\Demoq.txt");//与已有文件关联FileReader fr=new FileReader("F:\\Demo.txt");int ch=0;while((ch=fr.read())!=-1){fw.write(ch);}fw.close();fr.close();}public static void copy_2() throws IOException{FileWriter fw=null;FileReader fr=null;try{fw=new FileWriter("F:\\Demos.txt");fr=new FileReader("F:\\Demo.txt");char[] buf =new char[1024];int len=0;while((len=fr.read(buf))!=-1){fw.write(buf, 0, len);}}catch(IOException e){throw new RuntimeException("读写失败");}finally{if(fr!=null){try{fr.close();}catch(IOException e){}finally{}}if(fw!=null){try{fw.close();}catch(IOException e){}}}}}

图片的复制

package cn.baidu.com;import java.io.*;public class CopyText {public static void main(String[] args) throws IOException {copy_2();}public static void copy_1() throws IOException{//创建文件FileWriter fw=new FileWriter("F:\\Demoq.txt");//与已有文件关联FileReader fr=new FileReader("F:\\Demo.txt");int ch=0;while((ch=fr.read())!=-1){fw.write(ch);}fw.close();fr.close();}public static void copy_2() throws IOException{FileWriter fw=null;FileReader fr=null;try{fw=new FileWriter("F:\\Demos.txt");fr=new FileReader("F:\\Demo.txt");char[] buf =new char[1024];int len=0;while((len=fr.read(buf))!=-1){fw.write(buf, 0, len);}}catch(IOException e){throw new RuntimeException("读写失败");}finally{if(fr!=null){try{fr.close();}catch(IOException e){}finally{}}if(fw!=null){try{fw.close();}catch(IOException e){}}}}}

字符流的缓冲区

对应类：BufferedWriter BufferedReader

缓冲区要结合流才可以使用，在流的基础上对流的基础进行了增强

package cn.baidu.com;import java.io.*;/* * 缓冲区的出现是为了提高流的操作效率而出现的。 * 所以在创建缓冲区之前，必须要先有流对象 * 该缓冲区中提供了一个跨平台的换行符 newLine() */public class BufferedWriterDemo {public static void main(String[] args) throws IOException {//创建一个字符写入流对象FileWriter fw=new FileWriter("F:\\Demow.txt");//为了提高字符写入流效率，加入了缓冲技术，只要将需要提高的流//对象传递给缓冲区的构造函数即可。BufferedWriter bufw=new BufferedWriter(fw);for(int x=1;x<5;x++){bufw.write("而卧对的撒sdfssfd"+x);//只要用到缓冲区，就要记得刷新bufw.newLine();bufw.flush();}//其实关闭缓冲区，就是在关闭缓冲区中的流对象bufw.close();}}

字符读取流缓冲区

package cn.baidu.com;import java.io.*;/* * 字符读取流缓冲区 * 该缓冲区提供了一个一次读一行的方法 readLine 方法于对文本数据的获取 * 当返回null，表示读到文件的末尾 * readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符 */public class BufferedReaderDemo {public static void main(String[] args) throws IOException {//创建一个读取流对象和文件相关联FileReader fr=new FileReader("F:\\Demo.txt");//为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数BufferedReader butr=new BufferedReader(fr);String line=null;while((line=butr.readLine())!=null){System.out.println(line);}butr.close();}}

通过缓冲区复制一个文件

package cn.baidu.com;/* * 通过缓冲区复制一个.java文件 */import java.io.*;public class CopyTextByBuf {public static void main(String[] args) {// TODO Auto-generated method stubBufferedReader bufr=null;BufferedWriter bufw=null;try{bufr=new BufferedReader(new FileReader("F:\\Demo.txt"));bufw=new BufferedWriter(new FileWriter("F:\\Demonew.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("写关闭失败");}}}}

自己写的MyBufferedReader

package cn.baidu.com;/* * 在明白了BufferedReader类中特有方法readLine类中特有方法readLinde的原理后 * 可以自定义一个类中包含一个功能和readLine一致的方法，来模拟一下bufferedReader */import java.io.*;class MyBufferedReader {private FileReader r;MyBufferedReader(FileReader r){this.r=r;}//可以一次读一行数据的方法public String myReadLine() throws IOException{//定义一个临时容器，原BufferedReader封装的是字符数组//为了演示方便，定义一个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;//到文件结尾，无数据了}public void myClose() throws IOException{r.close();}}public class MyBufferedReaderDemo {public static void main(String[] args) throws IOException {FileReader fr=new FileReader("F:\\Demo.txt");MyBufferedReader mybuf=new MyBufferedReader(fr);String line=null;while((line=mybuf.myReadLine())!=null){System.out.println(line);}mybuf.myClose();}}

装饰设计模式

/*
 * 装饰设计模式比继承更灵活，避免了继承体系的臃肿
 * 而且降低了类与类之间的关系
 * 
 * 装饰类因为增强已有对象，具备的功能和已有的是形同的，只不过提供了更强的功能
 * 所以装饰类和被装饰类都是属于一个体系中的。
 * 
 * 当想到要对已有的对象进行功能增强时。
 * 可以定义类，将已有对象传入，基于已有的功能，并提供加强功能
 * 那么自定义的该类称为装饰类
 * 
 * 装饰类通常会通过构造方法接收被装饰的对象
 * 并基于被装饰的对象提供更强的功能
 */

package cn.baidu.com;class Person{public void eat(){System.out.println("吃饭");}}class SuperPerson{private Person p;SuperPerson(Person p){this.p=p;}public void supereat(){System.out.println("开胃菜");System.out.println("喝红酒");p.eat();System.out.println("唱K");}}public class PersonDemo {public static void main(String[] args) { Person p=new Person(); SuperPerson sp=new SuperPerson(p); sp.supereat();}}

package cn.baidu.com;import java.io.*;public class LineNumberReaderDemo {public static void main(String[] args) throws IOException{FileReader fr=new FileReader("F:\\Demo.txt");LineNumberReader lnr=new LineNumberReader(fr);String line=null;lnr.setLineNumber(100);while((line=lnr.readLine())!=null){System.out.println(lnr.getLineNumber()+":"+line);}lnr.close();}}

在明白其原理后，自己写一个

MyLineNumberReader

package cn.baidu.com;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 String myReadLine() throws IOException{lineNumber++;StringBuilder sb=new StringBuilder();int ch=0;while((ch=r.read())!=-1){if(ch=='\r')continue;if(ch=='\n')return sb.toString();elsesb.append((char)ch);}if(sb.length()!=0)return sb.toString();return null;}public int getLineNumber(){return lineNumber;}public void myClose() throws IOException{r.close();}}*/class MyLineNumberReader extends MyBufferedReader{private Reader r;private int lineNumber;MyLineNumberReader(FileReader r){super(r);}public String myReadLine() throws IOException{lineNumber++;return super.myReadLine();}public int getLineNumber(){return lineNumber;}public void setLineNumber(int lineNumber){this.lineNumber=lineNumber;}}public class MyLineNumberReaderDemo {public static void main(String[] args) throws IOException {FileReader fr=new FileReader("F:\\Demo.txt");MyLineNumberReader mylnr=new MyLineNumberReader(fr);String line=null;mylnr.setLineNumber(100);//初始行号设置为100while((line=mylnr.myReadLine())!=null){System.out.println(mylnr.getLineNumber()+":"+line);}mylnr.myClose();}}

/*
 * 字符流
 * FileReader
 * FileWriter
 * BufferedReader
 * BufferedWriter
 * 
 * 字节流：
 * InputStream OutputStream
 * 需求：想要操作图片数据，这是就要用到字节流
 */

package cn.baidu.com;import java.io.*;public class FileOutStreamDemo {public static void main(String[] args) throws IOException {// TODO Auto-generated method stub//writeFile();readFile_2();}public static void readFile_3() throws IOException{FileInputStream fis=new FileInputStream("F:\\Demoaaaa.txt");byte[] buf=new byte[fis.available()];//定义一个刚刚好的缓冲区，不用再循环了fis.read(buf);System.out.println(new String(buf));fis.close();}public static void readFile_2() throws IOException{byte[] buf=new byte[1024];int len=0;FileInputStream fis=new FileInputStream("F:\\Demoaaaa.txt");while((len=fis.read(buf))!=-1){System.out.println(new String(buf,0,len));}}public static void readFile_1() throws IOException{FileInputStream fis=new FileInputStream("F:\\Demoaaaa.txt");int ch=0;while((ch=fis.read())!=-1){System.out.println((char)ch);}}public static void writeFile() throws IOException{FileOutputStream fos=new FileOutputStream("F:\\Demoaaaa.txt");fos.write("大哥，我想你".getBytes());fos.close();}}

/*
 * 复制一个图片
 * 思路：
 * 1.用字节流读取流对象和图片关联
 * 2.用字节写入流对象创建一个图片文件，用于存储获取的图片数据
 * 3.通过循环读写，完成数据的存储
 */

package cn.baidu.com;import java.io.*;public class CopyPic {public static void main(String[] args) {FileOutputStream fos=null;FileInputStream fis=null;try{fis =new FileInputStream("F:\\old.jpg");//读取目标文件fos =new FileOutputStream("F:\\new.jpg");//写入新文文件byte[] buf=new byte[1024];int len=0;while((len=fis.read(buf))!=-1){fos.write(buf,0,len);}}catch(Exception e){throw new RuntimeException("复制文件失败");}finally{try{if(fis!=null){fis.close();}}catch(Exception e){throw new RuntimeException("读取关闭失败失败");}try{if(fos!=null){fos.close();}}catch(Exception e){throw new RuntimeException("写入关闭失败失败");}}}}

------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------

 * 读取键盘录入
 * System.out对应的是标准输出流，控制台
 * 需求：
 * 通过键盘录入数据，就将该行数据进行打印
 * 如果录入的数据是over,那么停止录入

package cn.baidu.com;import java.io.*;public class Readin {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());}elsesb.append((char)ch);}}}

转换流

package cn.baidu.com;import java.io.*;public class TransStreamDemo {public static void main(String[] args) throws IOException {//获取键盘录入对象InputStream in=System.in;//将字节流对象转成了字符流对象，使用转换流。InputStreamReaderInputStreamReader isr=new InputStreamReader(in);//为了提高效率，将字符串进行缓冲区高效操作，使用BufferedReaderBufferedReader buff=new BufferedReader(isr);String line=null;while((line=buff.readLine())!=null){if("over".equals(line))break;System.out.println(line.toUpperCase());}buff.close();}}

package cn.baidu.com;import java.io.*;public class TransStreamDemo2 {public static void main(String[] args) throws IOException {//获取键盘录入对象//InputStream in=System.in;//将字节流对象转成了字符流对象，使用转换流。InputStreamReader//InputStreamReader isr=new InputStreamReader(in);//为了提高效率，将字符串进行缓冲区高效操作，使用BufferedReader//BufferedReader buff=new BufferedReader(isr);    //键盘录入最常见写法BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));//OutputStream out=System.out;//OutputStreamWriter osw =new OutputStreamWriter(out);//BufferedWriter bufw=new BufferedWriter(osw);BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));String line=null;while((line=buff.readLine())!=null){if("over".equals(line))break;bufw.write(line.toUpperCase());bufw.newLine();bufw.flush();}buff.close();}}

/*
 * 1.需求：想把键盘录入的数据存储到一个文件中。
 * 源：键盘
 * 目的：文件
 * 2.需求：想要将一个文件的数据打印在控制台上
 * 源：文件
 * 目的：控制台
 * 
 * 流操作的基本规律
 * 通过两个明确来完成
 * 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体系中可以操作文件的对象FileWriter
 * 
 * FileWriter fr=new FileWriter("b.txt");
 * BufferedWriter bufw =new BufferedWriter(fw);
 * 
 * 
 * 
 * 2.需求：将键盘录入的数据保存到一个文件中
 * 源 ：InputStream Reader
 * 是不是纯文本 是 Reader 
 * 设备：键盘，对应的对象时System.in
 * 为了操作键盘文本数据方便，转成字符串操作是最方便的
 * 用了Reader体系中转换流，InputStreamReader
 * 
 * InputStreamReader isr=new InputStreamReader(System.in);
 * 提高效率 BufferedReader
 * BufferedReader buff=new BufferedReader(isr);
 * 
 * 目的: OutputStream Writer
 * 是否是纯文本  是 Writer
 * 设备： 硬盘  一个文件 使用FileWriter
 * 
 * 存储时，需要加入指定编码表，而指定的编码表只有转换流可以指定
 * 所以要使用的对象时OutputStreamWriter
 * 而该转换流对象要接收一个字节输出流，而且还可以操作的文件的字节输出流，FileOutputStream
 * OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
 * 
 * 考虑效率
 * BufferedWriter bufw =new BufferedWrier(osw);
 * 转换流怎么使用，字符和字节之间的桥梁，通常，涉及到字符编码转换时，需要用到转换流
 * 
 * 
 *FileWriter fw=new FileWriter("c.txt");
 *效率    BufferedWriter
 *BufferedWriter bufw=new BufferedWriter(fw);
 *

package cn.baidu.com;import java.io.*;public class TransStreamDemo3 {public static void main(String[] args) throws IOException {    //键盘录入最常见写法BufferedReader buff=new BufferedReader(new InputStreamReader(System.in));BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:\\out.txt")));String line=null;while((line=buff.readLine())!=null){if("over".equals(line))break;bufw.write(line.toUpperCase());bufw.newLine();bufw.flush();}buff.close();}}

建立日志文件，写入程序运行信息

package cn.baidu.com;import java.io.*;import java.text.SimpleDateFormat;import java.util.*;public class ExceptionInfo {public static void main(String[] args) throws IOException {Properties Prop=System.getProperties();Prop.list(new PrintStream("F:\\sysinfo.txt"));//把系统信息写入到日志文件中try{int[] arr=new int[2];System.out.println(arr[3]);}catch(Exception e){try{Date d=new Date();SimpleDateFormat sdf=new SimpleDateFormat("yy-MM-dd HH-mm-ss");String s=sdf.format(d);PrintStream ps=new PrintStream("F:\\exeception.log");ps.print(s);System.setOut(ps);}catch(IOException ex){throw new RuntimeException("日志文件创建失败");}e.printStackTrace(System.out);}}}