黑马程序员_源自梦想 IO流

------- android培训、java培训、期待与您交流！
---------

IO流

Java中的流，可以从不同的角度进行分类。

按照数据流的方向不同可以分为：输入流和输出流。

按照处理数据单位不同可以分为：字节流和字符流。

按照实现功能不同可以分为：节点流和处理流。

节点流：直接与数据源相连，读入或读出。

直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

处理流：与节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。

字符流和字节流：

|---字节流两个基类：

InputStream OutputStream (操作对象：所有格式的文件）

|---ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用

|---StringBufferInputStream：把一个String对象作为InputStream

|---FileInputStream：把一个文件作为InputStream，实现对文件的读取操作

|---PipedInputStream：实现了pipe的概念，主要在线程中使用

|---SequenceInputStream：把多个InputStream合并为一个InputStream

|---DataInputStream: 存取基本数据类型到本地硬盘

|---ObjectOutputStream:存取对象（引用类型）到本地硬盘

|---字符流两个基类：

Reader Writer (操作对象：文本文件）

|---字节流与字符流的转换

InputStreamReader和OutputStreamWriter，是用于将字节流转换成字节流来读写的两个类，

InputStream与OutputStream示例

public class OutputStreamDemo {
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("c:\\cwkk.txt");//读取文件
FileOutputStream fos = new FileOutputStream("c:\\c1.txt");//输出到指定文件

byte[] b = new byte[1024];
int len = 0;
while((len = fis.read(b) )!= -1){
fos.write(b, 0, len);
}
fis.close();
fos.close();
}
}

Reader--Writer示例

//Reader--Writer 外加一层壳
public class OutputStreamDemo {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("c:\\cwkk.txt");
FileWriter fw = new FileWriter("c:\\c1.txt");
BufferedReader br = new BufferedReader(fr);//对FileReader进行了嵌套，更易于操作
BufferedWriter bw = new BufferedWriter(fw);
String line = null;
while((line = br.readLine()) != null){
bw.write(line + "\r\n");
bw.flush();
}
br.close();
bw.close();
}
}

DataOutputStream和ObjectOutputStream区别：

|---DataOutputStream只能处理基本类型。

|---ObjectOutputStream处理序列化的类，可以将一个实现了序列化的类实例写入到输出流中，

ObjectInputStream可以从输入流中将ObjectOutputStream输出的类实例读入到一个实例中。

ObjectOutputStream和ObjectInputStream处理的类必须是实现了序列化的类。

//DataOutputStream存取基本数据类型到本地硬盘--先进先出
import java.io.*;

public class DataStreamTest{
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("count.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
DataOutputStream dos = new DataOutputStream(bos);
dos.writeUTF("123中国123");
dos.writeBytes("123中国123");
dos.writeChars("123中国123");
dos.close(); //只要关闭最上层流对象，下层的流对象也会关闭

FileInputStream fis = new FileInputStream("count.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
DataInputStream dis = new DataInputStream(bis);
System.out.pritnln(dos.readUTF());
dis.close();
}
}

//ObjectOutputStream:存取对象（引用类型）到本地硬盘
import java.io.*;
class Student implements Serializable{
int age;
String name;

public Student(int age,String name){
this.name = name;
this.age = age;
}
}
public class Serialization{
public static void main(String[] args) throws Exception {
Student stu1 = new Student(1,"zhangsan");
Student stu2 = new Student(2,"lisi");

FileOutputStream fos = new FileOutputStream("d:\\student.txt");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(stu1);
os.writeObject(stu2);
os.close();

FileInputStream fis = new FileInputStream("d:\\student.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
stu1 = (Student)ois.readObject();
stu2 = (Student)ois.readObject();
ois.close();

System.out.println("name:" + stu1.name);
System.out.println("age:" + stu1.age);

System.out.println("name:" + stu2.name);
System.out.println("age:" + stu2.age);

}
}

案例--模拟BufferedReader

/*
可以自定义一个类中包含一个功能和readLine一样的方法。
来模拟BufferedReader
*/
import java.io.*;
class MyBufferedReader extends Reader
{
private Reader reader;
MyBufferedReader(Reader reader)
{
this.reader = reader;
}
//可以一次读一行数据的方法。
public String myReadLine()throws IOException
{
//定义一个StringBuilder容器。
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch=reader.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length()!=0) //当数据只有一行或最后一行没有“\r\n”（回车）时进行输出
return sb.toString();
return null;
}

//覆盖Reader类中的抽象方法。
public int read(char[] cbuf, int off, int len) throws IOException
{
return reader.read(cbuf,off,len) ;
}

public void close()throws IOException
{
reader.close();
}
public void myClose()throws IOException
{
reader.close();
}
}
class  MyBufferedDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("c:\\cwk.txt");

MyBufferedReader myBuf = new MyBufferedReader(fr);

String line = null;
while((line=myBuf.myReadLine())!=null)
{
System.out.println(line);
}

myBuf.myClose();
}
}