黑马程序员——41，打印流，合并流，对象序列化，管道流，RandomAccessFile
----------- android 培训
、 java培训
、java学习型技术博客、期待与您交流！------------
黑马程序员——41，打印流，合并流，对象序列化，管道流，RandomAccessFile
一：打印流----》
字节打印流PrintStream：其构造函数可以接收File对象，String型路径，字节流
字符打印流PrintWriter:其构造函数可以接收File对象，String型路径，字节流和字符流，应用更加广泛。
所以主要介绍PrintWriter的使用，比较常用的构造函数有两个PrintWriter(OutputStream out,boolean autoFlush)和PrintWriter(Writer out, boolean autoFlush)，一般后面填写的都是true，表示自动刷新。
import java.io.*;
class Ioliou25
{
public static void main(String[] args)throws IOException
{
File f=new File("f:\\yyyyyyyk.txt");
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
// PrintWriter pw=new PrintWriter(System.out,true);//这个带true的就自动刷新，不用写flush方法了
// InputStreamReader是字节与字符的桥梁
//PrintWriter pw=new PrintWriter(f,true);//这种写法编译错误，PrintWriter类没有这种构造函数
/*
PrintWriter构造函数里面可以带true的只有
PrintWriter(OutputStream out,boolean autoFlush)
PrintWriter(Writer out, boolean autoFlush)
*/
// PrintWriter pw=new PrintWriter(System.out);
PrintWriter pw=new PrintWriter(new FileWriter(f),true);//使用FileWriter嵌套f的话就可以带true
String s=null;
while((s=bufr.readLine())!=null)
{
if(s.equals("over"))//设置结束语句
break;
// pw.write(s.toUpperCase()); //没有换行
pw.println(s.toUpperCase());//这个使用println方法更为常见
//pw.flush();
}
bufr.close();
pw.close();
}
public static void soc(Object obj)//打印方法
{
System.out.println(obj);
}
}
二：合并流SquenceInputStream----》
SequenceInputStream的构造函数有两个：
public SequenceInputStream(Enumeration e)//接收的是Enumeration的实例，该构造函数主要用在需要合并两个以上的读取流的情况下
public SequenceInputStream(InputStream s1，InputStream s2)//按顺序接收读取流s1和s2（注意顺序不能调乱）import java.io.*;
import java.util.*;
class Ioliou27
{
public static void main(String[] args)throws IOException
{
qiege();
//hebing();
hebing2();
}
public static void qiege()/*切割文件*/throws IOException
{
File f=new File("f:\\8.11\\8.11练习.png");//建立文件对象
FileInputStream fis=new FileInputStream(f);//关联目的文件
FileOutputStream fos=null;
int i=0,k=0;
byte[] by=new byte[1024*10];
while((i=fis.read(by))!=-1)
{
k++;
fos=new FileOutputStream("f:\\8.11\\8.11练习"+k+".part");
//每一次循环k值都不同所以对应有不同的关联的碎片文件
fos.write(by,0,i);
}
fis.close();
fos.close();
}
public static void hebing()/*合并文件*/throws IOException
{
ArrayList al=new ArrayList();
//这里采用的是ArrayList集合
for(int x=1;x<=4;x++)
{
al.add(new FileInputStream("f:\\8.11\\8.11练习"+x+".part"));
//把与文件相关联的流装进集合中
}
final Iterator it= al.iterator();
//被匿名内部类访问的局部成员要被final修饰
Enumeration en=new Enumeration()
{
//直接覆盖hasMoreElements和nextElement方法
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("f:\\8.11\\8.11练习合并.png");//确定目的地的
int i=0;
byte[] by= new byte[1024];
while((i=sis.read(by))!=-1)
{
fos.write(by,0,i);
}
sis.close();
fos.close();
}
public static void hebing2()/*第二种合并方法*/throws IOException
{
Vector v=new Vector();//直接用Vector集合来装流对象
for(int x=1;x<=4;x++)
{
v.add(new FileInputStream("f:\\8.11\\8.11练习"+x+".part"));
}
Enumeration en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("f:\\8.11\\8.11练习合并2.png");
int i=0;
byte[] by=new byte[1024*10];
while((i=sis.read(by))!=-1)
{
fos.write(by,0,i);
}
sis.close();
fos.close();
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
三：对象的序列化ObjectOutputStream----》
对象序列化就是把对象存放在硬盘上，存放对象所属的类必须是实现了Serializable类。虚拟机会给实现了Serializable接口的类划分UID号标示，UID号与类成员有关，如果类成员有改变，虚拟机会重新划分UID号的，当然也可以自动在该类中添加固定的UID号：public static final long serialazableUID=42L;这样无论该类的成员怎么变化该类的UID号都是固定不变的。
为什么会有这个UID号的存在？
因为对象都是按照对象建立的，如果没有UID号的话，那么把一个类的对象存放在硬盘上，接着该类成员有所改变，程序再读取该对象的话，虚拟机就会容易混乱。
被static或者transient修饰的成员无法被序列化。
调用readObject读取对象，调用writeObject写入对象。
import java.io.*;
import java.util.*;
class Ioliou28
{
public static void main(String[] args)throws Exception//主函数
{
// xieru();
duqu() ;
}
public static void xieru()/*写入*/ throws Exception
{
File f=new File("f:\\北方.txt");
FileOutputStream fos=new FileOutputStream(f);
ObjectOutputStream oops=new ObjectOutputStream(fos);
oops.writeObject(new Per("呼呼呼",26,"jkl"));
//写入对象,写入的对象所属的类必须是实现了Serializable借口
oops.close();
}
public static void duqu()/*读取*/ throws Exception
{
File f=new File("f:\\北方.txt");
FileInputStream fos=new FileInputStream(f);
ObjectInputStream oips=new ObjectInputStream(fos);
Object obj=oips.readObject();//readObject方法返回的是Object类型的对象
//readObject方法会抛出一个ClassNotFoundException,为了简便，方法上声明抛出都是Exception
Per p =(Per)obj;
oips.close();
soc(p);
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
class Per implements Serializable
{
//public static final long serializableUID=42L;
static String name="无名";//静态成员不能被序列化
private int age;
transient String country="cn";//transient修饰的成员也不能被序列化
Per(String name, int age,String country)
{
this.name=name;
this.age=age;
this.country=country ;
}
public String toString()
{
return name+":"+age+":"+country;
}
}
四：管道流PipeInputStream和PipeOutputSatream----》
管道输入流和管道输出流可以用connect方法连接在一起，通常与多线程密切相关：一般是一条线程负责管道输入流，一条线程负责管道输出流。
class Read() /*读取线程*/ implements Runnable throws IOException
{
private PipedInputStream pis=null;
Read(PipedInputStream pis)
{
this.pis=pis;
}
public void run()
{
int i=0;
byte[] by=new byte[1024];
while((i=pis.read(by))!=-1)
{
//填写内容
}
}
}
class Write() /*写入线程*/implements Runnable throws IOException
{
private PipedOutputStream pos=null;
Write(PipedOutputStream pos)
{
this.pos=pos;
}
public void run( )
{
// int i=0;
// byte[] by=new byte[1024];
pos.write("huhuhu".getBytes());
}
}
import java.io.*;
class Ioliou29
{
public static void main(String[] args)throws IOException
{
PipedInputStream pis=new PipedInputStream();
PipedOutputStream pos=new PipedOutputStream();
pis.connect(pos);//管道输入流和管道输出流连接
//开启线程
new Thread(new Read(pis)).start();
new Thread(new Write(pos)) .start();
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
五：RandomAccessFile----》
RandomAccessFile也是IO包的成员，里面封装了字节写入流和字节读取流，所以可以选取模式，常用的有两种模式”r”只读和”rw”读写，该类里面封装了一个非常大的数组，还有一个指针指示数组，通过getFilePointer方法获取指针位置，通过seek方法调整指针位置。
有两个常用的构造函数，都是用来关联文件并且确定模式的：
public RandomAccessFile(File file, String mode)throws FileNotFoundException
public RandomAccessFile(String name,String mode)throws FileNotFoundExceptionpublic void close()throws IOException //关闭
public int read()throws IOException //读取一个数据字节
public int read(byte[] b)throws IOException //按照数组长度读取
public int read(byte[] b,int off,int len)throws IOException//按照数组中实际接收数据的长度读取
public final boolean readBoolean()throws IOException//读取一个boolean
public final byte readByte()throws IOException//读取一个字节
public final char readChar()throws IOException//读取一个字符
public final double readDouble()throws IOException//读取一个double数据
public final float readFloat()throws IOException//读取一个float数据
public final int readInt()throws IOException//读取一个int数据import java.io.*;
class Ioliou30
{
public static void main(String[] args) throws IOException
{
write();
read();
}
public static void write()throws IOException
{
File f=new File("f:\\学习.txt");
RandomAccessFile raf=new RandomAccessFile(f,"rw");//关联文件并确定操作模式
//如果文件不存在会自动创建
raf.write("一二三".getBytes());
raf.writeInt(56);//写入数字时最好用writeInt,以32位形式写入
raf.write("四五六".getBytes());
raf.writeInt(85);//写入数字时最好用writeInt,以32位形式写入
}
public static void read()throws IOException
{
File f=new File("f:\\学习.txt");
RandomAccessFile raf=new RandomAccessFile(f,"rw");//关联文件并确定操作模式
soc("raf.getFilePointer()="+raf.getFilePointer());//getFilePointer方法返回内部数组指针位置
//raf.seek(2);//调整内部数组的指针指向第2位
byte[] by=new byte[4];
raf.read(by);//按照字节数组读取
String s=new String(by);//按照字节数组转成字符串
int i= raf.readInt();//按照32位读取数据
soc(s);
soc(i);
}
public static void soc(Object obj)
{
System.out.println(obj);
}
}
----------- android培训、java培训、java学习型技术博客、期待与您交流！------------