黑马程序员——IO流

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

 

java IO流

java.io包定义了多个流类型来实现输入、输出功能;

输入流、输出流  字节流（8位）、字符流（16位） 节点流、处理流

对文件进行操作，从文件读出来，写进文件里去。

输入流、字节流：InputStream   字符流：Reader
输出流、字节流：OutputStream  字符流：Writer

节点流直接从数据源（文件、内存）读写数据
处理流连接在已存在的流之上实现更为强大的读写功能。

InputStream （输入字节流）基本方法
int read() throws IOException  //-1已到输入流的末尾
int read(byte[] buffer) throws IOException //存储到一个数组buffer
void close() throws IOException //关闭流释放内存资源

OutputStream （输出字节流）基本方法
void write(int b) throws IOException
void write(byte[] b) throws IOException
void close() throws IOException
void flush()throws IOException //将输出流中缓冲的数据全部写出到目的地

Reader 基本方法与InputStream相同

Writer 基本方法与OutputStream基本相同

void Write(String str) throws IOException //将一个字符串写进去

void Write(char[] c) throws IOException

节点流类型

File(文件) FileReader、FileWriter、FileInputStream、FileOutputStream
Memory Array
Memory String
Pipe(管道)

例：

实现文件复制功能。

import java.io.*;
public class TestFileOutputStream {
  public static void main(String[] args) {
   int b = 0;
   FileInputStream in = null;//输入流
   FileOutputStream out = null;//输出流
   try {
     in = new FileInputStream("d:/share/java/HelloWorld.java");//从文件读
     out = new FileOutputStream("d:/share/java/io/HW.java");//写文件里
     while((b=in.read())!=-1){//从in对象读出来，read()方法返回int类型，不等于-1就继续。
       out.write(b);//写进out对象里
     }
     in.close();
     out.close();
     System.out.println("文件已复制");
   } catch (FileNotFoundException e2) {
     System.out.println("找不到指定文件"); System.exit(-1);
   } catch (IOException e1) {
     System.out.println("文件复制错误"); System.exit(-1);
   }  
  }
}

例：

练习FileReader从文件读取数据。

import java.io.*;
public class TestFileReader {
  public static void main(String[] args) {
    FileReader fr = null; //输入、字符流
    int c = 0;
    try {
      fr = new FileReader("d:\\share\\java\\io\\TestFileReader.java");//从文件读取
      int ln = 0;
      while ((c = fr.read()) != -1) {//不等于-1就继续读取。
        //char ch = (char) fr.read();
        System.out.print((char)c);//转换为字符输出。
        //if (++ln >= 100) { System.out.println(); ln = 0;}
      }
      fr.close();
    } catch (FileNotFoundException e) {
      System.out.println("找不到指定文件");
    } catch (IOException e) {
      System.out.println("文件读取错误");
    }

  }
}

例：

练习FileWriter写入数据到文件里。

import java.io.*;
public class TestFileWriter {
  public static void main(String[] args) {
    FileWriter fw = null;
    try {
      fw = new FileWriter("d:\\bak\\unicode.dat");//写入文件里，如果文件不存在，会自动建立。(不会建立目录)
      for(int c=0;c<=50000;c++){//char最大数为65535
        fw.write(c);//写入的是字符
      }
      fw.close();
    } catch (IOException e1) {
     e1.printStackTrace();
      System.out.println("文件写入错误");
      System.exit(-1);
    }
  }
}

处理流类型

Buffering(缓冲流): 缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率。

BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream

例1：

import java.io.*;
public class TestBufferStream1 {
  public static void main(String[] args) {
    try {
      FileInputStream fis =
              new FileInputStream("d:\\share\\java\\HelloWorld.java");//从文件读取
      BufferedInputStream bis =
              new BufferedInputStream(fis);//套接缓冲流读取，具有缓冲功能
      int c = 0;
      System.out.println(bis.read());
      System.out.println(bis.read());
      bis.mark(100);   //做个标记，从第100个开始读取
      for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
        System.out.print((char)c+" ");
      }
      System.out.println();
      bis.reset();   //回到标记点读取
      for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
        System.out.print((char)c+" ");
      }
      bis.close();
    } catch (IOException e) {e.printStackTrace();}
  }
}

例2：

import java.io.*;
public class TestBufferStream2 {
  public static void main(String[] args) {
    try {
      BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\share\\java\\dat2.txt"));//写入文件里去
      BufferedReader br = new BufferedReader(
             new FileReader("d:\\share\\java\\dat2.txt"));//从文件读取
      String s = null;
      for(int i=1;i<=100;i++){
        s = String.valueOf(Math.random());//产生0-1随机数
        bw.write(s);//写入到bw对象里去
        bw.newLine();//换行
      }
      bw.flush();//清空
      while((s=br.readLine())!=null){//整行读取，专属于 BufferedReader 类里
        System.out.println(s);
      }
      bw.close();
      br.close();
    } catch (IOException e) { e.printStackTrace();}
  }
}

Converting between
bytes and character（转换流）：把字节流转换为字符流。

InputStreamReader、OutputStreamWriter

例1

import java.io.*;
public class TestTransForm1 {
  public static void main(String[] args) {
    try {
      OutputStreamWriter osw = new OutputStreamWriter(//字节流转换为字符流，又套接一层
           new FileOutputStream("d:\\bak\\char.txt"));
      osw.write("mircosoftibmsunapplehp");
      System.out.println(osw.getEncoding());//输出字符编码
      osw.close();
      osw = new OutputStreamWriter(
           new FileOutputStream("d:\\bak\\char.txt", true),"ISO8859_1"); //true代表追加。iso8859-1又称                      latin-1
      osw.write("mircosoftibmsunapplehp");
      System.out.println(osw.getEncoding());
      osw.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

例2：

import java.io.*;
public class TestTransForm2 {
  public static void main(String args[]) {
    InputStreamReader isr =
            new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(isr);
    String s = null;
    try {
      s = br.readLine();
      while(s!=null){
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        s = br.readLine();
      }
      br.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

数据流

DataInputStream、DataOutputStream提供了可以存取与机器无关的Java原始类型数据（如：int、double等）的方法。

import java.io.*;
public class TestDataStream {
  public static void main(String[] args) {
    ByteArrayOutputStream baos =
                        new ByteArrayOutputStream(); //字节数组流
    DataOutputStream dos =
                        new DataOutputStream(baos);//数据输出流
    try {
      dos.writeDouble(Math.random());//写入double类型随机数，占8个字节
      dos.writeBoolean(true); //写入boolean类型，占1个字节
      ByteArrayInputStream bais =
          new ByteArrayInputStream(baos.toByteArray());//读出字节数组流
      System.out.println(bais.available());//总共9个字节
      DataInputStream dis = new DataInputStream(bais);数据输入流
      System.out.println(dis.readDouble());//读出随机数，先存先读
      System.out.println(dis.readBoolean());//读出布尔值
      dos.close();  dis.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

输出流

PrintWriter、PrintStream都属于输出流，分别针对字符和字节。打印到文件里。

例1：

import java.io.*;
public class TestPrintStream1 {
  public static void main(String[] args) {
    PrintStream ps = null;
    try {
      FileOutputStream fos =
              new FileOutputStream("d:\\bak\\log.dat");
      ps = new PrintStream(fos);
    } catch (IOException e) {
      e.printStackTrace();
    }
    if(ps != null){
      System.setOut(ps);//设置输出目标对象为ps
    }
    int ln = 0;
    for(char c = 0; c <= 60000; c++){
      System.out.print(c+ " ");
      if(ln++ >=100){ System.out.println(); ln = 0;}//输出到ps文件里
    }
  }
}

例2：

从窗口往里输入，然后自动打印到log日志里。

import java.util.*;
import java.io.*;
public class TestPrintStream3 {
  public static void main(String[] args) {
    String s = null;
    BufferedReader br = new BufferedReader(
                        new InputStreamReader(System.in));
    try {
      FileWriter fw = new FileWriter
                           ("d:\\bak\\logfile.log", true); //Log4J
      PrintWriter log = new PrintWriter(fw);
      while ((s = br.readLine())!=null) {
        if(s.equalsIgnoreCase("exit")) break;
        System.out.println(s.toUpperCase());
        log.println("-----");
        log.println(s.toUpperCase());
        log.flush();
      }
      log.println("==="+new Date()+"===");
      log.flush();
      log.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Object流

直接将Object写入或读出

ObjectOutputStream、ObjectInputStream

例：

import java.io.*;

public class TestObjectIO {
 public static void main(String args[]) throws Exception {
  T t = new T();
  t.k = 8;
  //写入文件里
  FileOutputStream fos = new FileOutputStream("d:/share/java/io/testobjectio.dat");  
  ObjectOutputStream oos = new ObjectOutputStream(fos);
  oos.writeObject(t);//直接把object对象t写入文件里
  oos.flush();
  oos.close();
  
  FileInputStream fis = new FileInputStream("d:/share/java/io/testobjectio.dat");
  ObjectInputStream ois = new ObjectInputStream(fis);
  T tReaded = (T)ois.readObject();//把内容读出来
  System.out.println(tReaded.i + " " + tReaded.j + " " + tReaded.d + " " + tReaded.k);
  
 }
}

class T
 implements Serializable//类可以序列化，就是可以直接的把object转换为字节流，写入到硬盘上。
{
 int i = 10;
 int j = 9;
 double d = 2.3;
 transient int k = 15;//transient 透明的 序列化时不予考虑
}

 

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

详细请查看：http://edu.csdn.net/heima