黑马程序员_IO包中的其他类

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

 

打印流

PrintWriter 字符流

PrintStream 字节流

打印流：可以直接操作输入流和文件。

打印流：该流提供了打印方法，可以将各种数据类型的数据都原样打印。

1、可以直接打印任意类型的数据

2、有一个自动刷新机制

3、使用本机默认的字符编码

4、该流的print方法不抛出IOException

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

补充知识点：PrintWriter(流，true)：true代表刷新流

  Println（）：换行打印

开发时尽量使用PrintWriter

import java.io.*;

class  PrintStreamDemo

{

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

       {

              BufferedReaderbufr =

                     new BufferedReader(newInputStreamReader(System.in));

              PrintWriter out = newPrintWriter(new FileWriter("a.txt"),true);

              String line = null;

              while((line=bufr.readLine())!=null)

              {

                     if("over".equals(line))

                            break;

                     out.println(line.toUpperCase());     

              }

              out.close();

              bufr.close();

       }    

}

序列流

SequenceInputStream对多个流进行合并

SequenceInputStream(Enumeration<?Extends InputStream>e):用到了枚举

 

import java.io.*;

import java.util.*;

class SequenceDemo

{

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

       {

              Vector<FileInputStream>v = new Vector<FileInputStream>();

              v.add(newFileInputStream("c:\\1.txt"));

              v.add(newFileInputStream("c:\\2.txt"));

              v.add(newFileInputStream("c:\\3.txt"));

        Enumeration<FileInputStream> en = v.elements();

              SequenceInputStreamsis = new SequenceInputStream(en);

              FileOutputStreamfos = new FileOutputStream("c:\\4.txt");

              byte[] buf = new byte[1024];

              int len =0;

              while((len=sis.read(buf))!=-1)

              {

                     fos.write(buf,0,len);

              }

              fos.close();

              sis.close();

       }

}

 

切割文件

练习：

import java.io.*;

import java.util.*;

class SplitFile

{

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

       {

              merge();

       }

       public static void merge()throws IOException

       {

              ArrayList<FileInputStream>al = new ArrayList<FileInputStream>();

              for(int x=1;x<=3; x++)

        {

                     al.add(new FileInputStream("c:\\my\\"+x+".part"));

              }

              finalIterator<FileInputStream> it = al.iterator();

              Enumeration<FileInputStream>en = new Enumeration<FileInputStream>()

              {

                     public boolean hasMoreElements()

                     {

                            returnit.hasNext();

            }

                     public FileInputStream nextElement()

                     {

                            returnit.next();

                     }

              };

              SequenceInputStreamsis = new SequenceInputStream(en);

              FileOutputStreamfos = new FileOutputStream("c:\\my\\fengjing.bmp");

        byte[] buf = new byte[1024];

              int len = 0;

              while((len=sis.read(buf))!=-1)

              {

                     fos.write(buf,0,len);

              }

              fos.close();

              sis.close();

       }

       public static void splitFile()throws IOException

       {

        FileInputStream fis =  newFileInputStream("c:\\1.bmp");

              FileOutputStreamfos = null;

              byte[] buf = new byte[1024*1024];

              int len = 0;

              int count = 1;

              while((len=fis.read(buf))!=-1)

              {

                     fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");

                     fos.write(buf,0,len);

                     fos.close();

              }

        fis.close();

       }

}

操作对象（对象的序例化）

ObjectInputStream 读

ObjectOutputStream 写

被操作的对象需要实现Serializable（标记接口）

静态成员不能被序列化；

对非静态的成员非序列化在前面加上一个关键字transient

定义类时，可以不让java自动生成UID，自定义UID

管道流

PipedInputStream 输入流

PipedOutputStream 输出流

输入输出可以直接进行连接，涉及到多线程。

 

RandomAccessFile

随机访问文件，自身具备读写方法。

通过skipBytes(int x),seek(int x)来达到随机访问。

该类不是算是IO体系中子类。

而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，

同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读r，，读写rw等。

如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。

如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

RandomAccessFile raf =new RandomAccessFile("ran.txt","r");

   //调整对象中指针。

   raf.seek(8*1);

    //跳过指定的字节数

    raf.skipBytes(8);

skipBytes与seek的不同之处：只能往后，不能向前跳。

DataStream

DataInputStream与DataOutputStream

可以用于操作基本数据类型的数据的流对象。

readInt   ---> writeInt

readBoolean --->  WriteBoolean

readDouble  ---> writeDouble

readUTF  ----> writeUTF

ByteArrayStream

用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

//数据源。

ByteArrayInputStream bis= new ByteArrayInputStream("ABCDEFD".getBytes());

ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。

//数据目的

ByteArrayOutputStreambos = new ByteArrayOutputStream();

因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行close关闭。

补充：

源设备

    键盘： System.in，硬盘 FileStream，内存 ArrayStream。

目的设备：

      控制台：System.out，硬盘FileStream，内存 ArrayStream。

所以用流的读写思想来操作数据。

操作字符数组

charArrayReader

charArrayWriter

操作字符串

StringReader

StringWriter

 

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