------------------------------android培训、java培训、期待与您交流!----------------------------------------------------------------
IO包中的其他类
打印流 •PrintWriter与PrintStream
• 可以直接操作输入流和文件。
序列流 •SequenceInputStream
• 对多个流进行合并。
操作对象
• ObjectInputStream与ObjectOutputStream
• 被操作的对象需要实现Serializable (标记接口);
1. java.lang.Object
java.io.OutputStream
java.io.FilterOutputStream
java.io.PrintStream
字节打印流:
PrintStream
构造函数可以接收的参数类型:
1,file对象。File
2,字符串路径。String
3,字节输出流。OutputStream
java.lang.Object
java.io.Writer
java.io.PrintWriter
字符打印流:
PrintWriter
构造函数可以接收的参数类型:
1,file对象。File
2,字符串路径。String
3,字节输出流。OutputStream
4,字符输出流,Writer。
importjava.io.*;
class PrintStreamDemo
{
public static void main(String[] args)throws IOException
{
BufferedReader bufr =
new BufferedReader(newInputStreamReader(System.in));
PrintWriterout = new PrintWriter(new FileWriter("a.txt"),true);//用来自动刷新.
/*public PrintWriter(Writer out, boolean autoFlush
autoFlush - boolean 变量;如果为 true,刷新输出缓冲区*/
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))//结束标记
break;
out.println(line.toUpperCase());//相当于BufferedWriter中的newLine()方法.换行的标记.
//out.flush();放在缓冲区中,要刷新.
}
out.close();
bufr.close();
}
}
2. java.lang.Object
java.io.InputStream
java.io.SequenceInputStream
没有SequenceOutputStream,
需求:将多个文件中的数据合并成一个文件.
SequenceInputStream
(Enumeration<? extends InputStream> e)
通过记住该参数初始化新创建的 SequenceInputStream
,该参数必须是生成运行时类型为 InputStream
对象的 Enumeration
型参数。
importjava.io.*;
importjava.util.*;
classSequenceDemo
{
public static void main(String[] args)throws IOException
{
Vector<FileInputStream>v = new Vector<FileInputStream>();//只有Vector中才有返回Enumeration
的方法.
elements() |
v.add(newFileInputStream("c:\\1.txt"));
v.add(newFileInputStream("c:\\2.txt"));
v.add(newFileInputStream("c:\\3.txt"));
Enumeration<FileInputStream>en = v.elements();
SequenceInputStream sis = newSequenceInputStream(en);//多个读取流对象变成一个读取流.
FileOutputStream fos = newFileOutputStream("c:\\4.txt");//字节流 不涉及到编码.
byte[] buf= new byte[1024];//建立缓冲区.
int len =0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
需求:将一个文件中的数据切割成多个文件.
importjava.io.*;
importjava.util.*;
classSplitFile
{
public static void main(String[] args)throws IOException
{
//splitFile();
merge();
}
public static void merge()throws IOException//首先要创建集合,Vertor集合效率低,
{
ArrayList<FileInputStream>al = new ArrayList<FileInputStream>();
for(int x=1; x<=3; x++)
{
al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));//多个流对象添加进去,和读取流对象相关联,然后在添加到集合中.
}
finalIterator<FileInputStream> it = al.iterator();//叠代器里有Enumeration
//final修饰匿名内部类.
Enumeration<FileInputStream>en = new Enumeration<FileInputStream>()
{
public booleanhasMoreElements()
{
return it.hasNext();
}
public FileInputStreamnextElement()
{
return it.next();
}
};
SequenceInputStreamsis = new SequenceInputStream(en);//需要传入Enumeration
FileOutputStream fos = newFileOutputStream("c:\\splitfiles\\0.bmp");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)//往buf中读数据.
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
public static void splitFile()throwsIOException
{
FileInputStream fis = new FileInputStream("c:\\1.bmp");//源只有一个.
FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];//刚好1M的数据.
int len = 0;
int count= 1;//从1开始
while((len=fis.read(buf))!=-1)//每循环一次,生成一个文件.
{
fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");//碎片文件.part, 目的有多个,在循环里new
fos.write(buf,0,len);//往流里写数据.
fos.close();
}
fis.close();
}
}
3. java.lang.Object
java.io.InputStream
java.io.ObjectInputStream
java.lang.Object
java.io.OutputStream
java.io.ObjectOutputStream
对象的持久化存储.或者叫对象的序列化.
需求:将一个对象存储到文件中.
ObjectInputStream和ObjectOutputStream成对出现.
importjava.io.*;
classObjectStreamDemo
{
public static void main(String[] args)throws Exception
{
//writeObj();
readObj();
}
public static void readObj()throwsException//将封装的对象中的数值读出来.
{
ObjectInputStream ois = newObjectInputStream(new FileInputStream("obj.txt"));//能直接操作对象的流.
Person p =(Person)ois.readObject();
System.out.println(p);
ois.close();
}
public static void writeObj()throwsIOException
{
ObjectOutputStream oos =
new ObjectOutputStream(newFileOutputStream("obj.txt"));
oos.writeObject(newPerson("lisi0",399,"kr"));//将对象写入硬盘中.
oos.close();
}
}
importjava.io.*;
classPerson implements Serializable//是个标记接口,没有方法来实现.
{
public static final long serialVersionUID= 42L;//自定义一个UID,不让编译器生成.给类定义一个固定标识.
private String name;
transientint age;//对非静态成员 也不想被序列化.虽然在堆内存中被序列化,但在文本中不被序列化.
static String country=”cn”;//静态不能被序列化.不在堆内存中
Person(String name,int age,Stringcountry)
{
this.name = name;
this.age = age;
this.country = country;
}
public String toString()
{
returnname+":"+age+":"+country;
}
}
4. java.lang.Object
java.io.InputStream
java.io.PipedInputStream
管道流
• PipedInputStream和PipedOutputStream
• 输入输出可以直接进行连接,通过结合线程使用。
• 涉及到多线的IO流对象. 集合当中涉及到IO流的是Properties
需求: 用多线程演示管道流.
importjava.io.*;
class Read implements Runnable//读的线程.
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try
{
byte[] buf = newbyte[1024];
System.out.println("读取前。。没有数据阻塞");
int len = in.read(buf);
System.out.println("读到数据。。阻塞结束");
String s= newString(buf,0,len);
System.out.println(s);//输出读到的数据.
in.close();
}
catch (IOException e)
{
throw newRuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable//写的线程.
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
try
{
//System.out.println("开始写入数据,等待6秒后。");//演示效果.
//Thread.sleep(6000);
out.write("piped lai la".getBytes());//用字节写入.
out.close();
}
catch (Exception e)
{
throw newRuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
public static void main(String[] args)throws IOException
{
PipedInputStream in = newPipedInputStream();
PipedOutputStream out = newPipedOutputStream();
in.connect(out);
Read r = new Read(in);//自定义的类Read.
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}
5. java.lang.Object
java.io.InputStream
java.io.FilterInputStream
java.io.DataInputStream
java.lang.Object
java.io.OutputStream
java.io.FilterOutputStream
java.io.DataOutputStream
可以用于操作基本数据类型的数据的流对象。
操作基本数据类型
• DataInputStream与DataOutputStream
需求:用DataInputStream与DataOutputStream演示操作基本数据类型.
importjava.io.*;
classDataStreamDemo
{
public static void main(String[] args)throws IOException
{
}
publicstatic void writeData()throws IOException//基本数据类型写入.
{
DataOutputStream dos = newDataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(234);
dos.writeBoolean(true);
dos.writeDouble(9887.543);//8个字节. 该 long
值以 8-byte 值形式写入基础输出流
dos.close();
ObjectOutputStream oos = null;
oos.writeObject(new O());
}
publicstatic void readData()throws IOException//将写进的数据读出来.
{
DataInputStream dis = newDataInputStream(new FileInputStream("data.txt"));
int num = dis.readInt();
boolean b = dis.readBoolean();
double d = dis.readDouble();
System.out.println("num="+num);
System.out.println("b="+b);
System.out.println("d="+d);
dis.close();
}
writeUTF
(String str)
以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
publicstatic void writeUTFDemo()throws IOException
{
DataOutputStream dos = newDataOutputStream(new FileOutputStream("utfdate.txt"));
dos.writeUTF("你好");//英文不涉及UTF-8编码.
dos.close();
}
static String | readUTF(DataInput in) |
publicstatic void readUTFDemo()throws IOException//
{
DataInputStream dis = newDataInputStream(new FileInputStream("utf.txt"));
String s = dis.readUTF();//writeUTF()写进的要readUTF()读出来.
System.out.println(s);
dis.close();
}
}
6. java.lang.Object
java.io.InputStream
java.io.ByteArrayInputStream
java.lang.Object
java.io.OutputStream
java.io.ByteArrayOutputStream
操作字节数组的流对象:用流的思想操作思想.
• ByteArrayInputStream与ByteArrayOutputStream
• 这个流对象没有调用底层的资源.
• 关闭ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用, 不会产生任何 IOException。
ByteArrayInputStream:在构造的时候,需要接收数据源,。而且数据源是一个字节数组。
ByteArrayOutputStream: 在构造的时候,不用定义数据目的,因为该对象中已经内部封装了可变长度的字节数组。
这就是数据目的地。
因为这两个流对象都操作的数组,并没有使用系统资源。
所以,不用进行close关闭。
importjava.io.*;
classByteArrayStream
{
public static void main(String[] args) 没有异常发生.
{
//数据源。
ByteArrayInputStream bis = newByteArrayInputStream("ABCDEFD".getBytes());
//数据目的
ByteArrayOutputStream bos = newByteArrayOutputStream();//构造方法可以没有参数.
int by = 0;
while((by=bis.read())!=-1)//InputStream的子类,并不用判断数组长度.
{
bos.write(by);
}
System.out.println(bos.size());
System.out.println(bos.toString());
// bos.writeTo(newFileOutputStream("a.txt"));
}
}
在流操作规律讲解时:
源设备,
键盘System.in,硬盘 FileStream,内存 ArrayStream。
目的设备:
控制台System.out,硬盘FileStream,内存 ArrayStream。
用流的读写思想来操作数据。
void | writeTo(OutputStream out) |
操作字符数组
• CharArrayReader与CharArrayWrite
操作字符串
• StringReader 与 StringWriter
-----------------------------android培训、java培训、期待与您交流!----详细请查看:http://edu.csdn.net/heima---------------