java常用数据流应用实例解析
这篇文章主要介绍了java常用数据流应用实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
按操作单位的不同分为：字节流（8bit）（InputStream、OuputStream）、字符流（16bit）（Reader、Writer）
按数据流的流向不同分为：输入流、输出流
按角色的不同分为：节点流、处理流
一、不带缓冲的流
1.文件字节输入流、文件字节输出流
packageanno;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassTest2{
publicstaticvoidmain(String[]args){
test1FileInputStream();
test2FileInputStream();
testFileOutputStream();
}
publicstaticvoidtest1FileInputStream(){
Stringpath="F:\\test.txt";
try{
FileInputStreamfs=newFileInputStream(path);
//设置一个数组接收文件的内容
//需要注意的是，如果数组设置的太小，那么可能出现读取的数据不完整或者乱码等情况
byte[]b=newbyte[30];
//文件输入流对象有一个返回值，返回的是读取数据的长度，如果读取到一个数据了，还会向后读一个，
//当读取完毕时会返回-1
intlen=0;
while((len=fs.read(b))!=-1){
//参数1是缓冲数据数组，参数2是从哪个位置开始转换成字符串，参数3是总共转换的长度
System.out.println(newString(b,0,len));
}
fs.close();
}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicstaticvoidtest2FileInputStream(){
Stringpath="F:\\test.txt";
Filef=newFile(path);
intl=(int)f.length();
try{
FileInputStreamfs=newFileInputStream(path);
byte[]b=newbyte[l];
//将读取的数据存入到b中
fs.read(b);
//将b转换成字符串并输出
System.out.println(newString(b));
fs.close();
}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicstaticvoidtestFileOutputStream(){//如果不存在该文件，则系统会新建一个
Stringpath1="F:\\test2.txt";
try{
FileOutputStreamfo=newFileOutputStream(path1);
Stringstr="这是我测试的输入";
fo.write(str.getBytes());//将数据写到byte中
fo.flush();//将内存中的数据写到文件中
fo.close();//关闭
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
在运行的过程中会遇到一些问题，比如说设置的byte数组来接收读取的数据，如果初始化长度给的比较小，那么读取的数据就不全，在进行test1FileInputStream()的实验中，即使按照：
intlen=0;
while((len=fs.read(b))!=-1){
//参数1是缓冲数据数组，参数2是从哪个位置开始转换成字符串，参数3是总共转换的长度
System.out.println(newString(b,0,len));
}
进行输出，如果byte设置的还是太小，就会出现：
这是我新建的test.txt�
��件
这种乱码问题，于是进行了第二种方法的尝试，即在传入数据之前首先获得要接收多少字节的数据，然后在进行接收（借鉴之前在golang中文件读取并显示的思想），然后就没有问题了，即test2FileInputStream()。
输出结果：
这是我新建的test.txt文件
2.使用字节流将一个文件复制到指定的文件夹下
publicstaticvoidcopyFile(){
Stringpath="F:\\test.txt";
Stringpath2="F:\\test2.txt";
try{
FileInputStreamfi=newFileInputStream(path);
FileOutputStreamfo=newFileOutputStream(path2);
Filef=newFile(path);
intl=(int)f.length();
byte[]b=newbyte[l];
intlen=0;
while((len=fi.read(b))!=-1){
fo.write(b,0,len);
}
fo.flush();
fo.close();
fi.close();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
综合使用之前读取的方式。
3.文件字符输入流、文件字符输出流
publicstaticvoidtestFileReader(){
Stringpath="F:\\test.txt";
try{
FileReaderfr=newFileReader(path);
//注意这里是char类型的数组了
char[]c=newchar[20];
intlen=0;
while((len=fr.read(c))!=-1){
System.out.println(newString(c,0,len));
}
fr.close();
}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicstaticvoidtestFileWriter(){
Stringpath1="F:\\test2.txt";
try{
FileWriterfw=newFileWriter(path1);
Stringstr="这是我测试的输入";
//注意这里可以直接写入字符串
fw.write(str);
fw.flush();//将内存中的数据写到文件中
fw.close();//关闭
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
需要注意的是定义char数组时仍然是需要知道数据是有多少字符的，不然长度不够，显示不全或者写入不全。（这里暂时还未了解怎么处理）
4.使用字符流将一个文件复制到指定的文件夹下
publicstaticvoidcopyFile2(){
Stringpath="F:\\test.txt";
Stringpath2="F:\\test2.txt";
try{
FileReaderfr=newFileReader(path);
FileWriterfw=newFileWriter(path2);
char[]c=newchar[30];
intlen=0;
while((len=fr.read(c))!=-1){
fw.write(c,0,len);
}
fw.flush();
fw.close();
fr.close();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
二、带缓冲的流
为了提高数据的读写速度，javaAPI提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。
根据数据操作单位可以把缓冲流分为：BufferedInputStream/BufferedOutputStream和BufferedReader/BufferedWriter。
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了些新方法。对于输出的缓冲流，写出的数据都会先在内存中缓存，使用flush()会将在内存中的数据立即写出。
1.缓冲字节输入流、缓冲字节输出流
packageanno;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassTest4{
publicstaticvoidmain(String[]args)throwsIOException{
testBufferedInputStream();
testBufferedOutputStream();
copyFile();
}
publicstaticvoidtestBufferedInputStream()throwsIOException{
FileInputStreamfi=newFileInputStream("F:\\test.txt");
//把文件字节输入流放入到缓冲输入流中
BufferedInputStreambi=newBufferedInputStream(fi);
byte[]b=newbyte[35];
intlen=0;
while((len=bi.read(b))!=-1){
System.out.println(newString(b,0,len));
}
bi.close();
fi.close();
}
publicstaticvoidtestBufferedOutputStream()throwsIOException{
FileOutputStreamfo=newFileOutputStream("F:\\test3.txt");
//把文件字节输入流放入到缓冲输入流中
BufferedOutputStreambo=newBufferedOutputStream(fo);
Stringstr="这是我测试的内容";
bo.write(str.getBytes());
bo.flush();
bo.close();
fo.close();
}
publicstaticvoidcopyFile(){
Stringpath="F:\\test.txt";
Stringpath2="F:\\test2.txt";
try{
FileInputStreamfi=newFileInputStream(path);
BufferedInputStreambi=newBufferedInputStream(fi);
FileOutputStreamfo=newFileOutputStream(path2);
BufferedOutputStreambo=newBufferedOutputStream(fo);
Filef=newFile(path);
intl=(int)f.length();
byte[]b=newbyte[l];
intlen=0;
while((len=bi.read(b))!=-1){
bo.write(b,0,len);
}
bo.flush();
bo.close();
fo.close();
bi.close();
fi.close();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
2.缓冲字符输入流、缓冲字符输出流
packageanno;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;
publicclassTest3{
publicstaticvoidmain(String[]args){
testBufferedReader();
testBufferedWriter();
copyFile();
}
publicstaticvoidtestBufferedReader(){
Stringpath="F:\\test.txt";
try{
FileReaderfr=newFileReader(path);
BufferedReaderbr=newBufferedReader(fr);
char[]c=newchar[17];
intlen=0;
while((len=br.read(c))!=-1){
System.out.println(newString(c,0,len));
}
br.close();
fr.close();
}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicstaticvoidtestBufferedWriter(){
Stringpath1="F:\\test2.txt";
try{
FileWriterfw=newFileWriter(path1);
BufferedWriterbw=newBufferedWriter(fw);
Stringstr="这是我测试的输入";
bw.write(str);//将数据写到chars中
bw.flush();//将内存中的数据写到文件中
bw.close();
fw.close();//关闭
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicstaticvoidcopyFile(){
Stringpath="F:\\test.txt";
Stringpath2="F:\\test2.txt";
try{
FileReaderfr=newFileReader(path);
BufferedReaderbr=newBufferedReader(fr);
FileWriterfw=newFileWriter(path2);
BufferedWriterbw=newBufferedWriter(fw);
char[]c=newchar[30];
intlen=0;
while((len=br.read(c))!=-1){
bw.write(c,0,len);
}
bw.flush();
bw.close();
fw.close();
br.close();
fr.close();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
三、转换流：用于字节流和字符流之间的转换
javaApi提供了两个转换流：InputStreamReader和OutputSreamWriter。
当字节流中的数据都是字符时，转换成字符流操作更高效
packageanno;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
publicclassTest5{
publicstaticvoidmain(String[]args)throwsIOException{
testInputStreamReader();
testOutputStreamWriter();
}
publicstaticvoidtestInputStreamReader()throwsIOException{
FileInputStreamfi=newFileInputStream("F:\\test.txt");
//字节流转换成字符流
//注意转换成的编码要和读取的文件一致
InputStreamReaderir=newInputStreamReader(fi,"utf-8");
char[]c=newchar[17];
intlen=0;
while((len=ir.read(c))!=-1){
System.out.println(newString(c,0,len));
}
ir.close();
fi.close();
}
publicstaticvoidtestOutputStreamWriter()throwsIOException{
FileOutputStreamfo=newFileOutputStream("F:\\test3.txt");
//转换字节输出流为字符输出流
OutputStreamWriterow=newOutputStreamWriter(fo,"utf-8");
Stringstr="这是我测试的内容";
ow.write(str);
ow.flush();
ow.close();
fo.close();
}
publicstaticvoidcopyFile(){
Stringpath="F:\\test.txt";
Stringpath2="F:\\test2.txt";
try{
FileInputStreamfi=newFileInputStream(path);
BufferedInputStreambi=newBufferedInputStream(fi);
FileOutputStreamfo=newFileOutputStream(path2);
BufferedOutputStreambo=newBufferedOutputStream(fo);
Filef=newFile(path);
intl=(int)f.length();
byte[]b=newbyte[l];
intlen=0;
while((len=bi.read(b))!=-1){
bo.write(b,0,len);
}
bo.flush();
bo.close();
fo.close();
bi.close();
fi.close();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
四、标准输入输出流
packageanno;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclassTest6{
publicstaticvoidmain(String[]args)throwsIOException{
//testSystemIn();
testWriterToTxt();
}
publicstaticvoidtestSystemIn()throwsIOException{
//创建一个获取键盘输入的输入流
InputStreamReaderir=newInputStreamReader(System.in);
//将输入流放在缓冲中
BufferedReaderbr=newBufferedReader(ir);
Stringstr="";
while((str=br.readLine())!=null){
System.out.println(str);
}
}
//将控制台的输入写入到txt文件中
publicstaticvoidtestWriterToTxt()throwsIOException{
//创建一个获取键盘输入的输入流
InputStreamReaderir=newInputStreamReader(System.in);
//将输入流放在缓冲中
BufferedReaderbr=newBufferedReader(ir);
BufferedWriterbw=newBufferedWriter(newFileWriter("F:\\test5.txt"));
Stringline="";
while((line=br.readLine())!=null){
if(line.equals("over")){
break;
}
bw.write(line);
}
bw.flush();
bw.close();
br.close();
ir.close();
}
}
五、数据流
packageanno;
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassTest7{
publicstaticvoidmain(String[]args)throwsIOException{
testDataOutputStream();
testDataInputStream();
}
//用数据输出流写到文件中的基本类型数据是乱码，不能辨认出来，需要数据输入流读取
publicstaticvoidtestDataOutputStream()throwsIOException{
DataOutputStreamds=newDataOutputStream(newFileOutputStream("F:\\test6.txt"));
ds.writeDouble(1.35d);
ds.flush();
ds.close();
}
publicstaticvoidtestDataInputStream()throwsIOException{
DataInputStreamds=newDataInputStream(newFileInputStream("F:\\test6.txt"));
System.out.println(ds.readDouble());
ds.close();
}
}
六、对象流
用于存储和读取对象的处理流，它的强大之处就是可以把java中对象写入到数据源中，也能把对象从数据源中还原出来。
序列化：用ObjectOutputStream类将一个对象下入io流中；
反序列化：用ObjectInputStream类从io流中恢复对Java对象；
packageanno;
importjava.io.Serializable;
publicclassPersonimplementsSerializable{
//用来标识的UID
privatestaticfinallongserialVersionUID=1L;
Stringname;
intage;
}
packageanno;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
publicclassTest8{
publicstaticvoidmain(String[]args)throwsIOException,ClassNotFoundException{
//testSerializable();
testDeSerializable();
}
//序列化
publicstaticvoidtestSerializable()throwsIOException{
ObjectOutputStreamoos=newObjectOutputStream(newFileOutputStream("F:\\test7.txt"));
Personp=newPerson();
p.name="tom";
p.age=12;
oos.writeObject(p);
oos.flush();
oos.close();
}
//反序列化
publicstaticvoidtestDeSerializable()throwsIOException,ClassNotFoundException{
ObjectInputStreamois=newObjectInputStream(newFileInputStream("F:\\test7.txt"));
Personp=null;
Objectobj=null;
obj=ois.readObject();
p=(Person)obj;
System.out.println(p.name);
System.out.println(p.age);
ois.close();
}
}
七、RandomAccessFile
支持随机访问的方式，程序可以直接跳转到文件的任意位置地方来进行读写。支持只访问文件的部分内容，可以向已存在的文件后追加内容。
RandomAccessFile对象包含一个记录指针，用以标记当前读写的位置。
RandomAccessFile类对象可以自由地移动和记录指针：
- longgetFilePoint()：获取文件记录指针的当前位置；
- voidseek(longpos)：将文件记录指针移动到指定位置；
packageanno;
importjava.io.IOException;
importjava.io.RandomAccessFile;
publicclassTest9{
publicstaticvoidmain(String[]args)throwsIOException{
//testRandomAccessFileRead();
testRandomAccessFileWrite();
}
publicstaticvoidtestRandomAccessFileRead()throwsIOException{
//构造方法有两个参数，参数一为路径，参数二为访问方式
//r:只读
//rw:可写可读
//rwd:可写可读，同步内容跟新
//rws:可写可读，同步内容和元数据跟新；
RandomAccessFileacf=newRandomAccessFile("F:\\test7.txt","r");
//设置文件起始的读取位置
acf.seek(5);
byte[]b=newbyte[35];
intlen=0;
while((len=acf.read(b))!=-1){
System.out.println(newString(b,0,len));
}
acf.close();
}
publicstaticvoidtestRandomAccessFileWrite()throwsIOException{
//构造方法有两个参数，参数一为路径，参数二为访问方式
//r:只读
//rw:可写可读
//rwd:可写可读，同步内容跟新
//rws:可写可读，同步内容和元数据跟新；
RandomAccessFileacf=newRandomAccessFile("F:\\test7.txt","rw");
//设置文件起始的写入位置，0代表开头，acf.length代表文件末尾
acf.seek(acf.length());
acf.write("你好".getBytes());
acf.close();
}
}
总结：
流适用于处理数据的。
处理数据时，一定要明确数据源，与数据目的地：数据源可以是文件，也可以是键盘；数据目的地可以是文件、显示器或其它设备。
流只是帮助数据进行传输，并对传输的数据进行处理，比如过滤处理、转换处理等。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。