黑马程序员-------IO流

　　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

IO流可以按流向分为输入流、输出流。按读取数据的类型可分为字节流和字符流。

 

字节流两个基类：InputStream    OutputStream

字符流两个基类：Reader    Writer

流的操作规律：因为我们要操作的流对象有多种，所以在操作过程中要明确我们每个程序所要操作的最合适的流对象。

输入流和输出流对象的选择：

1、明确源和目的:
             源：输入流，InputStream Reader
           目的：输出流，OutputStream Writer
2、操作的数据是否是纯文本:
             是：字符流
           不是：字节流
3、当体系明确后，在明确要使用哪个体系中具体的对象
通过设备来进行区分：
         源设备：内存，硬盘，键盘
       目的设备：内存，硬盘，控制台。

4、是否需要提高效率，是，加上缓冲技术。

 

IO流对数据的操作：

1、字符流：FilterWriterDemo文件对象的使用。

import java.io.*;
class FilterWriterDemo 
{
  public static void main(String[] args) throws IOException
  {
    //创建一个FilterWriter对象，该对象一被初始化就必须明确被操作的文件。
    //而且文件会被创建到指定目录下，果然该目录下已有重名，将会被覆盖。
    //其实该步骤就是明确文件要存放的目的地。
  FileWriter fw = new FileWriter("Java.txt");     //调用write()方法，将字符写入流中。
  fw.write("java");               //刷新对象中缓冲的数据。将数据转移到目的地中。
  fw.flush();

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

 

2、缓冲区：BufferedWriter
缓冲区的出现是为了提高流对象的操作效率所以在创建缓冲区的时候，一定先创建流对象。缓冲区提供一个跨平台的换行符：newLine();

import java.io.*;
class BufferedWriterDemo
{
  public static void main(String[] args) throws IOException
  {
    //创建一个字符写入流对象
    FileWriter fw = new FileWriter("BufferedWriter.txt");
    //为了提高写入流的效率，加入缓冲区技术。
    //只要将需要被提高效率的流对象作为参数传给缓冲区的构造函数即可。
    BufferedWriter bw = new BufferedWriter(fw);

    for(int i=0;i<=10;i++)
    {
     bw.write("java"+i);
     bw.newLine();
     //只要用到缓冲区，一定要刷新。
     bw.flush();
    }
    //关闭缓冲区就是关闭流对象。所以不用fw.close();
    bw.close();
  }
}

3、字符流读取缓冲区：BufferedReader 提供一次读一行的方法readLine。返回null表示读到末尾。

import java.io.*;

class BufferedReaderDemo 
{
 public static void main(String[] args) throws IOException
 {
  //创建一个读取流对象并和文件相关联。
  FileReader fr = new FileReader("BufferedWriter.txt");
  //创建一个读取流缓冲区，并把读取流对象作为参数传到构造函数中。
  BufferedReader br = new BufferedReader(fr);

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

File类

File类中常见的方法：
1、创建
boolean createNewFile();在指定位置创建文件，如果该文件存在，则不创建，返回     false，和输出流不一样。
boolean makdir();创建文件夹。
boolean makdirs();创建多级文件夹。
2、删除
boolean delete();删除失败返回false，如果文件正在被运行，删除不成功，也返回    false
void deleteOnExit();在程序退出时，删除指定文件。
3、判断
boolean exists();文件是否存在。
boolean isFile();isDirectory();isHidden();isAbsolute();
4、,获取信息
getName(); getPath(); getParent();
getAbsolutePath(); lastModified();  length();

IO包中的其他的包装类。

打印流：PrintWriter和PrintStream  
可以直接操作输入流和文件。
序列流：SequenceInputStream
对多个流进行操作。
操作对象：ObjectInputStream和ObjectOutputStream
被操作的对象需要实现Serializable(标记接口)
管道流：
PipedInputStream 和 PipedOutputStream
输入输出可以直接进行连接，通过结合线程使用。
/*

管道流结合线程的使用演示。

*/
import java.io.*;
class Read implements Runnable
{
 private PipedInputStream in;
 Read(PipedInputStream in)
 {
  this.in= in;
 }
 public void run()
 {
  try
  {
   
   byte [] buf = new byte[1024];
   System.out.println("读取前，没有数据，阻塞");
   int len = in.read(buf);
   System.out.println("读到数据，阻塞结束");
   String s = new String(buf,0,len);
   System.out.println(s);
   in.close();

  }
  catch (IOException e)
  {
   throw new RuntimeException("读取流失败");
  }
 }
}

class Write implements Runnable
{
 private PipedOutputStream out;
 Write(PipedOutputStream out)
 {
  this.out= out;
 }
  
 public void run()
 {
  try
  { System.out.println("开始写入数据，等待6秒！");
   Thread.sleep(6000);
   out.write("写入流开始".getBytes());
   out.close();
  }
  catch (Exception e)
  {
   throw new RuntimeException("写入流失败");
  }
  
 }

}
class PipedStream 
{
 public static void main(String[] args) throws IOException
 {
  PipedInputStream in = new PipedInputStream();
  PipedOutputStream out = new PipedOutputStream();
  in.connect(out);
  Read r = new Read(in);
  Write w = new Write(out);
  new Thread(r).start();
  new Thread(w).start();
 }
}

RandomAccessFile:
随机访问文件，自身具备读写方法。通过skipBytes(int x),seek(int x)来达到随机访问
该类不算是IO体系的子类。而是直接继承自Object
但是它是IO包中的成员，因为它具备读和写的功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过 getFilePointer获取指针位置，同时可以通过seek改变指针的位置。
完成读写的原理就是内部封装了字节输入流和输出流。
该类只能操作文件。而且操作文件还有模式：只读r，读写 rw等。
如果该模式为只读人r，不会创建文件，会去读取一个已存在文件，如果该文件不存在，则出异常
如果模式为rw，操作的文件不存在，会自动创建，如果存在则不会覆盖。