javaSE-IO补充 功能流对象（序列化和瞬态关键字）

打印流

/*
* 打印流：PrintStream
* 特点：
* 1，给字节输出流提供了打印方法。
* 2，方便打印数值表示形式。
* 3，构造函数接收File对象，字符串路径，OutputStream.
*/

PrintStream ps = new PrintStream("temp\\ps2.txt");

//		ps.write(97);//write写出一个int，只将最低一个字节写出。
//		ps.write(353);

//		ps.print(97);
ps.print(353); // 353 --> "353" --> 将数值保持表现形式不变，写到目的地中。都将数据转成字符串。

ps.close();

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("temp\\pw.txt")),true);

String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
pw.println(line.toUpperCase());
//			pw.flush();
}

pw.close();
bufr.close();

序列流

@Test
public void demo() throws Exception {
/*
* 演示序列流。 SequenceInputStream： 特地： 1，将多个源合并成一个源， 2，接收的是一个枚举接口对象。
*/

/* 效率太低了 不使用
* Vector<FileInputStream> v = new Vector<FileInputStream>(); v.add(new
* FileInputStream("temp\\1.txt")); v.add(new
* FileInputStream("temp\\2.txt")); v.add(new
* FileInputStream("temp\\3.txt"));
*/
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for (int x = 1; x <= 3; x++) {
al.add(new FileInputStream("temp\\" + x + ".txt"));
}

Enumeration<FileInputStream> en = Collections.enumeration(al);
SequenceInputStream sis = new SequenceInputStream(en);
BufferedReader in=new BufferedReader(new InputStreamReader(sis));
BufferedWriter out=new BufferedWriter(new FileWriter("temp/jiangyi.txt"));
String line=null;
while((line=in.readLine())!=null){
out.write(line);
out.newLine();
out.flush();
}
out.close();
in.close();
}

/*
* 将一个文件按照指定的大小进行切割。
* 思路：
* 1，一个输入流关联源文件。
* 2，当缓冲的数据满足了指定的大小后，则新建一个目的地进行继续的数据存储。
* 3，给每一个碎片文件编号。
*/public static void splitFile(File srcFile) throws IOException {

FileInputStream fis = new FileInputStream(srcFile);

FileOutputStream fos = null;

byte[] buf = new byte[1024*1024];//创建一个1M的缓冲区。

int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1){

fos = new FileOutputStream(new File("temp\\",(count++)+".part"));
fos.write(buf,0,len);
fos.close();

}

//将源文件的配置信息存储到一个文件中和碎片文件在一起。
Properties prop = new Properties();
prop.setProperty("partcount", count+"");
prop.setProperty("srcfilename", srcFile.getName());

fos = new FileOutputStream(new File("temp\\",count+".properties"));

prop.store(fos, "save partfiles info");

fos.close();

fis.close();

}

操作对象（对象序列化）

public static void writeObj() throws IOException {

/*
* 对象的序列化  ObjectOutputStream
* 将内存中的对象写到目的设备上。比如硬盘。
*/
FileOutputStream fos = new FileOutputStream("temp\\obj.object");
ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(new Person("mazi",23));

oos.close();

}

public static void readObj() throws IOException, ClassNotFoundException {

FileInputStream fis = new FileInputStream("temp\\obj.object");
ObjectInputStream ois = new ObjectInputStream(fis);

Object obj = ois.readObject();

Person p = (Person)obj;
System.out.println(p.getName()+":"+p.getAge());

ois.close();

}

public class Person implements Serializable {

/**
*
*/
private static final long serialVersionUID = 12367890L;
private static String name;
private transient/*瞬态*/ int age;

public Person() {
super();

}

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

}

对象的序列化是要将对象持久存放在设备中

瞬态

RandomAccessFile

/*
* RandomAccessFile:
* 1,既可以读取，有可以写入。
* 2,只对文件操作。
* 3,内部维护了一个大型的byte数组，将字节输入流和字节输出流进行封装。
* 4,通过索引的方式对数组中的元素进行操作，获取和设置索引的方法是getFilePointer,seek。
* 5,随机的访问的原理：就是通过操作索引的方法对指针进行自定义的指定位置来进行读写。
*
* 对于被随机读取的数据最好有规律。
*/

IOException

FileChannel

force(boolean)

public class PipedStreamDemo {

/**
* @param args
* @throws IOException
*/

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

PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
new Thread(new Input(in)).start();
new Thread(new Output(out)).start();

}

}

class Input implements Runnable{

private PipedInputStream in;

public Input(PipedInputStream in) {
super();
this.in = in;
}

@Override
public void run() {

byte[] buf = new byte[1024];
int len;
try {
len = in.read(buf);//阻塞。
String str = new String(buf,0,len);
System.out.println(str);
} catch (IOException e) {

e.printStackTrace();
}

}

}

class Output implements Runnable{

private PipedOutputStream out;

public Output(PipedOutputStream out) {
super();
this.out = out;
}

@Override
public void run() {

try {
out.write("哈哈哈，我来了!".getBytes());
} catch (IOException e) {

e.printStackTrace();
}
}

}

操作基本数据类型

public static void readData() throws IOException {

FileInputStream fis = new FileInputStream("temp\\data.txt");

DataInputStream dis = new DataInputStream(fis);

int num = dis.readInt();
System.out.println(num);

dis.close();
}

操作字节数组

ByteArrayInputStream bis = new ByteArrayInputStream("abcdef".getBytes());
ByteArrayOutputStream bos = new ByteArrayOutputStream();

int ch = 0;
while((ch=bis.read())!=-1){

bos.write(ch);
}
System.out.println(bos.toString());