java基础---IO(一)

1，io流用来处理数据之间的传输

2，java对数据的操作是通过流的方式；

3，java用于操作流的对象都在io包中；

4，流按操作数据分为两种：字节流和字符流；

5，流按流向分为：输入流和输出流。

注意：流只能操作数据，而不能操作文件。

3、IO流的常用基类：

        1）字节流的抽象基流：InputStream和OutputStream

        2）字符流的抽象基流：Reader和Writer

注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream；Reader子类FileReader

一、字符流：

 1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。

 2、字符流只用于处理文字数据，而字节流可以处理媒体数据。

 3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。

字符流继承体系图：

1、写入字符流步骤

        a、创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。

        b、调用write(String s)方法，将字符串写入到流中。

        c、调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。

        d、调用close()方法，关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。

close()和flush()区别：

        flush()刷新后，流可以继续使用；

       而close()刷新后，将会关闭流，不可再写入字符流。

1、FileReader:

读取一个本地文件，并打印到控制台

import java.io.*;class FileReaderDemo2 {public static void main(String[] args) throws IOException{FileReader fr = new FileReader("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();}}

2、FileWriter：

在本地创建一个文件，并写入内容

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

对已有文件进行续写

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

注意：

        1、定义文件路径时，可以用“/”或者“\\”。

        2、在创建一个文件时，如果目录下有同名文件将被覆盖。

        3、在读取文件时，必须保证该文件已存在，否则出异常。

字符流的缓冲区——BufferedReader和BufferedWriter

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

读取流缓冲区BufferedReader：
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

步骤:

        1）创建一个读取流对象和文件相关联

        如： FileReader fr=newFileReader("buf.txt");

        2）为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。

        如： BufferedReader bufr=new BufferedReader(fr);

        3）调用该缓冲区提供的readLine方法一行一行读取,如果到达文件末尾，则返回null

        如： String s=bufr.readLine();

        4）关闭流资源

        如： bufr.close();、

写入流缓冲区BufferedWriter:

步骤:

 1）创建一个字符写入流对象。

         如：FileWriter fw=newFileWriter("buf.txt");

         2）为了提高字符写入流效率。加入缓冲技术。只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

         如： BufferedWriter bufw =new BufferedWriter(fw);

         3）调用write方法写入数据到指定文件

         如：bufw.write("adfg");

         记住，只要用到缓冲区，就要记得刷新。（关闭流同样会刷新，但为了排除意外事故，保证数据存在，建议写入一次就刷新一次）

         如：bufw.flush();

         4）其实关闭缓冲区，就是在关闭缓冲区中的流对象。

应用:通过缓冲区复制一个文件

import java.io.*;class  CopyTextByBuf{public static void main(String[] args) {BufferedReader bufr = null;BufferedWriter bufw = null;try{bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.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("写入关闭失败");}}}}

自定义BufferedReader：

原理：

        可根据BufferedReader类中特有一行一行读取方法readLine()的原理，自定义一个类中包含相同功能的方法

步骤：

        a、初始化自定义的类，加入流对象。

        b、定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。

import java.io.*;class MyBufferedReader extends Reader{private Reader r;MyBufferedReader(Reader 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();elsesb.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();}public void myClose()throws IOException{r.close();}}class  MyBufferedReaderDemo{public static void main(String[] args) throws IOException{FileReader fr = new FileReader("buf.txt");MyBufferedReader myBuf = new MyBufferedReader(fr);String line = null;while((line=myBuf.myReadLine())!=null){System.out.println(line);}myBuf.myClose();}}

二、字节流

1、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。

2、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。

3、读写字节流：InputStream   输入流（读）

                          OutputStream  输出流（写）

字节流体系图:

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

import java.io.*;class  CopyPic{public static void main(String[] args) {FileOutputStream fos = null;FileInputStream fis = null;try{fos = new FileOutputStream("c:\\2.bmp");fis = new FileInputStream("c:\\1.bmp");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{try{if(fis!=null)fis.close();}catch (IOException e){throw new RuntimeException("读取关闭失败");}try{if(fos!=null)fos.close();}catch (IOException e){throw new RuntimeException("写入关闭失败");}}}}

字节流缓冲区：

1、读写特点：

        read()：会将字节byte型值提升为int型值

        write()：会将int型强转为byte型，即保留二进制数的最后八位。

2、原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。

        1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区。

        2）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。

        3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。

        4）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到0即元素取完。

        5）当文件中的全部数据都被读取出时，read()方法就返回-1。

应用：拷贝mp3文件

import java.io.*;class  CopyMp3{public static void main(String[] args) throws IOException{long start = System.currentTimeMillis();copy_2();long end = System.currentTimeMillis();System.out.println((end-start)+"毫秒");}public static void copy_2()throws IOException{MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\\9.mp3"));BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\3.mp3"));int by = 0;//System.out.println("第一个字节:"+bufis.myRead());while((by=bufis.myRead())!=-1){bufos.write(by);}bufos.close();bufis.myClose();}//通过字节流的缓冲区完成复制。public static void copy_1()throws IOException{BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));int by = 0;while((by=bufis.read())!=-1){bufos.write(by);}bufos.close();bufis.close();}}

自定义字节缓冲区:

注意：

        1、字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。

       因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。

       所以，为了避免这种情况将读到的字节进行int类型的提升。并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。而在写入数据时，只写该int类型数据的最低8位。

        2、byte类型的-1提升为int类型时还是-1。原因：因为在bit8个1前面补的全是1导致的。如果在bit8个1前面补0，即可以保留原字节数据不变，又可以避免-1的出现。这时将byte型数据&0xff即255即可。

import java.io.*;class MyBufferedInputStream{private InputStream in;private byte[] buf = new byte[1024*4];private int pos = 0,count = 0;MyBufferedInputStream(InputStream in){this.in = in;}//一次读一个字节，从缓冲区(字节数组)获取。public int myRead()throws IOException{//通过in对象读取硬盘上数据，并存储buf中。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&0xff;}return -1;}public void myClose()throws IOException{in.close();}}

键盘录入：

1,
源：键盘录入。
目的：控制台。
2，需求：想把键盘录入的数据存储到一个文件中。
源：键盘。
目的：文件。
3，需求：想要将一个文件的数据打印在控制台上。
源：文件。
目的：控制台。

流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪一个。

通过三个明确来完成。

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);

class  TransStreamDemo2{public static void main(String[] args) throws IOException{System.setIn(new FileInputStream("PersonDemo.java"));System.setOut(new PrintStream("zzz.txt"));//键盘的最常见写法。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();}}