第七课第二部分 基本的流类

 

基本的流类 第七课 D

·FileInputStream和FileOutputStream

      节点流，用于向文件读取或者写入字节流，

·BufferedInputStream和BufferedOutputStream

      过滤流，需要使用已存在的节点流来创建。，提供了带缓冲的读写，提高了效率。数据先是写在缓冲区，缓冲区写满之后才会自动写到硬盘上，但是在输出流关闭之后缓冲区的数据也会写入到硬盘。如果你想在输出流关闭之前手动写入到硬盘，就应该使用BufferedOutputStream中的flush()方法。详见后面例子。

·DataInputStream和DataOutputStream

       过滤流，需要使用已存在的节点流来创建。提供了读写java基本数据类型的功能

·PipedInputStream和PipedOutputStream

      管道流，用于线程间的通讯

FileInputStream和FileOutputStream：

import java.io.*;

public class StreamTest

{

      public static void main(String[] args) throws Exception

      {

           FileOutputStream fil =new FileOutputStream("258.txt");//定义个输出流

           fil.write("helloword你好".getBytes()); //因为write方法参数需要字节(字节数组)类型

           fil.close();

           

           FileInputStream filin = new FileInputStream("258.txt");

           byte[] buf =new byte[100];  //定义存储读取数据的缓冲区

           int bufint=filin.read(buf);   //传递存储读取数据的缓冲区

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

           filin.close();

          

      }

}

BufferedInputStream和BufferedOutputStream：

BufferedInputStream由java.io.FilterInputStream继承而来。

import java.io.*;

public class StreamTest2

{

      public static void main(String[] args) throws Exception

      {

           //输出流

           FileOutputStream fos =new FileOutputStream("asd.txt");//定义个输出流以传递给缓冲数据流

           BufferedOutputStream bof = new BufferedOutputStream(fos);

           bof.write("霞妹妹乖乖！！！".getBytes()); //因为write方法参数需要字节(字节数组)类型

           bof.flush();  //在流关闭之前手动写入到硬盘，因为此时bof中的数据还在缓冲区中

           bof.close();  //什么时候使用flush()什么时候使用close()呢？？？

           //因为fos已经传递给bof了，所以只需关闭bof流。

           //当你想把缓冲区数据写入到硬盘，而还需要对流进行操作时就使用flush()，当对流操作一完毕就可以关闭了

          

           //输入流

           String str =File.separator+"javaLession"+File.separator+"Lession8"+File.separator+"asd.txt";

           FileInputStream fis = new FileInputStream(str);

           BufferedInputStream bif = new BufferedInputStream(fis);

           byte[]  by = new byte[100]; //定义存储读取数据的缓冲区

           int myint =bif.read(by);    //传递存储读取数据的缓冲区

           System.out.println(new String(by,0,myint));

           bif.close();

          

      }

}

DataInputStream和DataOutputStream：

import java.io.*;

public class StreamTest3

{

      public static void main(String[] args) throws Exception

      {

           //输出流

           FileOutputStream fos =new FileOutputStream("asd.txt");//定义个输出流以传递给缓冲数据流

           BufferedOutputStream bof = new BufferedOutputStream(fos);

           DataOutputStream dos = new DataOutputStream(bof); //当然这里也可以传递fos对象参数

           byte b = 23;

           int i = 66;

           char chr = 'h';

           float f = 5.4f ;

           dos.writeByte(b);   //这种方式写入文件的是二进制代码哦

           dos.writeInt(i);    //这种方式写入文件的是二进制代码哦

           dos.writeChar(chr); //这种方式写入文件的是二进制代码哦

           dos.writeFloat(f);  //这种方式写入文件的是二进制代码哦

           bof.close();

                     

           //输入流

           String str =File.separator+"javaLession"+File.separator+"Lession8"+File.separator+"asd.txt";

           FileInputStream fis = new FileInputStream(str);

           BufferedInputStream bif = new BufferedInputStream(fis);

           DataInputStream dis = new DataInputStream(bif);

           //注意读出数据的方式与前2者的不同

           System.out.println(dis.readByte());

           System.out.println(dis.readInt());

           System.out.println(dis.readChar());

           System.out.println(dis.readFloat());

           dis.close();

          

      }

}

PipedInputStream和PipedOutputStream 第七课 E 2850

import java.io.*;

class PipedStreamTest

{

      public static void main(String[] args)

      {

           //首先定义两个管道输入流和输出流对象

           PipedInputStream pis = new PipedInputStream();

           PipedOutputStream pos = new PipedOutputStream();

           try

           {

                 pis.connect(pos);  //也可以用输出流连接输入流的哈

                 new Productor(pos).start();

                 new Consumer(pis).start();

                

           }

           catch(Exception e)

           {

                 e.printStackTrace();

           }

          

      }

}

class Productor extends Thread

{

      private PipedOutputStream pos;

      Productor(PipedOutputStream pos)

      {

           this.pos=pos;

      }

      public void run()

      {

           try

           {

                 //注意write参数需要字节类型

                 pos.write("hello: 管道数据流!".getBytes());

                 pos.close();

           }

           catch(Exception e)

           {

                 e.printStackTrace();

           }

      }

}

class Consumer extends Thread

{

      private PipedInputStream pis;

      Consumer(PipedInputStream pis)

      {

           this.pis=pis;

      }

      public void run()

      {

           try

           {

                 byte[] by =new byte[100]; //定义一个字节数组，用于存放输出流中的字节数据

                 int in = pis.read(by);    //返回实际读到的字节长度

                 System.out.println(new String(by,0,in));//打印数组中的字节数组

                 pis.close();

           }

           catch(Exception e)

           {

                 e.printStackTrace();

           }

      }

}