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 方法或写入换行符或字节 ('\n') 时都会刷新

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();
}
}