JAVA之旅三十.docx
《JAVA之旅三十.docx》由会员分享，可在线阅读，更多相关《JAVA之旅三十.docx（21页珍藏版）》请在冰豆网上搜索。
JAVA之旅三十
JAVA之旅（三十）
一.打印流PrintWriter
打印流有PrintWriter和PrintStream,他的特点可以直接操作输入流还有文件
该流提供了打印方法，可以将各种数据类型原样打印
file对象File
字符串路径String
字节打印流
字符打印流
我们演示一遍大家就对此有所了解了
packagecom.lgl.hellojava;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
publicclassHelloJJAVA{
publicstaticvoidmain（String[]args）{
try{
BufferedReaderbufr=newBufferedReader（newInputStreamReader（
System.in））;
PrintWriteroWriter=newPrintWriter（System.out,true）;
Stringline=null;
while（（line=bufr.readLine（））!
=null）{
if（line.equals（"over"））{
break;
}
oWriter.write（line）;
}
oWriter.close（）;
bufr.close（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
要想存到文件里，也是可以直接把文件给放进去的
二.合并流
我们来看看什么是合并流，在API文档上说，他可以串联流
packagecom.lgl.hellojava;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.SequenceInputStream;
importjava.util.Enumeration;
importjava.util.Vector;
publicclassHelloJJAVA{
publicstaticvoidmain（String[]args）{
try{
Vectorv=newVector（）;
v.add（newFileInputStream（"1.txt"））;
v.add（newFileInputStream（"2.txt"））;
Enumerationelements=v.elements（）;
SequenceInputStreamsis=newSequenceInputStream（elements）;
FileOutputStreamfos=newFileOutputStream（"3.txt"）;
byte[]buf=newbyte[1024];
intlen=0;
while（（len=sis.read（buf））!
=-1）{
fos.write（buf,0,len）;
}
fos.close（）;
sis.close（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
把1.txt和2.txt乃至add更多的内容合并到3.txt文件中，这就是流的合并
三.切割文件
合并文件可以，那肯定可以切割了，我们来看下具体是怎么去制作的
//切割文件
publicstaticvoidsplitFile（）{
try{
FileInputStreamfis=newFileInputStream（"1.jpg"）;
FileOutputStreamfos=null;
byte[]buf=newbyte[1024*1024];
intlen=0;
intcount=1;
while（（len=fis.read（buf））!
=-1）{
fos=newFileOutputStream（（count++）+".patch"）;
fos.write（buf,0,len）;
fos.close（）;
}
fis.close（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
当运行结束之后，我们可以看到
已经成功切割了
切割完我们可以合并了
//合并文件
publicstaticvoidmerge（）{
ArrayListal=newArrayList<>（）;
for（inti=1;i<=2;i++）{
try{
al.add（newFileInputStream（i+".patch"））;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
Iteratoriterator=al.iterator（）;
Enumerationen=newEnumeration（）{
@Override
publicbooleanhasMoreElements（）{
//TODOAuto-generatedmethodstub
returniterator.hasNext（）;
}
@Override
publicFileInputStreamnextElement（）{
//TODOAuto-generatedmethodstub
returniterator.next（）;
}
};
try{
SequenceInputStreamseq=newSequenceInputStream（en）;
FileOutputStreamfos=newFileOutputStream（"2.jpg"）;
byte[]buf=newbyte[1024];
intlen=0;
while（（len=seq.read（buf））!
=-1）{
fos.write（buf,0,len）;
}
fos.close（）;
seq.close（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
这样我们就把图片拷贝出来了，可以看到
这段代码是非常帮的，我们一定会用到的，希望能用的上
四.对象的序列化Serializable
其实就是可以直接操作对象的流，他会实现一个Serializable（）接口，我们用代码来看下他是怎么用的，我们直接写读取对象的类了
packagecom.lgl.hellojava;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.Serializable;
publicclassHelloJJAVA{
publicstaticvoidmain（String[]args）{
//writeObj（）;
readObj（）;
}
privatestaticvoidreadObj（）{
try{
ObjectInputStreamois=newObjectInputStream（newFileInputStream（
"obj.txt"））;
Personp=（Person）ois.readObject（）;
System.out.println（p）;
ois.close（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（ClassNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
privatestaticvoidwriteObj（）{
try{
ObjectOutputStreamoos=newObjectOutputStream（
newFileOutputStream（"obj.txt"））;
oos.writeObject（newPerson（"zhangsan",20））;
oos.close（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
classPersonimplementsSerializable{
Stringname;
intage;
publicPerson（Stringname,intage）{
this.name=name;
this.age=age;
}
}
OK,自己去验证一下
五.管道流
输入输出可以直接进行连接，通常结合线程使用
packagecom.lgl.hellojava;
importjava.io.IOException;
importjava.io.PipedInputStream;
importjava.io.PipedOutputStream;
publicclassHelloJJAVA{
publicstaticvoidmain（String[]args）{
PipedInputStreampi=newPipedInputStream（）;
PipedOutputStreampo=newPipedOutputStream（）;
try{
pi.connect（po）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
Readread=newRead（pi）;
Writewrite=newWrite（po）;
newThread（read）.start（）;
newThread（write）.start（）;
}
}
classReadimplementsRunnable{
privatePipedInputStreamin;
publicRead（PipedInputStreamin）{
this.in=in;
}
@Override
publicvoidrun（）{
try{
byte[]buf=newbyte[1024];
intlen=in.read（buf）;
Strings=newString（buf,0,len）;
System.out.println（s）;
in.close（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
classWriteimplementsRunnable{
privatePipedOutputStreamout;
publicWrite（PipedOutputStreamout）{
this.out=out;
}
@Override
publicvoidrun（）{
try{
out.write（"yes".getBytes（））;
out.close（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
现在就可以联通了
六.RandomAccessFile
这是一个很特别的家伙，他继承的是Object
该类不是IO体系中的子类
但是他是IO包中的成员，他同时具备读写功能
内部封装了一个数组，而且通过指针对数组中的元素进行操作
可以通过getFilePointer或者指针位置同时可以通过seek改变指针的位置
其实完成读写的原理就是内部封装了字节输入，输出流，通过构造函数可以看出该类具备操作文件的能力，而且操作文件还有模式
packagecom.lgl.hellojava;
importjava.io.FileNotFoundException;
importjava.io.IOException;
importjava.io.RandomAccessFile;
publicclassHelloJJAVA{
publicstaticvoidmain（String[]args）{
writeFile（）;
}
publicstaticvoidwriteFile（）{
try{
RandomAccessFileraf=newRandomAccessFile（"1.txt","rw"）;
raf.write（"zhangssan".getBytes（））;
raf.writeInt（99）;
raf.close（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
这只是一个写的过程，我们的特性还没有体现出来，我们来看下他是怎么读的
privatestaticvoidReadFile（）{
try{
RandomAccessFileraf=newRandomAccessFile（"1.txt","r"）;
//调整对象指针
raf.seek（8*0）;
byte[]buf=newbyte[1024];
raf.read（buf）;
Strings=newString（buf）;
System.out.println（s）;
raf.close（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
如果操作的文件不存在，就会自动创建，如果存在，直接覆盖
七.IO其他类
IO其他包里，还有一些其他的使用
操作基本数据类型
字节数组
字符数组
1.基本数据类型
我们先来看下基本数据类型的，我直接读写都写出来
publicstaticvoidreadData（）{
try{
DataInputStreamdis=newDataInputStream（newFileInputStream（
"data.txt"））;
intnum=dis.readInt（）;
booleand=dis.readBoolean（）;
System.out.println（num+""+d+""）;
dis.close（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTce（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
//基本数据类型
publicstaticvoidwriteDatea（）{
try{
DataOutputStreamdos=newDataOutputStream（newFileOutputStream（
"data.txt"））;
dos.writeInt（55）;
dos.writeBoolean（true）;
dos.close（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
读取基本数据类型
二.字节数组
这个偶尔用下，但是我们还是要去学习一下的
ByteArrayInputStream：
在构造的时候，需要接收数据源，而且数据源是一个字节数组
ByteArrayOutputStream：
在构造的时候，不用定义数据的目的，因为该对象中已经内部封装了可变程度的字节数组
因为这两个流的对象都操作的数组，并且没有使用系统资源，所以，不用进行close关闭！
packagecom.lgl.hellojava;
importjava.io.ByteArrayInputStream;
importjava.io.ByteArrayOutputStream;
publicclassHelloJJAVA{
publicstaticvoidmain（String[]args）{
//数据源
ByteArrayInputStreambis=newByteArrayInputStream（"123".getBytes（））;
//数据目的
ByteArrayOutputStreambos=newByteArrayOutputStream（）;
intch=0;
while（（ch=bis.read（））!
=-1）{
bos.write（ch）;
}
System.out.println（bos.size（））;
System.out.println（bos.toString（））;
}
}
是不是比较简单，字符流我就不说了，和字节流是类似的，但是他会衍生出一个新的内容就是字符编码
八.字符编码
这些乱七八糟的编码说真的，东西还是挺多的，但是我并不想讲那么多，因为本身我也不是很清楚，其次这玩意大致的知道一点就可以了（个人觉得），什么ASCLL,GBK，UTF-8之类的
Strings="hellojava";
byte[]b1=s.getBytes（）;
System.out.println（Arrays.toString（b1））;
他得到的是什么？
现在我换一个编码
byte[]b1=s.getBytes（"GBK"）;
1
1
我设置成GBK，他的值是一样的，说明默认的是GBK
九.练习
写完这个练习，我们的I/O流就GG了，感慨颇多，写I/O写了很多篇，但是仍然晕乎乎的，应该继续加深印象的，我们来看下需求
有五个学生，每个学生有三门课程，从键盘输入以下数据（包括姓名，三门课成绩），输入的格式，如zhangsan,30,60,96计算出总成绩，并把学生的信息和计算出的总分数高低顺序存入文件student.txt中去；
好了，开始撸代码了
packagecom.lgl.hellojava;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.util.Set;
importjava.util.TreeSet;
publicclassHelloJJAVA{
publicstaticvoidmain（Stri
升级会员 