黑马程序员_java IO流1

最新推荐文章于 2017-10-19 22:04:41 发布

松毛123

最新推荐文章于 2017-10-19 22:04:41 发布

阅读量672

点赞数

分类专栏： Java学习日志

本文链接：https://blog.csdn.net/u012343764/article/details/17000185

版权

Java学习日志专栏收录该内容

11 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

1、IO流概述
IO流用来处理设备之间的数据传输；Java对数据的操作是通过流的方式； Java用于操作流的对象都在IO包中；

IO流的两种分类：

1)、按操作数据分类：字节流、字符流；

2)、按流向分类：输入流、输出流。

2、IO流中常用的基类

1)、字节流的抽象基类：InputStream， OutPutStream；

2)、字符流的抽象基类：Reader， Writer

IO流的一般特性：后缀名为父类名，前缀名是该流对象的功能。

如：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。如：InputStream的子类FileInputStream。如：Reader的子类FileReader 。

3、字符流的基本操作演示

字符流一般使用来操作文本文件的。

示例：

FileWriter fw = new FileWriter(“java.text”);

//创建一个FileWriter对象，该对象一初始化就必须要明确被操作的文件，该文件会被创建到指定目录下；如果该目录中已有同名文件将会被覆盖，该步就是在明确数据要存放的目的地；

fw.write(“Hello World!!!”);

//调用write方法，将字符串写入到流中；

fw.flush();

//刷新流对象中的缓冲数据；将数据刷到目的地中；

fw.close();

//关闭资源，但是在关闭之前会刷新一次内部中的缓冲数据；将数据刷到目的地。

//close和flush的区别：flush刷新后流可以继续使用；close刷新后流将会关闭；

4、IO流的异常处理

IO流一般都会抛出异常，因此在写程序时，不能仅仅的将异常直接抛出，而应该根据实际情况做相应的处理。一般在finally语句中关闭流资源。

import java.io.*;
class IOExceptionDemo
{
public static void main(String[] args)
{
FileWriter fw = null;//首先将fw赋值为空，是因为创建FileWriter文件时
//会抛出异常，需要捕捉；如果放在try中，finally中将访问不到fw；
try
{
fw = new FileWriter("java.text");
fw.write("Hello World!!!");
}
catch (IOException e )
{
System.out.println(e.toString());
}
finally
{
try
{
if(fw!=null)//如果上面的新创建对象抛出异常，fw将为空，执行到close时将会抛出空指针异常；所以确保不会抛出空指针异常需要做一个判断；
fw.close();
}
catch (IOException e )
{
System.out.println(e.toString());
}
}
}
}

5、IO流的一些基本操作方式

5.1、文件的续写

在新建对象的时候，传递一个 true 参数，代表不覆盖已有文件，并在文件的末尾处进行数据续写。例如： FileWriter fw = new FileWriter("Java.txt",true); 该语句将在Java.txt文件后面继续写入数据。

5.2、文本文件读取方式

方式一：使用 FileReader 中的 read() 方法； read 方法每次只读取一个字符，会自动往下读。在创建文件流对象时，要保证该文件是存在的，如果不存在则会发生 FileNotFoundException 异常。

方式二：通过字符数组进行读取。即 read(char[]) ，返回的是读到的字符个数。

示例：

import java.io.*;
class FileReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("FileReaderDemo.java");
char[] ch = new char[1024];//一般将该处的数组大小定义为1024的整数倍；
int num = 0;
while((num=fr.read(ch)) != -1)//当read返回的num等于-1时，表示已经读到文件末尾了；
{
System.out.print(new String(ch,0,num));//此处表示读多少就打印多少；
}
fr.close();
}
}

练习：使用以上两种方式，将相关路径的文本文件复制到D盘；

复制原理：将相关路劲的文件数据存储到D盘的一个文件中；

实现步骤：

1)、在D盘建立一个文件，用于存储原始数据；

2)、定义读取流和相关路径的文件相关联；

3)、通过不断地读写完成数据的存储；

4)、关闭资源。示例：

import java.io.*;
class CopyTest
{
public static void main(String[] args) throws IOException
{
copy_1();
}
public static void copy_2()throws IOException
{
//创建需要Copy的目的地；
FileWriter fw = new FileWriter("D:\\CopyDemo.txt");
//创建需要copy的文件；
FileReader fr = new FileReader("CopyTest.java");
//使用read方法，每次读一个字符写一个字符；
int len = 0;
while((len=fr.read()) !=-1)
{
fw.write(len);
}
fw.close();
fr.close();
}
//使用数组存储字符，让后让字符一次性输出；
public static void copy_1()
{
FileWriter fw = null;
FileReader fr = null;
try
{
fw = new FileWriter("D:\\CopyDemo.txt");
fr = new FileReader("CopyTest.java");
int len = 0;
char[] ch = new char[1024];
while((len=fr.read(ch)) != -1)
{
fw.write(ch,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("Read and write failure");
}
finally
{
try
{
if(fw != null)
fw.close();
}
catch (IOException e)
{
throw new RuntimeException("Write close failure");
}
try
{
if(fr != null)
fr.close();
}
catch (IOException e)
{
throw new RuntimeException("Read close failure");
}
}
}

6、字符流缓冲区

缓冲区的出现提高了对数据的读写效率；对应类有BufferedWriter & BufferedReader；缓冲区要结合流才能使用，并且在流的基础上对流的功能进行了增强。

6.1、BufferedWriter

BufferedWriter将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。操作方法：由于缓冲区的出现是为了提高流的操作效率；所以在创建缓冲区之前需要先有流对象。将流对象作为参数传递到缓冲区的构造函数，用于缓冲区的方法对数据进行操作。注：该缓冲区还提供了一个跨平台的换行符：newline()。

import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
FileWriter fw = new FileWriter("java.txt");//创建一个写入流对象和文件相关联；
BufferedWriter buf = new BufferedWriter(fw);//将流对象作为参数传递到缓冲区的构造函数；
buf.write("Hello java");
buf.flush(); //需要刷新，缓冲区中的文件才能进去流对象中；
buf.close();
//fw.close();此时的fw不需要关闭，因为关闭了缓冲区，
//也就是关闭了缓冲区中的流对象；
}
}

6.2、BufferedReader

BufferedReader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

该缓冲区提供了一个一次读取一行的方法：readLine()，方便与对文本文件的读取。该方法返回包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。
演示示例：

import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("CopyTest.java");
//创建一个缓冲区，将流对象作为参数传递给缓冲对象的构造函数；
BufferedReader buf = new BufferedReader(fr);
String line = null;
while((line=buf.readLine()) != null)//readLine每次读一行，
{ //当读到文件末尾时返回null；
System.out.println(line);
}
buf.close();
}
}

6.3、练习：通过缓冲区复制一个.java文件。

import java.io.*;
class BufferedCopyDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader("CopyTest.java"));
bufw = new BufferedWriter(new FileWriter("D:\\BufferedCopy.txt"));
String line = null;
while((line=bufr.readLine()) != null)
{
bufw.write(line);//由于readLine不读换行符；
bufw.newLine();//所以每读一行就需要换行一次；
}
}
catch (IOException e)
{
throw new RuntimeException("Read and write failure");
}
finally //关闭流资源；
{
try
{
if(bufr != null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("Read close failure");
}
try
{
if(bufw != null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("Write close failure");
}
}
}
}

6.4、readLine方法的原理

readLine方法的原理：readLine方法虽然每次都是读一行，其实最终还是在硬盘上一个一个的读取，所以最终使用的还是read方法一次一个的读取。

通过了解readLine方法的原理，我们可以自己写一个readLine方法。

import java.io.*;
class MyBufferedReader
{
private FileReader r;
MyBufferedReader(FileReader r)
{
this.r = r;
}
//自定义一个readLine方法myReadLine；
public String myReadLine()throws IOException
{
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch=r.read()) != -1)
{
if(ch == '\r')//当读到'\r'时，重新回去循环；
continue;
if(ch == '\n')//当读到'\n'时，将读到的数据转换成字符串；
return sb.toString();
else
sb.append((char)ch);//否则的话，就将数据存储到sb中；
}
if(sb.length() !=0)//当最后一行没有出现回车符时，也要将数据转换成字符串；
return sb.toString();
return null;
}
public void myClose()throws IOException //自定义myClose方法；
{
r.close();
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("CopyTest.java");
MyBufferedReader mbuf = new MyBufferedReader(fr);
String line = null;
while((line=mbuf.myReadLine()) != null)//调用myReadLine方法；
{
System.out.println(line);
}
mbuf.myClose();
}
}

7 、装饰设计模式

当要对已有对象进行功能增强时，就可以定义一个类，将已有对象传入，基于已有功能并提供增强功能，该自定义的类就称为装饰类。装饰类通常会通过构造方法接受别装饰的对象，并基于被装饰的的对象的功能，提供更强的功能。

装饰模式比继承要灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系；装饰类因为是增强已有对象，具备的功能和已有对象时相同的，只不过提供了更强大的功能，所以装饰类和被装饰类一般都是属于一个体系的。

例如：在一个专门用于读取的类中，

继承体系：

MyReader

|---MyTextReader

|---MyBufferedTextReader

|---MyMediaReader

|---MyBufferedMediaReader

|---MyDataReader

|---MuBufferedDataReader

class MyBufferedReader

{

MyBufferedReader(MyTextReader text){}

MyBufferedReader(MyMediaReader Media){}

}

该类的扩展性很差，找其参数的共同类型，可以通过多态的形式提高其扩展性。

class MyBufferedReader extends MyReader

{

MyBufferedReader(MyReader r){}

}

装饰设计模式：(扩展性更强，也更加简洁)

MyReader

|---MyTextReader

|---MyMediaReader

|---MyDataReader

|---MuBufferedReader

通过对装饰类的学习，我们可以将以上myReadLine方法进行改进成装饰类：

import java.io.*;
class MyBufferedReader extends Reader //该类继承Reader
{
private Reader r;
MyBufferedReader(Reader r)
{
this.r = r;
}
public String myReadLine()throws IOException
{
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch=r.read())!=-1)
{
if(ch == '\r') //当读到回车符的’\r’时重新循环；
continue;
if(ch == '\n') //当读到回车符的’\n’时直接打印当前行；
return sb.toString();
else
sb.append((char)ch);//如果没有遇到回车符将一直添加字符到sb中；
}
return null;
}
/*覆盖父类中的抽象方法*/
public void close()throws IOException
{
r.close();
}
public int read(char[] cbuf, int off, int len)throws IOException
{
return read(cbuf,off,len);
}
public void myClose()throws IOException
{
r.close();
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
MyBufferedReader buf = new MyBufferedReader(new FileReader("java.txt"));
String line = null;
while((line=buf.myReadLine()) != null)
{
System.out.println(line);
}
}
}

8、LineNumberReader

8.1、BufferedReader

|--- LineNumberReader

LineNumberReader是跟踪行号的缓冲字符输入流。此类定义了方法 de>setLineNumber(int)de> 和 de>getLineNumber()de>，它们可分别用于设置和获取当前行号。

其操作方法见示例：

import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("BufferedWriterDemo.java");
LineNumberReader lnr = new LineNumberReader(fr);
lnr.setLineNumber(100);//此处设置文件的行号从100(不包含100)开始；
String line = null;
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
} //getLineNumber()可以获取文件的行号；
lnr.close();
}
}

8.2、通过了解LineNumberReader原理的了解，自定义一个MyLineNumberReader类。

import java.io.*;
class MyLineNumberReader
{
private Reader r;
private int lineNumber;
public void setLineNumber(int lineNumber)
{
this.lineNumber = lineNumber;
}
public int getLineNumber()
{
return lineNumber;
}
MyLineNumberReader(Reader r)
{
this.r = r;
}
public String myReadLine() throws IOException
{
lineNumber++; //当每次调用MyReadLine方法时lineNumber就加一次；
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 myClose()throws IOException
{
r.close();
}
}
class MyLineNumberReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("BufferedReaderDemo.java");
MyLineNumberReader mlnr = new MyLineNumberReader(fr);
mlnr.setLineNumber(100); //设置起始行号为100；
String line = null;
while((line = mlnr.myReadLine()) != null)
{
System.out.println(mlnr.getLineNumber()+":"+line);
}
mlnr.myClose();
}

9、字节流

字节流：InputStream OutputStream

字符流是用于操作文本文件的，但是当要操作图片文件或者媒体文件等其他文件时，就得需要使用字节流。

InputStream和OutputStream与Reader和Writer的用法基本一致。在InputStream类中有一个available()方法，该方法可以获取文件的长度。

读取文件(InputStream)的三种操作方式：

1)、每读一个字节就打印一个字节；

2)、定义一个固定长度的数组，将读到的字节先存入到数组中，读完之后再一次性打印出来。

3)、定义一个长度为刚好的数组，其可是使用available方法获取，将读到的字节存入到刚好大小的数组中，让后直接全部打印出来。

在实际使用时，建议使用第二种方法，因为第一种方法读取速度较慢，第三种方法在读取较大文件时，当内存不够用时，就会发生内存溢出。

FileInputStream和FileOutputStread相关操作演示：

import java.io.*;
class FileStream
{
public static void main(String[] args) throws IOException
{
readFile_3();
}
public static void readFile_1()throws IOException
{
FileInputStream fis = new FileInputStream("D:\\java.txt");
int ch = 0;
while((ch = fis.read()) != -1)
{
System.out.print((char)ch);
}
fis.close();
}
public static void readFile_2()throws IOException
{
FileInputStream fis = new FileInputStream("D:\\java.txt");
byte[] bt = new byte[1024];
int len = 0;
while((len = fis.read(bt)) != -1)
{
System.out.println(new String(bt,0,len));
}
fis.close();
}
public static void readFile_3()throws IOException
{
FileInputStream fis = new FileInputStream("D:\\java.txt");
byte[] bt = new byte[fis.available()];//使用available方法可以获取fis的字节长度；
fis.read(bt);
System.out.println(new String(bt));
}
public static void writeFile()throws IOException
{
FileOutputStream fos = new FileOutputStream("D:\\java.txt");
fos.write("Hellojava".getBytes());
fos.close();
}
}

练习：使用字节流拷贝一副图片。

思路：1)、用字节读取流对象和图片关联；

2)、用字节写入流对象创建一副图片文件，用于存储获取到的图片数据；

3)、通过循环读写完成数据的存储；

4)、关闭资源。

import java.io.*;
class CopyPicDemo
{
public static void main(String[] args)
{
FileInputStream fis = null;
FileOutputStream fos = null;
try
{
fis = new FileInputStream("D:\\1.jpg");
fos = new FileOutputStream("D:\\2.jpg");
int len = 0;
byte[] bt = new byte[1024];
while((len = fis.read(bt)) != -1)
{
fos.write(bt,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("read and write file failure");
}
finally
{
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("read close failure");
}
try
{
if(fos!=null)
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("write close failure");
}
}
}

10、字节流缓冲区

BufferedInputStream和BufferedOutputStream。该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。字节流缓冲区与字符流缓冲区用法基本一致。以下通过一个复制mp3文件来演示字符流缓冲区的用法：

import java.io.*;
class CopyMp3Demo
{
public static void main(String[] args) throws IOException
{
long start = System.currentTimeMillis();//复制开始时间；
copy();
long end = System.currentTimeMillis();//复制结束后的时间；
System.out.println((end-start)+"毫秒");//复制mp3总共用时；
}
public static void copy()throws IOException
{
//通过字节流的缓冲区完成复制；将流对象作为参数传递给缓冲对象的构造函数；
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\1.mp3"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\2.mp3"));
//此方法是读一字节的数据就写一字节的数据；将数据写入到缓冲区中；
int bt = 0;
while((bt = bis.read()) != -1)
{
bos.write(bt);
}
bis.close();
bos.close();
}
}

自定义字节流缓冲区：

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
{
//通过in对象读取硬盘上的数据，并存储在buf中；
if(count == 0)
{
count = in.read(buf);
if(count < 0)
return -1;
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b;
}
else if(count > 0)
{
byte b = buf[pos];
count--;
pos++;
return b;
}
return -1;
}
public void myClose()throws IOException
{
in.close();
}
}
class MyBufferedInputStreamDemo
{
public static void main(String[] args) throws IOException
{
MyBufferedInputStream bis = new MyBufferedInputStream(new FileInputStream("D:\\1.mp3"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\2.mp3"));
int by = 0;
while((by = bis.myRead()) != -1)
{
bos.write(by);
}
bis.close();
bos.close();
}
}

此代码在复制过程中，会出现目标文件中没有数据；这是问什么呢？

mp3文件的存储格式是二进制数据存放的，当取数据的时候碰到1111 1111 1111 1111 0000 0101 0100 1101… ，当连续读到8个二进制数据1111 1111返回时，将会被强转提升成int型，即变成-1，此时用4个八位存储该数据；所以当读到语句while((by = bis.myRead()) != -1)时，将跳出循环，不再写数据；就会出现以上情况。

那么这个问题该如何解决呢？

为了避免-1与判断标记-1相同，需要在保留原8个二进制数据1111 1111时，在转换成int类型时，在前24位补0，即00000000 00000000 00000000 11111111，这样既可以避免原数据不变化，也可以避免出现于标记-1相同的情况出现。此时只需要将返回的b&255。其修改情况如下：

public int myRead()throws IOException
{
//通过in对象读取硬盘上的数据，并存储在buf中；
if(count == 0)
{
count = in.read(buf);
if(count < 0)
return -1;
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b&255;
}
else if(count > 0)
{
byte b = buf[pos];
count--;
pos++;
return b&0xff;
}
return -1;
}

11、读取键盘录入

System.out：对应的是标准输出设备，控制台

System.in：对应标准输入设备，键盘。

需求：利用键盘输入数据，并在控制台上打印出来，当遇到over时，退出打印。

import java.io.*;
class ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in = System.in; //通过键盘输入数据；
StringBuilder sb = new StringBuilder();//定义一个容器存储数据；
while(true)
{
int ch = in.read();
if(ch == '\r')
continue;
if(ch == '\n')//当遇到回车符时将数据转换成字符串；
{
String s = sb.toString();
if("over".equals(s))//遇到over时退出循环；
break;
System.out.println(s.toUpperCase());//打印出输入字符的大写；
sb.delete(0,s.length());//每次输完一行后就清空一次容器；
}
else
sb.append((char)ch);//否则就将数据存储在容器中；
}
}
}

12、转换流(InputStreamReader、OutputStreamWriter)

1)、读取转换流

通过以上示例发现就是每次读一行的原理，也就是readLine方法；这时可以考虑是否可以用readLine方法来实现以上方法呢？但readLine方法是字符流BufferedReader类中的方法，而键盘录入的read方法是字节流InputStream类中的方法，那么能不能将字节流转换成字符流，在使用字符流缓冲区的readLine方法呢？

通过API文档查找，我们知道了InputStreamReader类可以将字节流转换成字符流；而OutputStreamWriter则可以将字符流转换成字节流。读取转换流InputStreamReader是字节流通向字符流的桥梁; 写入转换流OutputStreamWriter 是字符流通向字节流的桥梁。

所以以上代码可以简化成：

import java.io.*;
class InputStreamReaderDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入；
InputStream in = System.in;
//将字节流转换成字符流，使用转换流；
InputStreamReader isr = new InputStreamReader(in); //读取转换流；
//为了提高效率使用缓冲流技术；
BufferedReader bufr = new BufferedReader(isr);
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out); //写入转换流；
BufferedWriter bufw = new BufferedWriter(osw);
String line = null;
while((line = bufr.readLine()) != null)
{
if(line.equals("over"))
break;
bufw.write(line.toUpperCase());
bufw.newLine(); //由于readLine不读取回车符，所以没读一行就需要重新换行；
bufw.flush();
}
bufr.close();
bufw.close();
}
}

记住：BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in))是以后键盘录入经常使用的语句。

13、流操作的基本规律

通过三个明确来完成：

1)、明确源和目的。

源：输入流，InputStream Reader

目的：输出流，OutputStream Writer

2)操作的数据是否是纯文本文件

是：字符流不是：字节流

3)当体系明确后，再明确使用哪个具体的对象，通过设备来进行区分：

源设备：内存、硬盘、键盘；

目的设备：内存、硬盘、控制台。

示例：

1.需求：将一个文本本件数据存储到另一个文件中(复制文件)。

源：因为是源，所以使用读取流：InputStream Reader;

是不是操作文本文件？是，选择Reader;

接下来明确要使用该体系中的哪个对象

明确设备：硬盘，文件 Reader体系中可以操作文本的对象是FileReader;

是否需要提高效率？是，加入Reader体系中的缓冲区BufferedReader;

FileReader fr= new FileReader(“a.txt”);

BufferedReader bufr = new BufferedReader(fr);

目的：OutputStream Writer;

是否是纯文本？是，选择Writer;

Writer体系中可以操作文本的对象时FileWriter

是否需要提高效率？是，加入Writer体系中的缓冲区BufferedWriter;

FileWriter fw = new FileWriter(“b.txt”);

BufferedWriter bufw = new BufferedWriter(fw);

2.需求：将键盘录入的数据保存在一个文件中。

源：InputStream Reader 是否是纯文本？是，选择Reader

设备：键盘。对应的对象时System.in

System.in对应的是字节流，为什么要选择Reader呢？为了操作键盘输入的文本数据方便，将字节流转换成字符流，按照字符串操作时最方便的。既然明确了Reader，那么就将System.in转换成Reader；这时就需要使用Reader体系中的转换流：InputStreamReader

InputStreamReader isr = new InputStreamReader(System.in);

需要提高效率吗？需要，则需要使用BufferedReader

BufferedReader bufr = new BufferedReader(isr);

目的：OutputStream Writer；

设备：硬盘，文件，使用FileWriter；

是否是纯文本？是，使用Writer

FileWriter fr = new FileWriter(“A.txt”);

需要提高效率吗？需要，使用BufferedWriter

BufferedWriter new = BufferedWriter(fr);

扩展：需要把录入的数据按照指定的编码表UTF-8存入到文件中

目的：OutputStream Writer；

是否是纯文本？是，使用Writer

设备：硬盘，文件，使用FileWriter；FileWriter使用的是默认编码表：GBK.

但是存储时要使用指定的编码表UTF-8,而指定的编码表只有转换流可以指定，所以要使用的对象时 OutputStreamWriter，而该转换流对象要接受一个字节输出流，而且还可以操作文件的字节输出流FileOutputStream

OutputStreamWriter osw

= new OutputStreamWriter(new FileOutputStream(“B.txt”),”UTF-8”);

什么时候使用转换流？转换流为字符和字节之间的桥梁。通常涉及到字符编码转换时，需要用到转换流。

示例：

import java.io.*;
class InputStreamTest
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\3.txt"),"UTF-8"));
//这里需要将指定的编码表作为参数传递到OutputStreamWriter;
String line = null;
while((line = bufr.readLine()) != null)
{
if(line.equals("over"))
break;
bufw.write(line);
bufw.flush();
bufw.newLine();
}
bufr.close();
bufw.close();
}
}

14、其他常用小操作

1)、改变标准输入输出设备(改变输入输出方式)

System.setIn(InputStream in)

System.setOut(PrintStream out)

2)、异常日志信息

演示示例：

import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
public static void main(String[] args) throws IOException
{
try
{
int[] arr = new int[2];
System.out.println(arr[2]);//角标越界异常发生；
}
catch (Exception e)
{
try
{
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//打印异常信息日期；
String s = sdf.format(d);
PrintStream ps = new PrintStream("D:\\ExceptionLog.txt");//指定异常信息存放目的地；
ps.println(s);
System.setOut(ps);
}
catch (IOException ex)
{
throw new RuntimeException("日志创建失败");
}
e.printStackTrace(System.out);
}
}
}