Java：IO流其他类(字节数组流、字符数组流、数据流、打印流、Properities、对象流、管道流、随机访问、序列流、字符串读写流)

一、字节数组流：

类 ByteArrayInputStream:在构造函数的时候，需要接受数据源，而且数据源是一个字节数组。

包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节

关闭ByteArrayInputStream流无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException

 

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

此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。

可使用toByteArray()和toString()获取数据。 

关闭ByteArrayOutputStream流无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

 

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

用流的思想去操作数组。

 

在流操作讲解时：

源设备：键盘(System.in)、硬盘(FileStream)、内存(ArrayStream)

目的设备：控制台(System.out)、硬盘(FileStream)、内存(ArrayStream)

//例子1：

import java.io.*;
class ByteArrayStreamDemo
{
    public static void main(String[] args)
    {
        //数据源
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEF".getBytes());//getBytes()是将一个字符串转化为一个字节数组
        
        //数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int by = 0;
        while((by = bis.read())!=-1)
        {
            bos.write(by);
        }
        
        System.out.println(bos.size());
        System.out.println(bos.toString());
        
        //bos.writeTo(new FileOutputStream("ByteArray.txt"));//只有此处需要对异常进行处理。
    }
}

二、字符数组流：CharArrayReader和CharArrayWriter

 

类 CharArrayReader:在构造函数的时候，需要接受数据源，而且数据源是一个字符数组。

此类实现一个可用作字符输入流的字符缓冲区。读入流会产生IOException 

 

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

此类实现了一个输出流，其中的数据被写入一个char数组。缓冲区会随着数据的不断写入而自动增长。

可使用toCharArray()和toString()获取数据。 

关闭CharArrayWriter流无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

 

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

用流的思想去操作数组。

//例子2：

import java.io.*;
class CharArrayStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //数据源
        CharArrayReader car = new CharArrayReader("世界第一等".toCharArray());//toCharArray()是将一个字符串转化为一个字符数组
        
        //数据目的
        CharArrayWriter caw = new CharArrayWriter();
        int by = 0;
        while((by = car.read())!=-1)
        {
            caw.write(by);
        }
        
        System.out.println(caw.size());
        System.out.println(caw.toString());
        
        //caw.writeTo(new FileOutputStream("CharArray.txt"));//需要对异常进行处理。
    }
}

三、数据流

DataInputStream: DataInputStream(InputStream in) 

DataOutputStream: DataOutputStream(OutputStream out) 

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

//例子3：

import java.io.*;
class DataStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        //WriteData();
        //ReadData();
        WriteUTFDemo();
        ReadUTFDemo();
    }
    public static void WriteData()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("Data.txt"));
        dos.writeInt(10);
        dos.writeChar(97);
        dos.writeDouble(3.1415926);
        dos.writeBoolean(true);
        dos.close();        
    }
    public static void ReadData()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("Data.txt"));
        System.out.println(dis.readInt());
        System.out.println(dis.readChar());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());
        dis.close();
    }
    
    
    public static void WriteUTFDemo()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("Data-UTF.txt"));
        dos.writeUTF("你好");
        dos.close();
    }
    public static void ReadUTFDemo()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("Data-UTF.txt"));
        System.out.println(dis.readUTF());
        dis.close();
    }
}

四、管道流：

PipedInputStream 

PipedOutputStream 

作用：输入输出可以直接进行连接，通过结合线程使用。

//例子4：

import java.io.*;
class ReadPiped implements Runnable
{
    private PipedInputStream in;
    ReadPiped(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);
        }
        catch(IOException e)
        {
            throw new RuntimeException("管道读取流失败!");
        }
        finally
        {
            try
            {
               in.close();    
            }
            catch(IOException e)
            {
              throw new RuntimeException("流关闭失败!");
            }
        }
    }
}
class WritePiped implements Runnable
{
    private PipedOutputStream out;
    WritePiped(PipedOutputStream out)
    {
        this.out = out;
    }
    public void run()
    {
        try
        {
            System.out.println("开始写入数据，等待5秒");
            Thread.sleep(5000);
            out.write("guandao lai le".getBytes());
            out.close();    
        }
        catch(Exception e)
        {
            throw new RuntimeException("管道输出流失败!");
        }
    }            
}
class PipedStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
        in.connect(out);//使此管道输入流连接到管道输出流 
        
        ReadPiped r = new ReadPiped(in);
        WritePiped w = new WritePiped(out);
        
        new Thread(r).start();
        new Thread(w).start();
    }
}

五、打印流：PrintStream 

        PrintWriter 

java.lang.Object

  继承者 java.io.OutputStream

      继承者 java.io.FilterOutputStream

          继承者 java.io.PrintStream

 

java.lang.Object

  继承者 java.io.Writer

      继承者 java.io.PrintWriter

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

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

 

PrintStream:字节打印流

构造函数可以接受的类型：1.file对象。File

                        2.字符串路径。String 

                        3.字节输出流。OutputStream

//PrintStream(OutputStream out, boolean autoFlush) 

 如果为 true，则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 (' ') 时都会刷新

 

PrintWriter:字符打印流

构造函数可以接受的类型：

1.file对象。File

2.字符串路径。String 

3.字节输出流。OutputStream

4.字符数据流。Writer

//PrintWriter(OutputStream out, boolean autoFlush) 

autoFlush为true时，则println、printf或format将自动刷新输出缓冲流

 //例子5：

import java.io.*;
class PrintStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        
        PrintWriter ps = new PrintWriter(System.out,true);//(new BufferedWriter(new FileWriter("F:\myfile\print.txt")),true)
        
        String line = null;
        
        while((line = bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            ps.println(line.toUpperCase());
            //ps.flush();
        }
        ps.close();
        bufr.close();
    }
}

六、Properties

它是hashtable的子类，也就是它具备了Map集合的特点，而且它里面存储的键值对都是字符串。

是集合中和IO技术相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件

那么在加载数据时，需要数据有固定格式：键=值

 Object setProperty(String key, String value) 

          调用 Hashtable 的方法 put。 

 String getProperty(String key) 

          用指定的键在此属性列表中搜索属性。 

 String getProperty(String key, String defaultValue) 

          用指定的键在属性列表中搜索属性。 

 Set<String> stringPropertyNames()  

          返回此属性列表中的键集

 void load(InputStream inStream) 

          从输入流中读取属性列表（键和元素对）。 

 void load(Reader reader) 

          按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

  void store(OutputStream out, String comments) 

          以适合使用 load(InputStream) 方法加载到 Properties 表中的格式,并存储到打印流中 

 void store(Writer writer, String comments) 

          以适合使用 load(Reader) 方法的格式，并存储到打印流中 。 

//例子6：

import java.io.*;
import java.util.*;
class PropertiesDemo
{
    public static void main(String[] args)throws IOException
    {
        //setAndget();
        //method_1();
        method_2();
    }
    //演示如何将流中的数据添加放到集合中
    //想要将key-value.txt数据存到集合进行操作
    /*
     步骤：1.用一个流和key-value相关联
           2.读一行数据，将该行数据用"="进行切割
           3.等号左边作为键，右边作为值，存入到Properties集合即可。
    */
    //方法1(load方法的原理)
    public static void method_1()throws IOException
    {
        Properties p = new Properties();
        //FileInputStream fis = new FileInputStream("F:\myfile\key-value.txt");
        BufferedReader bufr = new BufferedReader(new FileReader("F:\myfile\key-value.txt"));
        String str=null;
        while((str=bufr.readLine())!=null)
        {
            String[] s = str.split("=");
            System.out.println(s[0]+"...."+s[1]);
            p.setProperty(s[0],s[1]);
        }
        //System.out.println(p);
        p.list(System.out);
        bufr.close();
    }
    //方法2(直接调用load方法)
    public static void method_2()throws IOException
    {
        Properties p = new Properties();
        p.load(new FileReader("F:\myfile\key-value.txt"));//p.load(new FileInputStream("F:\myfile\key-value.txt"))
        
        p.setProperty("zhaoliu","100");//修改已有的姓名的年龄并保存在文件中
        p.store(new FileWriter("F:\myfile\key-value.txt"), p.toString());
        System.out.println(p);
    }
    

    
    //设置和获取元素
    public static void setAndget()
    {
        Properties p = new Properties();
        p.setProperty("zhangsan","30");
        p.setProperty("lisi","40");
        
        System.out.println(p);
        
        
        String value = p.getProperty("lisi");
        System.out.println("value="+value);

        //p.setProperty("lisi",89+"");//修改lisi年龄
        
        Set<String> name = p.stringPropertyNames();
        Iterator<String> it = name.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            System.out.println("key:"+key+" "+"value"+p.getProperty(key));
        }
        /*
        for(String key: name)
        {
            System.out.println("key:"+key+" "+"value"+p.getProperty(key));
        }
        */        
    }
}

七、随机访问类

类 RandomAccessFile：此类的实例支持对随机访问文件的读取和写入

java.lang.Object

       继承者 java.io.RandomAccessFile

  

RandomAccessFile:RandomAccessFile(File file, String mode) 

该类不算是IO体系中的子类，而是直接继承Object。

 

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

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

可以通过getFilePointer获取指针位置或者通过seek改变指针的位置。

 

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

 

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

而且，操作文件还有模式mode：只读r、读写rw、rws、rwd

 

如果文件只读r，不会创建文件，而是会去读取一个存在的文件，如果该文件不存在，则会出现异常。

如果文件为读写rw，要操作的文件不存在，会自动创建，而且如果存在不会覆盖。 

//例子7：

import java.io.*;
class RandomAccessFileDemo
{
    public static void main(String[] args)throws IOException
    {
        //WriteFile();
        //WriteFile2();
        ReadFile();
    }
    public static void WriteFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("Random.txt","rw");
        raf.write("李四".getBytes());
        raf.writeInt(65);
        raf.write("王武".getBytes());
        raf.writeInt(67);
        raf.close();
    }
    
    
    public static void WriteFile2()throws IOException
    {
        //改变指针，随机位置写入数据，还可以修改之前位置所写的数据(不会重新覆盖创建的文件)
        RandomAccessFile raf = new RandomAccessFile("Random.txt","rw");
        raf.seek(8*3);
        raf.write("周七".getBytes());
        raf.writeInt(69);        
        raf.seek(8*2);
        raf.write("赵六".getBytes());
        raf.writeInt(68);
        raf.close();        
    }
    
    
    
    public static void ReadFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("Random.txt","r");
        PrintStream ps = System.out;
        System.setOut(ps);
        byte[] buf = new byte[4];
        //ps.println(raf.getFilePointer());//获取当前指针位置
        //raf.seek(8*1);//改变当前指针的位置(可以前后移动)
        //raf.skipBytes(8);//跳过8个字节(只能往后跳)
        while(raf.read(buf)!=-1)
        {
            String name = new String(buf);
            ps.println("name="+name);
            
            int age= raf.readInt();
            ps.println("age="+age);
            
        }
            raf.close();            
    }
}

八、序列流

java.lang.Object

  继承者 java.io.InputStream

      继承者 java.io.SequenceInputStream

类 SequenceInputStream:表示其他输入流的逻辑串联

构造方法：

SequenceInputStream(Enumeration<? extends InputStream> e) 

SequenceInputStream(InputStream s1, InputStream s2)  

合并文件

//例子8：

import java.io.*;
import java.util.*;
class SequenceStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        Vector<FileInputStream> v = new Vector<FileInputStream>();
        v.add(new FileInputStream("F:\myfile\1.txt"));
        v.add(new FileInputStream("F:\myfile\2.txt"));
        v.add(new FileInputStream("F:\myfile\3.txt"));
        
        Enumeration<FileInputStream> enu = v.elements(); 
        SequenceInputStream sis = new SequenceInputStream(enu);//将多个流整合为一个流对象
        
        BufferedWriter bufw = new BufferedWriter(new FileWriter("F:\myfile\123.txt"));
        
        int num = 0;
        while((num=sis.read())!=-1)
        {
            bufw.write(num);
            bufw.flush();
        }
        sis.close();
        bufw.close();
    }
}

九、字符串读写流

类 StringReader：其源为一个字符串的字符流。

    StringReader(String s) 创建一个新字符串 reader。

类 StringWriter：一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。关闭 StringWriter 无效。 

                 此类中的方法在关闭该流后仍可被调用，而不会产生任何 IOException。

    StringWriter() 

          使用默认初始字符串缓冲区大小创建一个新字符串 writer。

//例子9：

import java.io.*;
class StringReaderWriterDemo
{
    public static void main(String[] args)throws IOException
    {
        StringReader sr = new StringReader("Thank you very much");
        StringWriter sw = new StringWriter();
        
        //StringWriter s = sw.append('A');
        int by = 0;
        while((by=sr.read())!=-1)
        {
            sw.write(by);
        }
        
        System.out.println(sw.toString());
    }
}

十、对象流

类 ObjectInputStream:  

 1.ObjectOutputStream() 

  2.ObjectOutputStream(OutputStream out)  

  3.void writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

           

java.lang.Object

  继承者 java.io.InputStream

      继承者 java.io.ObjectInputStream

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

类 ObjectOutputStream:  

1.ObjectInputStream() 

2.ObjectInputStream(InputStream in)  

3.Object readObject() 从 ObjectInputStream 读取对象。

  

java.lang.Object

  继承者 java.io.OutputStream

      继承者 java.io.ObjectOutputStream

//例子10：

import java.io.*;
class ObjectStreamDemo
{
    public static void main(String[] args)throws Exception
    {
        //writeObj();
        readObj();
    }
    public static void writeObj()throws IOException
    {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Object.txt"));
        oos.writeObject(new Person("zhangsan",25));
        oos.close();
    }
    public static void readObj()throws Exception
    {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Object.txt"));
        Person p =(Person)ois.readObject();
        System.out.println(p);
        ois.close();
    }
}