Java笔记（六）

IO流：

字符流和字节流：

字符流两个基类： InputStream OutputStream

字节流两个基类： Reader Writer

FileWriter:

 import java.io.FileWriter;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException {
         //创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件
         //而且该文件被创建到指定目录下，如果该目录下已有同名文件，将被覆盖
         //该步就是在明确数据要存放的目的地
         FileWriter fw = new FileWriter("F:\\demo.txt");

         //调用write方法，将字符串写入到流中
         fw.write("abcde");

         //刷新流对象中的缓冲区数据
         //将数据刷到目的地中
         fw.flush();

         //关闭流资源，但是关闭之前会刷新一次内部的缓冲区数据
         //将数据刷到目的地中
         //和flush区别：flush刷新后，流可以继续使用；close刷新后，会将流关闭
         fw.close();
     }
 }

IO异常处理方式：

 import java.io.FileWriter;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) {
         FileWriter fw = null;
         try{
             fw = new FileWriter("F:\\demo.txt");
             fw.write("abcdefg");
         }catch(IOException e){
             System.out.println(e.toString());
         }finally{
             if(fw != null){
                 try{
                     fw.close();
                 }catch(IOException e){
                     System.out.println(e.toString());
                 }
             }
         }
     }
 }

文件的续写：

 import java.io.FileWriter;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException {
         //传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写
         FileWriter fw = new FileWriter("F:\\demo.txt", true);
         fw.write("haha");
         fw.close();
     }
 }

文件的读取方式（一）：

 import java.io.FileReader;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException {
         //创建一个文件读取流对象，和指定名称的文件相关联
         //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
         FileReader fr = new FileReader("F:\\demo.txt");

         //调用读取流对象的read方法
         //read():一次读一个字符，而且会自动往下读
         int ch = 0;
         while((ch = fr.read()) != -1){
             System.out.print((char)ch);
         }
     }
 }

文件的读取方式（二）：

 import java.io.FileReader;
 import java.io.IOException;

 public class Demo{
     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();
     }
 }

复制文件：

 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args){
         copy();
     }
     public static void copy(){
         FileReader fr = null;
         FileWriter fw = null;
         try{
             fr = new FileReader("F:\\demo.txt");
             fw = new FileWriter("F:\\demo_copy.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){
                     System.out.println(e.toString());
                 }
             }
             if(fw != null){
                 try{
                     fw.close();
                 }catch(IOException e){
                     System.out.println(e.toString());
                 }
             }
         }
     }
 }

BufferedWriter：

缓冲区的出现是为了提高流的操作效率而出现的，所以在创建缓冲区前，必须要先有流对象。

 import java.io.BufferedWriter;
 import java.io.FileWriter;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException {
         //创建一个字符写入流对象
         FileWriter fw = new FileWriter("F:\\demo.txt");

         //为了提高字符写入流效率，加入缓冲技术
         //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
         BufferedWriter bufw = new BufferedWriter(fw);
         for(int i = 0; i < 5; i++){
             bufw.write("abcd" + i);
             bufw.newLine();  //等同于bufw.write("\r\n");且跨平台
             bufw.flush();
         }

         //关闭缓冲区，就是在关闭缓冲区中的流对象
         bufw.close();
     }
 }

BufferedReader：

该缓冲区提供了一个一次读一行的方法readLine，方便用于对文本数据的获取。当返回null时，表示读到文件的末尾。

 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException {
         //创建一个读取流对象和文件相关联
         FileReader fr = new FileReader("F:\\demo.txt");

         //为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数
         BufferedReader bufr = new BufferedReader(fr);

         String line = null;
         while((line = bufr.readLine()) != null){
             System.out.println(line);
         }
         bufr.close();
     }
 }

通过缓冲区复制一个文件：

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) {
         BufferedReader bufr = null;
         BufferedWriter bufw = null;
         try{
             bufr = new BufferedReader(new FileReader("F:\\demo.txt"));
             bufw = new BufferedWriter(new FileWriter("F:\\demo_copy.txt"));
             String line = null;
             while((line = bufr.readLine()) != null){
                 bufw.write(line);
                 bufw.newLine();
                 bufw.flush();
             }
         }catch(IOException e){
             throw new RuntimeException("读写失败");
         }finally{
             if(bufr != null){
                 try{
                     bufr.close();
                 }catch(IOException e){
                     throw new RuntimeException("读取关闭失败");
                 }
             }
             if(bufw != null){
                 try{
                     bufw.close();
                 }catch(IOException e){
                     throw new RuntimeException("写入关闭失败");
                 }
             }
         }
     }
 }

模拟BufferedReader：

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;

 class MyBufferedReader{
     private FileReader f;
     MyBufferedReader(FileReader f){
         this.f = f;
     }
     public String myReadLine() throws IOException{
         StringBuilder sb = new StringBuilder();
         int ch = 0;
         while((ch = f.read()) != -1){
             if(ch == '\r')
                 continue;
             else 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{
         f.close();
     }
 }

 public class Demo{
     public static void main(String[] args) throws IOException {
         MyBufferedReader mybuf = new MyBufferedReader(new FileReader("F:\\demo.txt"));
         String line = null;
         while((line = mybuf.myReadLine()) != null){
             System.out.println(line);
         }
         mybuf.myClose();
     }
 }

LineNumberReader：

 import java.io.FileReader;
 import java.io.IOException;
 import java.io.LineNumberReader;

 public class Demo{
     public static void main(String[] args) throws IOException {
         FileReader fr = new FileReader("F:\\demo.txt");
         LineNumberReader num = new LineNumberReader(fr);
         num.setLineNumber(100);
         String line = null;
         while((line = num.readLine()) != null){
             System.out.println(num.getLineNumber() + ": " + line);
         }
         num.close();
     }
 }

输出结果：

101: abcd0
102: abcd1
103: abcd2
104: abcd3
105: abcd4

模拟LineNumberReader：

 import java.io.FileReader;
 import java.io.IOException;
 import java.io.Reader;

 class MyBufferedReader{
     private FileReader f;
     MyBufferedReader(FileReader f){
         this.f = f;
     }
     public String myReadLine() throws IOException{
         StringBuilder sb = new StringBuilder();
         int ch = 0;
         while((ch = f.read()) != -1){
             if(ch == '\r')
                 continue;
             else 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{
         f.close();
     }
 }

 class MyLineNumberReader extends MyBufferedReader{
     private int lineNum;
     MyLineNumberReader(FileReader r) {
         super(r);
     }
     public String myReadLine() throws IOException{
         lineNum++;
         return super.myReadLine();
     }
     public void setLineNumber(int lineNum){
         this.lineNum = lineNum;
     }
     public int getLineNumber(){
         return lineNum;
     }
 }

 public class Demo{
     public static void main(String[] args) throws IOException {
         MyLineNumberReader myline = new MyLineNumberReader(new FileReader("F:\\demo.txt"));
         String line = null;
         myline.setLineNumber(100);
         while((line = myline.myReadLine()) != null){
             System.out.println(myline.getLineNumber() + ": " + line);
         }
         myline.myClose();
     }
 }

字节流读写操作：

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException{
         readFile_03();
     }
     public static void writeFile() throws IOException{
         FileOutputStream f = new FileOutputStream("F:\\demo.txt");
         f.write("ztq".getBytes());
         //不需要刷新
         f.close();
     }
     public static void readFile_01() throws IOException{
         FileInputStream f = new FileInputStream("F:\\demo.txt");
         int ch = 0;
         while((ch = f.read()) != -1){
             System.out.print((char)ch);
         }
         f.close();
     }
     public static void readFile_02() throws IOException{
         FileInputStream f = new FileInputStream("F:\\demo.txt");
         byte[] buf = new byte[1024];
         int len = 0;
         while((len = f.read(buf)) != -1){
             System.out.println(new String(buf, 0, len));
         }
         f.close();
     }
     //字节流特有的读文件方法
     public static void readFile_03() throws IOException{
         FileInputStream f = new FileInputStream("F:\\demo.txt");

         //定义一个大小刚好的数组，不用循环
         byte[] buf = new byte[f.available()];
         f.read(buf);
         System.out.println(new String(buf));
     }
 }

复制一个图片：

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException{
         FileInputStream fis = null;
         FileOutputStream fos = null;
         try{
             fis = new FileInputStream("F:\\pic.jpg");
             fos = new FileOutputStream("F:\\pic_copy.jpg");
             byte[] buf = new byte[1024];
             int len = 0;
             while((len = fis.read(buf)) != -1){
                 fos.write(buf, 0, len);
             }
         }catch(IOException e){
             throw new RuntimeException("复制文件失败");
         }finally{
             if(fis != null){
                 try{
                     fis.close();
                 }catch(IOException e){
                     throw new RuntimeException("读取流关闭失败");
                 }
             }
             if(fos != null){
                 try{
                     fos.close();
                 }catch(IOException e){
                     throw new RuntimeException("写入流关闭失败");
                 }
             }
         }
     }
 }

字节流的缓冲区：

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException{
         BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("F:\\pic.jpg"));
         BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("F:\\pic_copy.jpg"));
         int ch = 0;
         while((ch = bufis.read()) != -1){
             bufos.write(ch);
         }
         bufis.close();
         bufos.close();
     }
 }

模拟字节流的缓冲区：

注：11111111提升到int型还是-1，因为在8个1的前面补的全是1。要是在前面补0，既可以保留原字节数据不变，又可以避免-1的出现。

11111111 11111111 11111111 11111111  &

00000000 00000000 00000000 11111111

 import java.io.BufferedOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;

 class MyBufferedInputStream{
     private InputStream in;
     private int count = 0, pos = 0;
     private byte[] buf = new byte[1024];
     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 & 0xff;
         }
         else if(count > 0){
             byte b = buf[pos];
             count--;
             pos++;
             return b & 0xff;
         }
         return -1;
     }
     public void myClose() throws IOException{
         in.close();
     }
 }

 public class Demo{
     public static void main(String[] args) throws IOException{
         MyBufferedInputStream mybfis = new MyBufferedInputStream(new FileInputStream("F:\\pic.jpg"));
         BufferedOutputStream bfos = new BufferedOutputStream(new FileOutputStream("F:\\pic_copy.jpg"));
         int ch = 0;
         while((ch = mybfis.myRead()) != -1){
             bfos.write(ch);
         }
         mybfis.myClose();
         bfos.close();
     }
 }

读取键盘录入：

通过键盘录入数据，当录入一行数据后，就将该行数据进行打印。如果录入的数据是over，那么停止录入。

 import java.io.IOException;
 import java.io.InputStream;

 public 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;
             else if(ch == '\n'){
                 String s = sb.toString();
                 if("over".equals(s))
                     break;
                 System.out.println(s);
                 sb.delete(0, sb.length());
             }
             else{
                 sb.append((char)ch);
             }
         }
     }
 }

读取转换流：

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;

 public class Demo{
     public static void main(String[] args) throws IOException{
         //获取键盘录入对象
         InputStream in = System.in;

         //将字节流对象转成字符流对象，使用转换流。InputStreamReader
         InputStreamReader isr = new InputStreamReader(in);

         //为了提高效率，将字符串进行缓冲区技术高效操作。BufferedReader
         BufferedReader bufr = new BufferedReader(isr);

         String line = null;
         while((line = bufr.readLine()) != null){
             if("over".equals(line)) break;
             System.out.println(line.toUpperCase());
         }
         bufr.close();
     }
 }

写入转换流：

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;

 public class Demo{
     public static void main(String[] args) throws IOException{
         //键盘录入常见写法
         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
         BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

         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.（1）明确源和目的

　　源：输入流。InputStream  Reader

　　目的：输出流。 OutputStream Writer

（2）操作的数据是否是纯文本

　　是：字符流。

　　否：字节流。

（3）当体系明确后，再明确要是用哪个具体的对象。通过设备来进行区分。

　　源设备：内存、硬盘、键盘

　　目的设备：内存、硬盘、控制台

通常涉及到字符编码转换时，需要用到转换流。

异常的日志信息：

 import java.io.IOException;
 import java.io.PrintStream;
 import java.text.SimpleDateFormat;
 import java.util.Date;

 public class Demo{
     public static void main(String[] args){
         try{
             int[] arr = new int[2];
             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("F:\\exception.log");
                 ps.println(s);
                 System.setOut(ps);
             }catch(IOException ex){
                 throw new RuntimeException("日志文件创建失败");
             }
             e.printStackTrace(System.out);
         }
     }
 }

将系统信息存储到文件中：

 import java.io.IOException;
 import java.io.PrintStream;
 import java.util.Properties;

 public class Demo{
     public static void main(String[] args) throws IOException{
         Properties pro = System.getProperties();
         pro.list(new PrintStream("F:\\properties.txt"));
     }
 }