Java——IO流读写对象及流操作规律
IO流
概述：IO流就是用来进行数据的输入输出操作的一个缓冲区。
按操作的对象不同可分为：
1、对字符操作
Reader和Writer
2、对字节操作
InputStream和OutputStream
字符流：
FileWriter：是Writer的一个子类，用于进行文件的数据写入，以字符为操作单位。
首先要创建一个FileWriter对象，构造方法的参数要指定一个文件名，用来明确数据写入的位置。如：FileWriter fw = new FileWriter("demo.txt");
常用方法：
write() //将数据存储到字符流中，可以以字符串，字符，字符数组等为参数。
flush() //刷新字符流，将数据写入到目的地。
close() //刷新字符流，同时关闭字符流，调用后Writer对象不能使用。
示例：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。
//没有此文件 将创建文件，如有同名文件，将被覆盖。
FileWriter fw = new FileWriter("demo.txt");
//write方法将字符串写入到流中。
fw.write("hello");
//刷新缓冲区中数据，写入目的地中。
//fw.flush();
//关闭流，并刷新一次缓冲中的数据。
fw.close();
}
}字符流读取方法
以FileReader为例：
常用方法：
read() //读取一个字符，返回字符对应的ACSII码
close() //关闭读取流
读取文件示例：
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args) throws IOException
{
//第一种读取方式：单个字符读取
FileReader fr = new FileReader("demo.txt");
while(true)
{
int c = fr.read();
if(c == -1)
break;
System.out.print((char)c);
}
fr.close();
//第二种方式：通过字符数组进行读取。
//read(char[])返回的是读到的字符个数
FileReader fr2 = new FileReader("demo.txt");
char[] buf = new char[1024];
int num = 0;
while((num = fr2.read(buf)) != -1)
System.out.print(new String(buf, 0, num));
fr2.close();
}
}带缓冲区的字符读取和写入流：
BufferedReader和BufferedWriter：
这两个类封装了定义缓冲区的操作，在读取和写入时定义了字符数组作为缓冲区，避免了单个字符操作的低效率。建立对象时，需要传入对应的Reader和Writer对象作为参数。
BufferedWriter：
建立对象时格式应如：
FileWriter fw = new FileWriter("test.txt");
BufferedWriter bufw = new BufferedWriter(fw);
特有方法：
newLine() //添加一个换行符，自动通过系统获取，可以跨平台。
BufferedReader：
建立对象和上面方法类似。
特有方法：
readLine() //返回一个字符串，内容是读取一行字符的内容，到文本末尾返回null。
示例：
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("test.java");
BufferedReader bufr = new BufferedReader(fr);
String s = null;
while((s = bufr.readLine()) != null)
{
System.out.println(s);
}
}
}
class BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
FileWriter fw = new FileWriter("buf.txt");
BufferedWriter bufw = new BufferedWriter(fw);
bufw.write("abcde");
bufw.flush();
bufw.close();//关闭缓冲区也直接关闭了FileWriter对象；
}
} 装饰模式：
这种对原有Reader和Writer功能进行增强的设计模式成为装饰设计模式。
方法是在遇到一个定义好的类，并需要对其进行改进时，定义一个新类，将其作为新类的成员，并定义新方法，内部使用原有需要改进的方法，并加入新的代码。
这种设计模式的好处在于：
装饰模式比继承要灵活。避免了继承体系的臃肿，且降低了类与类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰的类通常都是属于一个体系。
自定义BufferedReader：
下面用这种设计模式 自定义一个BufferedReader，主要以自定义的readLine()方法为例：
import java.io.*;
//自定义BufferedReader类
class MyBufferedReader extends Reader
{
private Reader r;
MyBufferedReader(Reader r)
{
this.r = r;
}
//一次读一行数据的方法
public String myReadLine()throws IOException
{
//定义一个临时容器，原BufferedReader使用的是字符数组，
//这里为了方便使用StringBuilder,
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch = r.read()) != -1)
{
//判断是否为行终止符
if(ch == '\r')
continue;
if(ch == '\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length() != 0)
{
return sb.toString();
}
return null;
}
public void close()throws IOException
{
r.close();
}
public int read(char[] cbuf, int off, int len)throws IOException
{
return r.read(cbuf, off, len);
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("test.java");
MyBufferedReader mbufr = new MyBufferedReader(fr);
FileWriter fw = new FileWriter("buf.txt");
BufferedWriter bufw = new BufferedWriter(fw);
String buf = null;
while((buf = mbufr.myReadLine()) != null)
{
fw.write(buf);
bufw.newLine();
bufw.flush();
}
mbufr.close();
fw.close();
}
}字节流：
字节流是直接针对字节进行操作的，所以字节流可以直接对非文本文件进行读写。
读写方法与字符流类似，只是自定义的缓冲区缓存byte数组就可以了。
以拷贝图片为例：
import java.io.*;
class CopyPic
{
public static void picCopy()
{
FileInputStream fis = null;
FileOutputStream fos = null;
try
{
fos = new FileOutputStream("buf.jpg");
fis = new FileInputStream("logo.jpg");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1)
{
fos.write(buf, 0, len);
}
}
catch(IOException e)
{
System.out.println("pic copy failed");
}
finally
{
try
{
if(fos != null)
fos.close();
}
catch(IOException e)
{
System.out.println("output close failed");
}
try
{
if(fos != null)
fos.close();
}
catch(IOException e)
{
System.out.println("input close failed");
}
}
}
public static void main(String[] args)
{
picCopy();
}
}
字节流也有对应的带有缓冲区的加强类：BufferedInputStream和BufferedOutputStream
调用read()方法时应注意，它会把读到的byte类型数据提升为int类型并返回，数据前自动补齐-1，这样在遇到连续8位是1的数据时，再补齐-1就会被当做结束标记，
自定义read()方法时，应注意在提升byte为int时，要在前面补0，也就是将数据和255做与运算。
自定义BufferedInputStream如下：
import java.io.*;
class MyBufferedInputStream
{
private InputStream in;
private byte[] buf = new byte[1024];//缓冲区
private int pos = 0, count = 0;//定义指针，计数器
MyBufferedInputStream(InputStream in)
{
this.in = in;
}
//一次读一个字节,从缓冲区——字节数组中读
public int myRead()throws IOException
{
if(count == 0)//数组是否取空
{
count = in.read(buf);//通过in对象读取硬盘上的数据 并存储到缓冲区buf中，
if(count < 0)
{
return -1;
}
pos = 0;
byte b = buf[pos];//第一次从缓冲区中取一个字节
count --;
pos ++;
return b & 0xff;//补0
}else if(count > 0)
{
byte b = buf[pos];//一次从缓冲区中取一个字节
count --;
pos ++;
return b & 255;//补0
}
return -1;
}
public void close()throws IOException
{
in.close();
}
}
/* byte型提升为int型后，8位数据提升为32位，前面系统自动补1，如果独到8个1，补位后
* 还是-1，就会中断读数据循环，所以要手动补0。就和255与运算。
*
*/字符流与字节流转换流：
最简单的应用例子就是，在获取键盘录入时，希望提高效率，避免输入一个读取一个，改为输入一行，然后整行读取到缓冲区，而readLine()方法又是字符流的方法，
这时就可以使用转换流，将InputStream对象传入InputStreamReader构造函数中，再通过BufferedReader对象来使用readLine()方法。
代码如下：
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
//获取键盘录入对象
// InputStream in = System.in;
// //将字节流转换成字符流，使用转换流
// InputStreamReader isr = new InputStreamReader(in);
// BufferedReader br = new BufferedReader(isr);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// OutputStream out = System.out;
// OutputStreamWriter osw = new OutputStreamWriter(out);
// BufferedWriter bw = new BufferedWriter(osw);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
String buf = null;
while((buf = br.readLine()) != null)
{
if("over".equals(buf))
break;
bw.write(buf.toUpperCase());
bw.newLine();
bw.flush();
}
br.close();
br.close();
bw.close();
}
}流操作规律：
下面总结一下流操作规律，以便明确数据操作时用哪个流对象。
通过明确以下几点就可以确定：
1、 源：输入流：InputStream Reader
目的：输出流：OutputStream Writer
2、操作的是否为纯文本：
是：字符流对象
否：字节流对象
3、通过设备来确定具体对象：
硬盘上文件：Filexxxx
标准输入输出设备（键盘，控制台）：System.xx 这里可以通过System.setxx()来设置默认设备。
再通过是否需要提高效率决定是否用Bufferedxxx。
示例：
需求：想要将一个文件的数据打印在控制台上。
源：文件
目的：控制台
代码如下：
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
//获取键盘录入对象
// InputStream in = System.in;
// //将字节流转换成字符流，使用转换流
// InputStreamReader isr = new InputStreamReader(in);
// BufferedReader br = new BufferedReader(isr);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// OutputStream out = System.out;
// OutputStreamWriter osw = new OutputStreamWriter(out);
// BufferedWriter bw = new BufferedWriter(osw);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
String buf = null;
while((buf = br.readLine()) != null)
{
if("over".equals(buf))
break;
bw.write(buf.toUpperCase());
bw.newLine();
bw.flush();
}
br.close();
br.close();
bw.close();
}
}