黑马学习日记_IO篇（第一部分）

---------------------- android开发、java培训、期待与您交流！ ----------------------

 

IO:主要用来处理设备之间的数据传输(如硬盘上的文件，内存中的数据)，java对数据的操作是通过流的方式，

java操作流的对象存在IO包中，流按数据分为两种，字节流和字符流。

 字符流的数据字节流其实都能处理，因为无论什么在计算机上最后都是以字节存在的，但是其中有一部

 分数据它是以文本形式存在的，所以为了方便有了字符流，字符流里融合了编码表，而只有文字用到了

 编码表，所以字符流用来处理文本形式的数据。

 

按方向分的话有输入流和输出流之分。

字符流：              字节流：

 Writer   Reader    InputStream  OutputStream 

这四个基类的子类名称都是以父类的名称为后缀，如FileReader,FileInputStream,

在写有关IO流程序的时候，首先要注意：

 1.要注意一定要记得导包，import java.Io.*;

 2.记得要进行异常处理，和IO流有关的都会抛异常，原因：例如FileWrite("C:\\abc.txt");

   因为括号里的文件名会有可能出错，比如写成(K:\\abc.txt)

 3.最后一定要进行关闭流的操作。因为它底层调用的其实是window资源，所以要关闭。

 

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

 

下面是IO异常处理方式：

例如;

 

FileWriter fw = null；//2.所以一般在外面定义引用在try内初始化，这样fw就作用于整个程序中，
 try
 {
  //1.因为会抛异常所以要进行try处理，但是如过把下面这句放在try代码块里面定义fw，那么
  //在别的代码块里会访问不到(比如finaly里关流的时候)
     //FileWriter fw = new FileWriter(c:\\abc.txt); 
    fw = new FileWriter(c:\\abc.txt); // 代码1
  fw.Write("abcdef");  //代码2
 }
 catch(IOException e)，
 {
  //异常处理
 }
 finaly
 {
  try
  {//一定要对关闭的流对象进行判断是否为空
   if(fw != null)//写这句的原因：因为如果“代码1”处出现异常被处理了，那么代码里面fw里面也就
       //没有被写进东西，所以fw为空。
    fw.close();//如果为空的话则不能调用这句，所以要进行下是否为空判断
  }
  catch(IOException e)，
  {
   //异常处理
  }
 }

  

 

字符流：writer(写)

 根据以往经验，要想了解一个体系，是不是都要先从最顶端的开始了解啊？字符流写的方法最顶端的

 父类就是writer，它里面有append(),close(), write() 等方法，可以知道它的子类中肯定也都具有

 这些功能。既然是字符流，那么它操作的最基本数据就是字符， FileWriter 里的主力方法就是write

 方法，就是往文件里写数据的方法，既然是操作字符了，那肯定忘里写单个字符啊字符数组啊，字符串

 啊都行。

 

 字符流---创建文件  异常处理如上：

 

 FileWriter fw = new FileWriter("Demo.txt");//  在此目录下创建一文件，如果已经存在会被覆盖掉。

 FileWriter fw = new FileWriter("Demo.txt"，true);//不覆盖原文件，在末尾处添加

 fw.write("abcdefg");//调用write()方法，其实是存在了流(内存)中

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

 fw.close();// close()特点：刷新一次数据然后关闭流

 

 其实，我们不用java也能创建一个文件往里写数据，也就是说windows系统本身就具有这个动作，java能往

 windows的文件系统中写入数据，是不是代表着java在调用windos中那个写的动作？这个就是我们所说的流

 资源。其实java本身是不能往硬盘里写数据的，我们知道windows和linux系统它们写数据的方式是不是不一

 样啊？所以java得靠系统本身的方式来完成对数据的书写。总的来说就是java写数据什么的是不是在调用

 windows的系统资源用完了要怎么办？是不是要释放出来，所以close动作是一定要做的。

 

 文件的续写：

  建个文件往里面写数据，但是那个文件里已经有数据了该怎么往里续写数据呢？写一次刷新一次，通过

  查看API我们发现FileWriter类有一种构造函数

  FileWriter(String fileName, boolean append)

  参数： fileName - 一个字符串，表示与系统有关的文件名。

   append - 一个 boolean 值，如果为 true，则将数据写入文件末尾处，而不是写入文件开始处。 

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

 

字符流 Reader(读)

 说完写该说读了，查看API发现Reader类里也有很多和Writer方法，如close()等，但是它里面没有flush();

 另外它里面有一群读的方法(read),如读单个字符，或把数据读入到一个数组，另外读文件的话是不是先把

 文件传给他啊，所以在创建对象的时候要把指定文件与它相关联。如果不存在会发生文件未找到异常。

 

 字符流---读取文件1 下面是没有进行异常处理的

 

 FileReader fr = new FileReader("Demo.txt");//文件不存在会抛异常

 int x = fr.read();//一次读一个会自动往下读，如果在调用一次read方法和打印方法，打印的则是下一个

 System.out.println(char(x));//因为返回的是int型，所以要进行类型转换。

 //一个文件里面显然不会只有一个字符，像上面所说读一个重写一次方法，会很麻烦，所以会想到循环，如下：

    int x = 0;

 while((x=fr.read()) != -1)//文件读取到末尾如果没有的话会返回-1

 {

  System.out.println((char)x);

 }

 

  字符流---读取文件2 通过字符数组进行读取，下面是没有进行异常处理的

 FileReader fr = new FileReader("Demo.txt");//创建一个文件读取流对象和指定文件相关联

 //定义一个字符数组

 char[] ch = new char[1024]//一般数组大小会定为1024的整数倍

 int num = fr.read(ch);//将读取到的文字存放在数组中，则返回的是字符里面的个数

 System.out.println(new String(ch));//将数组变成字符串打印

 fr.close();//这一步没有刷新数据，读取文件不用刷新

 

 文件读取2的完整代码：

 

 

FileReder fr = null
  try
  {
  fr = new FileReade();
  char[] ch = new char[1024];
  int num = 0;
  while((num = fr.read(ch))!=-1)
  {
   //打印数组中的有效位，如果数组中只有三个字符，就没必要把1024个全打印出来
   System.out.println(new String(buf,0,len)); 
  }
  }
  catch (IOException e)
  {
   //异常处理
  }
  finally
  {
   try
   {
   if (fr !=null)
   {
    fw.close();
   }
   }
   catch (IOException e)
   {
   //异常处理
   }
  }

  

 注意：

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

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

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

 

练习：复制文件

 部分代码：

  

FileWriter fw = new FileWriter("copy.txt");//向目的文件中写入数据
  FileReader fr = new FileReader("Demo.java");//读取文件中的数据写入流中
 
  char[] buf = new char[1024];
 
  int len = 0;
  while((len=fr.read(buf))!=-1)
  {
   fw.write(buf,0,len);
  }

  

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

字符流的缓冲区： BufferedWriter  BufferedReader

 

 字符流中的读写，如上面方法的话，都是一个一个的读或写，为了提高效率出现了缓冲区，就像

 用杯子接水滴，等接满了一杯再喝会比接一滴喝一滴舒服。

 像迅雷，BT这些软件它们在下载过程中都有自己的缓冲区，比如它们在服务器下载东西，每次下

 载一次性两兆再写到硬盘上从，比每次从服务器下载一点就往硬盘上写一点快吧。这边一顿狂读，

 这后到这边再一顿狂写，省的磁头来回的切换，这样效率就提升了很多。

 

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

 该缓冲区中提供了一个跨平台的换行符。newLine();

 

 我们创建一个流对象之后，然后把它当参数传给缓冲区的构造函数，因为缓冲区已经和流相关联了，

 所以然后直接用缓冲区的方法就可以了。

 

 字符写入流缓冲区： BufferedWriter

 

      既然缓冲区是为了提高流的效率，那么它存在的前提是要有流。

 

    例如：

  FileWriter fw = new FileWriter("Demo.txt");

  //只需将需要被提高效率的流当参数传入给缓冲区的构造函数即可

  BufferedWriter bfw = new BufferedWriter(fw);

  //然后下面就可以用缓冲区的方法了(BufferedWriter也是Write的子类，所以也能用它的方法)

  bfw.write("abcde");

  bfw.flush();//只要用到缓冲区就要刷新

  bfw.close();//关闭缓冲区其是就是关闭了流对象，所以fw.close()就不用再写了

 

 缓冲区有一个新的方法：newLine()这个方法是跨平台的，在window上"\r\n"是换行而在linux上"\n"是换行

 只有用到缓冲区对象的时候才能用newLine()方法

 例如：

  for(intx =0;x<5;x++)

  {

  bfw.write("abcde");

  bfw.newLine();

  //为什么要写一次刷新一次？ 因为在写的过程中可能会出现一些状况如停电，如果在写好多的情况下

  // 停电了没刷新那么文件里面一点也不会有

  bfw.flush();

  }

 

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

 

字符读取流缓冲区： BufferedReader

 

 该缓冲区提供了一次读一行的方法：readLine()因为一行有很多字符。所以它返回的是字符串，读到流的

 末尾返回的是null，readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

 readLine()方法最终都是从硬盘上一个一个的读取所以最终使用的还是read方法一个一个的读的。

 

 //创建一个读取流对象和文件相关联。

 FileReader fr = new FileReader("Demo.txt");

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

 BufferedReader bfr = new BufferedReader(fr);

 //下面使用BufferedReader的方法

 String s = null;

 while((s=bfr.readLine()) !=null)

 {

  System.out.print(s);

 }

 bfr.close();

 

 缓冲区特点：

  缓冲区的出现提高了对数据的读写效率。?

  缓冲区要结合流才可以使用。?

  在流的基础上对流的功能进行了增强。

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

 

装饰设计模式:

 一个类的功能如果需要加强，可以在定义一个类来写加强的功能，然后将需要被加强的类

 当参数传入加强类，通过构造方法来接收被加强的类。如BufferedReader(FlieRader fr).

 

 模式例如:

 

class OldMethod   //1.
 {
  public void fuction
  {
   //原有的功能
  }
 }
 class SuperMethod  //2.
 {
  private OldMethod om;
  SuperMethod(OldMethod om)
  {
   this.om = om;
  }
  public void superFuction
  {
   //基于原有而加强的功能
   //如果有用到原来的东西，直接调用：om.fuction()
  }
 }

  

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

 

疑问:为什么类2不继承类1呢？

  例如下面类OldMethod有三个子类，比如在开发的过程中我们发现这三个子类里面的功能效率有点低我

  们想要重写个类来加强一下它们的功能，这时会想到用缓冲技术，那么如果要用继承的话，就会像下

  面这样,在后期OldMethod可能还会再增加好多子类，那么在这样写的话整个体系就会显得非常臃肿，所

  以要进行优化。

  

OldMethod

 |--OneMethod

  |--OneBufferMethod

 |--TwoMethod

  |--TwoBufferMethod

 |--ThreeMethod

  |--ThreeBufferMethod

怎么优化呢？既然它们都需要缓冲，所用的技术也都一样，那么就没必要一个一个的写缓冲类来继承了，可以

专门定义一个缓冲类，OldMethod的哪个子类需要缓冲就把哪个当参数传进来。如下：

class MyBufferMethod

{

 MyBufferMethod(OneMethod one)

 {

 }

 MyBufferMethod(TwoMethod two)

 {

 }

 MyBufferMethod(ThreeMethod three)

 {

 }

    ......//但是这样扩展型还是不太好

}

 

这时可以发现，无论是哪个类需要缓冲，他们都是OldMethod的子类，这样就想到了多态，我们可以这样定义

一个类来继承.

class MyBufferMethod extends OldMethod//既然MyBufferMethod里的功能和只是那三个子类功能的加强，

{         //所以它也应该属于OldMethod参看下面的（看这里）

 MyBufferMethod(OldMethod old)//多态，技能传OneMethod也能传TwoMethod...

 {

 }

}

 

最后这个体系就变成了这样：

OldMethod

 |--OneMethod

 |--TwoMethod

 |--ThreeMethod

 |--MyBufferMethod

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

我们可以看出装饰模式比继承更灵活，降低了类与类之间的关系

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了加强功能。所以装饰类

和被装饰类属于同一个体系就像BufferedReader与FileReader同是Reader的子类

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

 

LineNumberReader: 也是一个装饰类，BufferedReader的子类，所以它也有readLine()方法，

                   另外还有setLineNumber()和getLineNumber(),意为设置和获取行号。

 

使用方法如下(没有进行异常处理)：

 FileReader fr = new FileReader("Demo.txt");

    LineNumberReader lnr = new LineNumberReader(fr);

 String s = null;

 lnr.setLineNumber(10);//可以设置行号的起始值

 while((x=lnr.readLine()) != null)

 {

  System.out.println(lnr.getLineNumber()+"::"+x);

 }

 

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

 

 

字节流：基本操作与字符流差不多，别说它里面的write，read方法和字符流里的基本一样，它也能一个一个

的往文件里写数据，也能把数组中的数据一下写到文件中，既能一个一个的读，也能把数据读入到一个数组

中，唯一的区别是字符流写进的是char[]，而字节流是往byte[]数组中读或写。另外字节流不仅操作字符，

还可以操作其他媒体文件

 

基类 InputStream读 OutputStream写

  

字节流--文件写入,与字符流一样也要处理异常。

 FileOutputStream fos = new FileOutputStream("Test.txt");//创建一个字节写入流，与文件相关联

 //里面要么写单个字节，要么写字节数组，写字符串的话要把它转成字节类型的

 fos.write("abcde".getBytes());//不需要刷新，因为是直接对字节最小单位操作，中间不需要任何转换

 fos.close();//关闭流

 

字节流--文件读取1，一个一个的打印

 FileInputStream fis = new FileInputStream("Test.txt");

 int ch = 0;//调用read()方法返回的是整数，流末尾返回的是-1；

 while((ch=fos.read())!=-1)

 {

  System.out.println(char(ch));//因为返回的是整数，所以要把它转成字符型打印

 }

 fos.close(); 

字节流--文件读取2，将数据读进一个字节数组

 FileInputStream fis = new FileInputStream("Test.txt");

 byte[] buf = new Byte[1024];

 int len = 0;

 while((flen=os.read(buf))!=-1)

 {

  //把数组转换为字符串，按范围打印出来

  System.out.println(new String(buf,0,len));

 }

字节流--文件读取3，这一种是字节流特有的

 FileInputStream fis = new FileInputStream("Test.txt");

 //int num = fis.available();调用这个方法可以算出文件中的字符数

 byte[] buf = new Byte[fis.available()];//所已就可以定义一个刚刚好的数组了，也就不用循环了

 fos.read(buf);//读取文件中的字节存在数组buf中

 System.out.println(buf);//不用循环，直接把数组里面的全打印出来

 fis.close();

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

 注意：

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

  因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.

  那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。

  所以，为了避免这种情况将读到的字节进行int类型的提升。

  并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。

 

  而在写入数据时，只写该int类型数据的最低8位。

 

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

字节流缓冲区

  //例：通过字节流的缓冲区来完成 Mp3的复制：

 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)

 {

  fos.write(by);//把从文件中读取的数据写进目的文件

 }

 

 fos.close();//有多少流就关多少流

 fis.close();

 

 

自定义字节流缓冲区：

 字节流缓存区的原理是，把一些数据先存进一个数组中，然后在一下取出来。自定义缓冲区的话，思路

 就是：要先定义一个数组，然后再把数组中的数据一个一个往外取。用到了数组，怎么往里存呢？我们

 知道read(arr)返回的是数组里元素的个数，

 那取的时候read方法

 是一个一个的往下读的，所以就用到了指针，那什么时候停呢？就是取到数组末尾的时候，就是count=0的时候，

 那怎么往数组里面存呢？

 class MyBufferInputStream extends 
 {
  private InputStream ips;//定义一个InputStream引用
  private byte[] buf = new byte[1024*4];
   
  private int pos = 0,count = 0;//定义一个指针和数据个数的变量
  MyBufferInputStream(InputStream ips)//把需要缓存的文件当参数传给缓冲器的构造函数
  {
   this ips = ips;
  }
 //要对外提供一个read方法，就像BufferInputStream，一次读一个字节(从缓冲区即字符数组中读取)
  public int myRead()throws IOException//进行异常处理
  {
   //通过in对象读取硬盘上数据，并存储buf中。
   if(count==0)//5.所以当数组中元素为0的时候，是先存再取
   {
    count = ips.read(buf);//1.把数据读取到数组中，返回的是数组里元素的个数
    if(count<0)//
     return -1;
    pos = 0;//
    byte b = buf[pos];//2.往数组里存满了是不是就该把数组里的数据取出来放缓冲区里啦
 
    count--;//3.把数组里的数据往缓冲区里装的时候是不是装一个，数组里就少一个啊？
    pos++;//4.一个一个的把数组里的取出来，是不是就是指针越来越往后移啊
    return b&255;
   }
   else if(count>0)//6.而当数组里有数据的时候直接取
   {
    byte b = buf[pos];
 
    count--;
    pos++;
    return b&0xff;
   }
   return -1;
  }
 }

  

读取键盘录入：

 System.out:对应的是标准输出设备，控制台。

 System.in:对应的标准输入设备：键盘。in 是标准输入流对应的是InputStream,所以能用read()等方法

 例如：

 InputStream in = System.in;//System调用in方法之后返回的是一个字节读取流

 int by = in.read();//读取一个字节字符流字节流读取一个数据返回的都是int型

 System.out.println(by);//控制台将会等待输入运行代码

 

 部分代码：

 import java.io.*;
 class IODemo 
 { 
  public static void main(String[] args) throws IOException
  {
   InputStream ins = System.in;
   
   StringBuilder sb = new StringBuilder();
   while(true)
   {
    int ch  = ins.read();
    if(ch=='\r')
     continue;
    if(ch=='\n')
    {
     String s = sb.toString();
     
     //sb.delete(0,sb.length());
     if("over".equals(s))
      break;
     System.out.println(s.toUpperCase());
     sb.delete(0,sb.length());
    }
    else
     sb.append((char)ch);
   }
  }
 }

  然后发现以上代码与我们自定义 BufferedReader时写的ReaderLine代码差不多，这时就考虑能不能

 直接拿过来用呢？但是 BufferedReader是字符流，而InputStream是字节流，它是字节流要用字符流

 的东西，怎么办？是不是要看看有没有能把字节流转为字符流的东西啊？通过查看java API发现，还

 真有个转换流，下面请看java io(2)。

---------------------- android开发、java培训、期待与您交流！ ----------------------