Java学习笔记之输入输出流（二） 缓冲流、随机流、数组流、数据流、对象流
缓冲流(读一行)
BufferedReader类和BufferedWriter类创建的对象称为缓冲输入流、输出流，两者增强了读/写文件的能力。效率更高。
BufferedReader类的构造方法是:
BufferedReader(Reader in);
例:FileReader fr = new FileReader(“hello.txt”);
BufferedReader br = new BufferedReader(fr);
String str = br.readLine();
readLine()读取文本行，当读到文件的末尾时，返回null;
BufferedWriter类的构造方法是:
BufferedWriter(Writer out);
例:FileWriter fw = new FileWriter(“d:\\hello.txt”);
BufferedWriter bw = new BufferedWriter(fw);
bw.write(String s,int off,int len);
BufferedWriter流有自己独特的向文件写入一个回行符的方法。
bw.newLine();
例:
/**
* 将一段字符串写入文本，然后copy到其他的目录下
*/
package com.File_1;
import java.io.*;
import java.nio.Buffer;
public class huanchongliu {
public static void main(String[] args) {
// TODO Auto-generated method stub
String str[] = {"大家好","我叫小明","很高兴认识大家","跟大家在一起很快乐","谢谢."};
BufferedWriter bw = null;
BufferedReader br = null;
BufferedWriter bw2 = null;
try {
FileWriter file = new FileWriter("d:\\haha.txt");
bw = new BufferedWriter(file);
for(String s:str){
bw.write(s);
bw.newLine();
}
bw.close();
file.close();
FileReader fr = new FileReader("d:\\haha.txt");
br = new BufferedReader(fr);
String srr = null;
FileWriter fw2 = new FileWriter("e:\\你好啊.txt");
bw2 = new BufferedWriter(fw2);
String sr = null;
while((srr=br.readLine())!=null){
System.out.println(srr);
bw2.write(srr);
}
bw2.close();
fr.close();
br.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}//每个输入流输出流在用完的时候都要及时关闭，不然会发生一些未知的错误
随机流
RandomAccessFile类创建的对象称为随机访问文件流。
RandomAccessFile类创建的流和前面的输入流、输出流不同，RandomAccessFile类既是输入流，又是输出流。
RandomAccessFile类有两个构造方法:
RandomAccessFile(String name,String mode);参数name用来确定一个文件名，给出创建的流的源，也是流的目的地。参数mode取r(只读)或rw(可读/写)，决定创建的流对文件的访问权利。
RandomAccessFile(File file,String mode);参数file是一个File对象，给出创建的流的源，也是流的目的地。参数mode取r(只读)或rw(可读/写)，决定创建的流对文件的访问权利。
RandomAccessFile类中有一个方法seek(long a),用来定位RandomAccessFile流的读/写的位置，其中，参数a确定读/写位置距离文件开头的字节个数。
流还可以调用getFilePointer()方法获取流的当前读/写位置。
例:
/**
* 随机流 ，了解RandomAccessFile类的使用
*/
package com.File_1;
import java.io.*;
import java.util.Arrays;
public class shiyongwenbenduihuakuang {
public static void main(String[] args) {
// TODO Auto-generated method stub
RandomAccessFile rda = null;
RandomAccessFile rda2 = null;
int data[] = {1,2,3,4,5,6,7,8,9,10,11};
String s[] ={"nihao","dajiahao","jaj","hiuhf","oiuljl","ljhkfs"};
try {
rda = new RandomAccessFile("d:\\tent.txt", "rw");
for(int i:data){
rda.writeInt(i);
/**
* 这里存储在文本文档中的不是数字，而是乱码？？？？？？？？？？？
* 怎么解决？？？？
*/
//System.out.println();
}
rda2 = new RandomAccessFile("d:\\rrr.txt","rw");
for(String st:s){
//System.out.println();
rda2.writeBytes(st+"\r\n");
//System.out.println();
//rda2.seek(st.length());
}
rda2.close();
for(int i=data.length-1;i>=0;i--){
rda.seek(i*4);
System.out.print(rda.readInt()+" ");
}
rda.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}答案:
11 10 9 8 7 6 5 4 3 2 1 RandomAccessFile流的readLine()方法在读取含有非ASCII字符的文件时(比如汉字)会出现乱码现象，因此，需要把readLine()读取的字符串用ISO-8859-1重新编码存放在byte数组中，然后用计算机默认编码成字符串。
例:
/**
* 将文档中的汉字用RandomAccessFile流中的readLine()输出出来
*/
package com.File_1;
import java.io.*;
public class suijiliu_2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
RandomAccessFile rda = null;
try {
rda = new RandomAccessFile("d:\\haha.txt", "rw");
long length = rda.length();
long con =0;
rda.seek(con);
while(con答案:
大家好
我叫小明
很高兴认识大家
跟大家在一起很快乐
谢谢.
数组流
字节数组输出流ByteArrayInputStream和字节数组输出流ByteArrayOutputStream分别使用字节数组作为流的源和目标。
ByteArrayInputStream的构造方法是:
ByteArrayInputStream(byte[] buf);
ByteArrayInputStream(byte[] buf,int off,int len);
字节数组输出流调用public int read();方法可以顺序的读出一个字节，该方法返回读出的字节值，如果未读出字节，read()方法返回-1。
ByteArrayOutputStream();
ByteArrayOutputStream(int size);
第一个构造方法构造的字节数组输出流指向一个默认大小为32个字节的缓冲区，第二个指向size大小的缓冲区，如果超过了缓冲区的容量，缓冲区的容量就会自动增加。
public void write(int b); 方法顺序的向缓冲区写入一个字节。
public void write(byte b[],int off,int len);
public byte[] toByteArray(); 方法返回输出流写入缓存区的所示字节。
字节数组流对应的是字符数组流CharArrayReader和CharArrayWriter类，字符数组流分别使用字符数组作为流的源和目标。
例:
/**
* 使用数组流向内存(输出流的缓冲区)写入"How are you"和"您好",然后再从内存读取层写入的数据。
* 了解ByteArrayInputStream和ByteArrayOutputStream的用法(byte b[])
* 了解CharArrayReader和CharArrayWriter的用法(char c[])
*/
package com.File_2;
import java.io.*;
public class shuzuliu {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
byte b[] = "How are you".getBytes(); //用getBytes()方法将字符串转化成byte数组
//System.out.println(b);
ByteArrayOutputStream bao = new ByteArrayOutputStream();
bao.write(b);
ByteArrayInputStream bat = new ByteArrayInputStream(bao.toByteArray()); //返回输出流写入缓冲区的所示字节
byte ba[] = new byte[bao.toByteArray().length];
bat.read(ba); //将输入流的数据读入到ba[]中
String s = new String(ba); //将byte数组转化为String并输出
System.out.println(s);
char str[] = "您好".toCharArray(); //同理用toCharArray()方法将汉字转化成char数组
CharArrayWriter caw = new CharArrayWriter();
caw.write(str);
CharArrayReader car = new CharArrayReader(caw.toCharArray());
char sr[] = new char[caw.toCharArray().length];
car.read(sr);
System.out.println(new String(sr));
}
}答案:
How are you
您好
数据流
DataInputStream类和DataOutputStream类创建的对象称为数据输入流和数据输出流。
DataInputStream类的构造方法是:
DataInputStream(InputStream in); 创建的数据输入流指向一个由参数in指定的底层输入流
DataOutputStream类
DataOutputStream(OutputStream out);创建的数据输出流指向一个由参数out指定的底层输出流。
例:
/**
* 将几个java类型的数据写进一个文件中，然后再读出来
*/
package com.File_2;
import java.io.*;
public class shujuliu {
public static void main(String[] args) {
// TODO Auto-generated method stub
File file = new File("d:\\lalalal.txt");
try{
FileOutputStream fos = new FileOutputStream(file);
DataOutputStream dos = new DataOutputStream(fos);
dos.writeInt(120);
dos.writeFloat(3.1240f);
//dos.writeInt(5200);
dos.writeDouble(3.12045214);
dos.writeChar('A');
dos.writeChars("我叫小明");
}
catch(IOException e){
}
try{
FileInputStream fis = new FileInputStream(file);
DataInputStream dis = new DataInputStream(fis);
System.out.println(dis.readInt()); //这里read()的顺序要和上面write()的类型的顺序相同
System.out.println(dis.readFloat());
System.out.println(dis.readDouble());
System.out.println(dis.readChar());
//System.out.println(dis.readChar());
//字符串类型的要单独对待，用while来控制
char s ;
while((s=dis.readChar())!='\0'){
System.out.print(s); //'\0'表示空字符
}
}
catch(IOException e){}
}
}
/**
* DataInputStream和DataOutputStream类要在两个异常中建立，否则字符串类型的read()时会出错
**/答案:
120
3.124
3.12045214
A
我叫小明对象流
ObjectInoutStream类和ObjectOutputStream类创建的对象称为对象输入流和对象输出流。
对象输出流使用writeObject(Object obj)方法将一个对象obj写入到一个文件，对象输出流使用readObject()方法读取一个对象到程序中。
ObjectInoutStream类的构造函数是:
ObjectInoutStream(InputStream in);
例:FileInputStream fis = new FileInputStream(“d:tom.txt”);
ObjectInoutStream ois = new ObjectInoutStream(fis);
ObjectOutputStream类的构造方法如下:
ObjectOutputStream(OutputStrem out);
例:FileOutputStream fos = new FileOutputStream(“haha.txt”);
ObjectOutputStream oos = new ObjectOutputStream(fos);
知识点：
把Java对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为Java对象的过程称为对象的反序列化。
对象的序列化主要有两种用途：
1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
2） 在网络上传送对象的字节序列。
java.io.ObjectOutputStream代表对象输出流，
它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，
把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream代表对象输入流，
它的readObject()方法从一个源输入流中读取字节序列，
再把它们反序列化为一个对象，并将其返回。
只有实现了Serializable和Externalizable接口的类的对象才能被序列化。
Externalizable接口继承自Serializable接口，
实现Externalizable接口的类完全由自身来控制序列化的行为，
而仅实现Serializable接口的类可以采用默认的序列化方式 。
对象序列化包括如下步骤：
1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2） 通过对象输出流的writeObject()方法写对象。
对象反序列化的步骤如下：
1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2） 通过对象输入流的readObject()方法读取对象。
/**
* 使用对象流读/写Student类创建的对象
*/
package com.File_2;
import java.io.*;
public class duixiangliu {
public static void main(String[] args) {
// TODO Auto-generated method stub
Students student = new Students();
student.getNumber("小刚", 22, 176);
try {
FileOutputStream fos = new FileOutputStream("e:\\dasha.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(student);
fos.close();
oos.close();
FileInputStream fis = new FileInputStream("e:\\dasha.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Students stu = (Students)ois.readObject();
System.out.println(stu.setS());
System.out.println(stu.setData());
System.out.println(stu.setShengao());
stu.getNumber("小明", 20, 180);
System.out.println(stu.setS());
System.out.println(stu.setData());
System.out.println(stu.setShengao());
fis.close();
ois.close();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class Students implements Serializable{
String s;
private int data;
private double shengao;
public void getNumber(String s,int data,double shengao){
this.s = s;
this.data = data;
this.shengao = shengao;
}
public int setData(){
return data;
}
public double setShengao(){
return shengao;
}
public String setS(){
return s;
}
}答案:
小刚
22
176.0
小明
20
180.0