黑马程序员——Java基础---IO(一)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.IO流

1.IO流概述

1.IO流：

即InputOutput的缩写。

2.特点：

1）IO流用来处理设备间的数据传输。

2）Java对数据的操作是通过流的方式。

3）Java用于操作流的对象都在IO包中。

4）流按操作数据分为两种：字节流和字符流。

5）流按流向分为：输入流和输出流。

注意：流只能操作数据，而不能操作文件。

3.IO流的常用基类：

1）字节流的抽象基流：InputStream和OutputStream

2）字符流的抽象基流：Reader和Writer

字符流的由来：

其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表，获取对应的文字。再对这个文字进行操作。简单说：字节流+编码 表。

注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；如InputStream子类FileInputStream；Reader子 类FileReader

2.字符流

1.FileWriter概述

1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。

2、字符流只用于处理文字数据，而字节流可以处理媒体数据。

3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。

查看API，找到一个专门用于操作文件的Writer子类对象：FileWriter。 后缀是父类名。前缀名是流对象的功能。该流对象一被初始化，就必须有被操作的文件存在。

2.字符流输出

1、写入字符流步骤

a、创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步 就是在明确数据要存放的目的地。

b、调用write(String s)方法，将字符串写入到流中。

c、调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。

d、调用close()方法，关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。

close()和flush()区别：

flush()刷新后，流可以继续使用；

而close()刷新后，将会关闭流，不可再写入字符流。

2、 注意：

1、其实java自身不能写入数据，而是调用系统内部方式完成数据的书写，使用系统资源后，一定要关闭资源。

2、文件的数据的续写是通过构造函数 FileWriter(Strings,boolean append)，在创建对象时，传递一个true参数，代表不覆盖已有的文件。并 在已有文件的末尾处进行数据续写。（windows系统中的文件内换行用\r\n两个转义字符表示，在linux系统中只用\n表示换行）

3、由于在创建对象时，需要指定创建文件位置，如果指定的位置不存在，就会发生IOException异常，所以在整个步骤中，需要对IO异常进 行try处理。

示例：

import java.io.*;

class FileWriterDemo
{
public static void main(String[] args)
{
writerDate("abcde");//写入数据
writerFrom("zheshi:\r\nshenma");//续写数据，并附换行操作
}

//在硬盘上创建一个文件并写入指定数据
public static void writerDate(String s)
{
FileWriter fw=null;
try
{
fw=new FileWriter("demo.txt");//创建文件
fw.write(s);//将数据写入流
}
catch (IOException e)
{
throw new RuntimeException("写入失败");
}
finally
{
if(fw!=null)
try
{
fw.close();//将写入流的数据刷到指定文件内，并关闭流资源
}
catch (IOException e)
{
}
}
}

//对已有文件的数据续写指定数据
public static void writerFrom(String s)
{
FileWriter fw=null;
try
{
fw=new FileWriter("demo.txt",true);//传递一个true参数，代表不覆盖已有的文件。
fw.write(s);
}
catch (IOException e)
{
throw new RuntimeException("写入失败");
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
}
}
}
}

3.FileReader

1. 创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，若不存在，将会发生异常FileNotFoundException。

2. 调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。

第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。

3. 读取后要调用close方法将流资源关闭。

import java.io.*;
class  FileReaderDemo
{
public static void main(String[] args)
{
//第一种读取方式
singleCharReader();
//第二种读取方式
arrayCharReader();
}

//第一种读取方式，单个字符读取
public static void singleCharReader()
{
FileReader fr=null;
try
{

fr=new FileReader("demo.txt");//读取文件位置和文件名
//read()返回值为-1时表示读到文件末尾
for (int ch=0;(ch=fr.read())!=-1 ; )
{
System.out.print((char)ch);
}
}
catch (IOException e)
{
throw new RuntimeException("读取失败");
}
finally
{
try
{
if(fr!=null)
fr.close();//关闭读取流资源
}
catch (IOException e)
{
}
}
}

//第二种读取方式，通过字符数组进行读取
public static void arrayCharReader()
{
FileReader fr=null;
char[] arr=new char[1024];//定义一个字符数组，用于临时存储读取的字符
try
{
//读取一个.java文件，并打印在控制台上。
fr=new FileReader("FileReaderDemo.java");
for (int len=0;(len=fr.read(arr))!=-1 ; )
{
//显示字符数组的字符个数
System.out.print(new String(arr,0,len));
}
}
catch (IOException e)
{
throw new RuntimeException("读取失败");
}
finally
{
if(fr!=null)
try
{
fr.close();
}
catch (IOException e)
{
}
}
}
}

注意：

1、定义文件路径时，可以用“/”或者“\\”。

2、在创建一个文件时，如果目录下有同名文件将被覆盖。

3、在读取文件时，必须保证该文件已存在，否则出异常。

4.文件拷贝

/**
* 需求：将c盘一个文本文件复制到e盘、
* 思路：其实就是将c盘下的文件数据存储到e盘的一个文件中。
步骤：
1、在e盘创建一个文件。用于存储c盘文件中的数据。
2、定义读取流和c盘文件关联。
3、通过不断的读写完成数据存储。
4、关闭资源。
* @author jinlong
* */
package com.blog.part4.IO流;
import java.io.*;

class CopyFileDemo
{
public static void main(String[] args)
{
//调 用复制方法
//copy_1();
copy_2();
}
//用第一种读取方式进行复制
public static void copy_1()
{
FileWriter fw=null;
FileReader fr=null;
try
{
//关联读取和写入的文件
fw=new FileWriter("E:\\HelloWorld.java");
fr=new FileReader("C:\\HelloWorld.java");

for(int ch=0;(ch=fr.read())!=-1 ; )
{
fw.write(ch);//一个字符一个字符写入
}
}
catch(IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
if(fr!=null)
try
{
fr.close();//对读取流和写入流分别关闭
}
catch(IOException e)
{
}
if(fw!=null)
try
{
fw.close();
}
catch(IOException e)
{
}
}
}

//第二种读取方式进行复制
public static void copy_2()
{
FileWriter fw=null;
FileReader fr=null;
try
{
//关联读取和写入的文件
fw=new FileWriter("E:\\HelloWorld.java");
fr=new FileReader("C:\\HelloWorld.java");

//定义存储数组
char[]arr=new char[1024];

for(int len=0;(len=fr.read(arr))!=-1 ; )
{
fw.write(arr,0,len);//利用数组一次存入数组中的字符
}
}
catch(IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(fr!=null)
fr.close();
}
catch(IOException e)
{
}
finally
{
if(fw!=null)
try
{
fw.close();
}
catch(IOException e)
{
}
}
}
}
}

3.缓冲区

1.作用

提高了流的读写效率，所以在缓冲区创建前，要先创建流对象。即先将流对象初始化到构造函数中。

2.缓冲技术原理

此对象中封装了数组，将数据存入，再一次性取出。

3.写入步骤

1、创建一个字符写入流对象。

如：FileWriter fw=newFileWriter("buf.txt");

2、为了提高字符写入流效率。加入缓冲技术。只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

如： BufferedWriter bufw =new BufferedWriter(fw);

3、调用write方法写入数据到指定文件

如：bufw.write("adfg");

记住，只要用到缓冲区，就要记得刷新。（关闭流同样会刷新，但为了排除意外事故，保证数据存在，建议写入一次就刷新一次）

如：bufw.flush();

4、其实关闭缓冲区，就是在关闭缓冲区中的流对象。

如： bufw.close();

小知识：BufferedWriter缓冲区中提供了一个跨平台的换行符：newLine();可以在不同操作系统上调用，用作数据换行。

如：bufw.newLine();

4.读取步骤

该缓冲区提供了一个一次读一行的方法readLine，方便于堆文本数据的获取，当返回null时表示读到文件末尾。readLine方法返回的时候，只返 回回车符之前的数据内容。并不返回回车符。

readLine方法原理：

无论是读一行。或者读取多个字符。其实最终都是在在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。

步骤：

1、创建一个读取流对象和文件相关联

如： FileReader fr=newFileReader("buf.txt");

2、为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。

如： BufferedReader bufr=new BufferedReader(fr);

3、调用该缓冲区提供的readLine方法一行一行读取,如果到达文件末尾，则返回null

如： String s=bufr.readLine();

4、关闭流资源

如： bufr.close();、

示例一：

/*
需求：使用缓冲技术copy一个文本文件
*/
import java.io.*;

class BufferedCopyDemo
{
public static void main(String[] args)
{

BufferedWriter bfw=null;
BufferedReader bfr=null;
try
{
//创建写缓冲对象
bfw=new BufferedWriter(new FileWriter("ReaderWriterTest_copy.txt"));
//创建读缓冲对象
bfr=new BufferedReader(new FileReader("ReaderWriterTest.java"));
//利用BufferedReader提供的readLine方法获取整行的有效字符。直到全部获取
for (String line=null; (line=bfr.readLine())!=null; )
{
bfw.write(line);//写入指定文件中
bfw.newLine();//换行
bfw.flush();//将缓冲区数据刷到指定文件中
}

}
catch (IOException e)
{
throw new RuntimeException("文件copy失败");
}
finally
{
if(bfw!=null)
try
{
bfw.close();//关闭写入流
}
catch (IOException e)
{
throw new RuntimeException("写入流关闭失败");
}
if(bfr!=null)
try
{
bfr.close();//关闭读取流
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败");
}
}
}
}

示例二：

/*
需求：根据readLine方法原理，模拟BufferedReader写一个自己的MyBufferedReader
*/
import java.io.*;
//自定义缓冲类
class MyBufferedReader extends Reader
{
private Reader r;//定义接收的流对象
MyBufferedReader(Reader r)
{
this.r=r;
}
//自定义整行读取
public String myReadLine()throws IOException
{
//创建一个容器，用来存储一行的字符
StringBuilder sb =new StringBuilder();
//一个字符一个字符读取
for (int ch=0;(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 int read(char[] cbuf, int off, int len) throws IOException
{
return r.read(cbuf,off,len);
}

//复写父类的close方法
public void close()throws IOException
{
r.close();
}
}
//测试MyBufferedReader
class  MyBufferedReaderDemo
{
public static void main(String[] args)
{
MyBufferedReader mbr=null;
try
{
mbr=new MyBufferedReader(new FileReader("BufferedCopyDemo.java"));
for (String line=null;(line=mbr.myReadLine())!=null ; )
{
System.out.println(line);//显示效果
}
}
catch (IOException e)
{
throw new RuntimeException("读取数据失败");
}
finally
{
try
{
if(mbr!=null)
mbr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败");
}
}
}
}

5.获取和设置行号

在BufferedReader中有个直接的子类LineNumberReader，其中有特有的方法获取和设置行号：

setLineNumber();//设置初始行号

getLineNumber();//获取行号

/*
需求：利用LineNumberReader的特有方法去设置和获取文件中数据的行号
*/
class  LineNumberReaderDemo
{
public static void main(String[] args)
{
LineNumberReader lnr=null;
try
{
//将读取流对象传入
lnr=new LineNumberReader(new FileReader("LineNumberReaderDemo.java"));
lnr.setLineNumber(100);//设置开始行号

for (String line=null;(line=lnr.readLine())!=null ; )
{
System.out.println(lnr.getLineNumber()+":"+line);//打印每行行号和字符
}
}
catch (IOException e)
{
throw new RuntimeException("读取数据失败");
}
finally
{
try
{
if(lnr!=null)
lnr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败");
}
}
}
}

6.装饰类

1、简述

当想对已有对象进行功能增强时，可定义类：将已有对象传入，基于已有对象的功能，并提供加强功能，那么自定义的该类称之为装饰类。

2、特点

装饰类通常都会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。

装饰类和被装饰类都必须所属同一个接口或者父类。

3、装饰和继承的区别：

1）装饰模式比继承要灵活。避免了继承体系的臃肿，且降低了类与类之间的关系。

2）装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰的类通常都是属于一个体系。

3）从继承结构转为组合结构。

注：在定义类的时候，不要以继承为主；可通过装饰设计模式进行增强类功能。灵活性较强，当装饰类中的功能不适合，可再使 用被装饰类的功能。

示例：上面讲到的MyBufferedReader的例子就是最好的装饰设计模式的例子。

Class A
{
public void  function();
}

Class superA
{
private A a;

//构造函数
superA (A a)
{this.p=p;}

public void superFunction()
{
xxxxx
p.function();
xxxxxx
}

}

4.字节流

1.概述

1、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。

2、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。

3、读写字节流：InputStream 输入流（读）

OutputStream 输出流（写）

4、为何不用进行刷流动作：

因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。

5、InputStream特有方法：

int available();//返回文件中的字节个数

注：可以利用此方法来指定读取方式中传入数组的长度，从而省去循环判断。但是如果文件较大，而虚拟机启动分配的默认内存一般为64M。当 文件过大时，此数组长度所占内存空间就会溢出。所以，此方法慎用，当文件不大时，可以使用。

/**
* 需求：复制一个图片
* 思路：图片类型的文件可以用字节流方式赋值
*           将字节读取流和图片关联，用字节写入流创建一个图片用于存储获取到的图片资源
*           通过循环完成数据存储，关闭资源
* */
package com.blog.part4.IO流;

import java.io.*;

public class CopyPic
{
public static void main(String[]args)
{
//
availableCopy();

byteArrayCopy();
}
//使用available方法进行复制
public static void availableCopy()
{
//创建流对象
FileInputStream fis=null;
FileOutputStream fos=null;

try {
//将流与文件关联
fis=new FileInputStream("C:\\1.jpg");
fos=new FileOutputStream("D:\\java\\1.jpg");

//设置存储数组
byte[] by=new byte[fis.available()];

//连接流与存储数组
fis.read(by);
fos.write(by);

} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("图片复制失败");
}
finally
{
if(fis!=null)
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("输入流关闭失败");
}

if(fos!=null)
try {
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("输出流关闭失败");
}

}

}

//使用读数组方式进行复制
public static void byteArrayCopy()
{
//创建流对象
FileInputStream fis=null;
FileOutputStream fos=null;

try {
//将流与文件关联
fis=new FileInputStream("C:\\1.jpg");
fos=new FileOutputStream("D:\\java\\1.jpg");

//设置存储数组
byte[] by=new byte[1024];

//len存储返回位置
int len=0;
//写入自定义数组
while((len=fis.read(by))!=-1)
{
fos.write(by);
}

} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("图片复制失败");
}
finally
{
if(fis!=null)
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("输入流关闭失败");
}

if(fos!=null)
try {
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("输出流关闭失败");
}

}

}

}

2.字节流缓冲区

同样是提高了字节流的读写效率。

1、 读写特点：

read()：会将字节byte型值提升为int型值

write()：会将int型强转为byte型，即保留二进制数的最后八位。

2、原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。

1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区。

2）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。

3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。

4）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到0即元素取完。

5）当文件中的全部数据都被读取出时，read()方法就返回-1。

3、自定义读取字节流缓冲区

需求：根据字节流缓冲区的原理，自定义一个字节流缓冲区。

注意：

1、字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。

因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是 通过结尾标记-1来确定的。

所以，为了避免这种情况将读到的字节进行int类型的提升。并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。而在写入数 据时，只写该int类型数据的最低8位。

2、byte类型的-1提升为int类型时还是-1。原因：因为在bit8个1前面补的全是1导致的。如果在bit8个1前面补0，即可以保留原字节数据不变， 又可以避免-1的出现。这时将byte型数据&0xff即255即可。

/**
* 需求：自定义字节流缓冲区
* 思路：类似于字符流缓冲区
*           自定义一个固定长度的数组，定义指针和计数器。
*           每次存入字节数据都要先将数组元素取完。
*
* @author jinlong
* */
package com.blog.part4.IO流;
import java.io.*;
//自定义字节缓冲区
class MyBufferedInputStream
{
private InputStream in;
private byte[] by=new byte[1024];//固定长度字节数组
private int count=0,pos=0;//指针和计数器
//构造函数获取数据流对象
MyBufferedInputStream(InputStream in)
{
this.in=in;
}
//自定义读方法，一次读一个字节
public int myRead()throws IOException
{
//通过in对象读取硬盘上数据，并存储by中。
//存储在数组中的数据被读取完，再通过in对象从硬盘上读取数据
if(count==0)
{
count=in.read(by);
if(count<0)//文件数据全部被读取出来了
return-1;

pos=0;//初始化指针
byte b=by[pos];

count--;//每被读一个字节，表示数组中的字节数少一个
pos++;//指针加1
return b&255;//返回的byte类型提升为int类型，字节数增加，且高24位被补1，原字节数据改变。
//通过与上255，主动将byte类型提升为int类型，将高24位补0，原字节数据不变。
//而在输出字节流写入数据时，只写该int类型数据的最低8位。
}
else if(count>0)//如果数组中的数据没被读取完，则继续读取
{
byte b=by[pos];

count--;
pos++;
return b&0xff;
}
return-1;
}

//自定义关闭资源方法
public void close()throws IOException
{
in.close();
}
}

//测试自定义输入字节流缓冲区
class MyBufferedCopy
{
public static void main(String[] args)
{
//利用字节流的缓冲区进行复制
copyMe();
}
//使用字节流的缓冲区进行复制
public static void copyMe()
{
BufferedOutputStream bout=null;
MyBufferedInputStream bin=null;
try
{
//关联复制文件输入流对象到缓冲区
bin=new MyBufferedInputStream(new FileInputStream("F:/CloudMusic/追梦赤子心.mp3"));
//指定文件粘贴位置的输出流对象到缓冲区
bout=new BufferedOutputStream(new FileOutputStream("D:/追梦附件.mp3"));

//使用自定义read方法
int by=0;
while((by=bin.myRead())!=-1)
{
bout.write(by);//将缓冲区中的数据写入指定文件中
}
}
catch(IOException e)
{
throw new RuntimeException("MP3复制失败");
}
finally
{
try
{
if(bin!=null)
bin.close();//关闭输入字节流
}
catch(IOException e)
{
throw new RuntimeException("读取字节流关闭失败");
}
try
{
if(bout!=null)
bout.close();//关闭输出字节流
}
catch(IOException e)
{
throw new RuntimeException("写入字节流关闭失败");
}
}
}
}

3

2.流操作规律

1.键盘录入

1.标准输入输出流

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

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

System.in的类型是InputStream.

System.out的类型是PrintStream 是OutputStream的子类FilterOutputStream的子类。

2.整行录入

当使用输入流进行键盘录入时，只能一个字节一个字节进行录入。为了提高效率，可以自定义一个数组将一行字节进行存储。当一行录入完毕，再将一行数据进行显示。这种正行录入的方式，和字符流读一行数据的原理是一样的。也就是readLine方法。

那么能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？readLine方法是字符流BufferedReader类中方法。而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢？这就需要用到转换流了。

3.转换流

1. 转换流的由来：

a、字符流与字节流之间的桥梁

b、方便了字符流与字节流之间的操作

转换流的应用：

字节流中的数据都是字符时，转成字符流操作更高效。

任何Java识别的字符数据使用的都是Unicode码表，而OutputStreamWriter可使用指定的编码将要写入流中的字符编码成字节。

2. InputStreamReader将字节流通向字符流

a、获取键盘录入对象。

InputStream in=System.in;

b、将字节流对象转成字符流对象，使用转换流。

InputStreamReader isr=new InputStreamReader(in);

c、为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

BufferedReader br=new BufferedReader(isr);

//键盘录入最常见写法

BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

3. OutputStreamWriter字符流通向字节流

字符通向字节：录入的是字符，存到硬盘上的是字节。步骤和InputStreamReader转换流一样。

BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
4.转换流的两个常用字类：FileReader 和FileWriter
FileWriter是用来写入字符文件的便捷类，此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。

FileWriter写入本地文件使用的是本地编码，也就是GBK码表。

示例一：

/**
* 需求：将键盘录入的数据，显示在控制台，当输入over时，表示结束
* 思路： 源：键盘录入。
目的：控制台。
* @author jinlong
* */
package com.blog.part4.IO流;
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
//获取键盘录入对象。
//InputStream in=System.in;
//将字节流对象转成字符流对象，使用转换流。
//InputStreamReader isr=new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
//BufferedReader br=new BufferedReader(isr);

//键盘录入最常见写法
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

//字符流通向字节流
BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(System.out));

String s=null;
while((s=in.readLine())!=null)
{
if("over".equals(s))
break;
bw.write(s.toUpperCase());//写入数据
bw.newLine();//换行
bw.flush();//刷新

}
bw.close();//关闭流资源
in.close();
}
}

示例二：

/**
* 需求：演示便捷类FileWriter
* @author jinlong
* */
package com.blog.part4.IO流;
import java.io.*;
public class FileWriterDemo {
public static void main(String[] args) throws IOException
{
writeText();
}

public static void writeText() throws IOException
{
FileWriter fw = new FileWriter("D:/a.txt" );
fw.write( "天亮了");
fw.close();
}
}

2.操作流的规律

使用IO流，可以通过三个明确来完成

1.明确源和目的。

源：输入流。InputStream Reader

目的：输出流。OutputStream Writer

2.操作的数据是否是纯文本。

是：字符流

否：字节流

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

源设备：内存，硬盘，键盘

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

4.System类的setIn，setOut方法可以对默认设备进行改变

System.setIn(newFileInputStream(“1.txt”));//将源改成文件1.txt。

System.setOut(newFileOutputStream(“2.txt”));//将目的改成文件2.txt

示例一：

/**
* 需求：想把键盘录入的数据按照指定的编码表（UTF-8）存储到一个文件中。将一个文件的数据打印在控制台上。
* 思路：这里可以按照三个明确来设计
*           1.输入流 键盘：System.in
*           2.纯文本：字符流
*           3.输入流是键盘，所以要用字节流接收，但是要指定编码表，而且是纯文本所以可以用转换流
* @author jinlong
* */
package com.blog.part4.IO流;
import java.io.*;
class  TransStreamDemo1
{
public static void main(String[] args)throws IOException
{

//键盘录入
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

//存入文件中，按照指定的编码表（UTF-8）
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("Temp.txt"),"UTF-8"));

String line=null;
while((line=br.readLine())!=null)
{
if("over".equals(line))
break;
bw.write(line);
bw.newLine();
bw.flush();
}

/*-------------读取文件打印到控制台----------------
//录入文件数据
BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("G:\\workspace\\blog\\src\\com\\blog\\part4\\IO流\\TransStreamDemo1.java")));

//显示在控制台
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));

String line=null;
while((line=br.readLine())!=null)
{
if("over".equals(line))
break;
bw.write(line);
bw.newLine();
bw.flush();
}
*/
}
}

示例二：

/**
* 需求：将错误异常存储到日志文件
* 思路：1、获取当前时间的字符串格式
*           2、修改输出流设备，从控制台输出改为输出到文档
* @author jinlong
* */
package com.blog.part4.IO流;
import java.io.*;
import java.text.*;
import java.util.*;
class  ExceptionInfo
{
public static void main(String[] args)
{
try
{
//这里会出现越界异常
int[] arr =new int[2];
System.out.println(arr[3]);

}
//异常处理，打印到指定日志文件中
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("info.log");//打印流对象
System.setOut(ps);//修改输出流设备
ps.println(s);//输出时间

}
catch (IOException ex)
{
throw new RuntimeException("文件创建失败");
}
e.printStackTrace(System.out);//将异常信息输出指定输出流
}
}
}

示例三:

/**
* 需求：将系统信息存储到指定文件
* 思路：  获取系统信息：
Properties getProperties()
将信息输出到指定输出流中
void list(PrintStream out)
将输出流中数据存入指定文件中
new PrintStream("systeminfo.txt")

* @author jinlong
* */
package com.blog.part4.IO流;
import java.util.*;
import java.io.*;

class SystemInfo
{
public static void main(String[] args)
{
PrintStream ps = null;
try
{
//获取系统信息：
Properties pop = System.getProperties();
//创建输出流对象，将输出流中数据存入指定文件中
ps = new PrintStream("systeminfo.txt");
//将属性列表输出到指定的输出流
pop.list(ps);
}
catch (Exception e)
{
throw new RuntimeException("获取系统信息失败。");
}
}
}

3.总结

1. 流是用来处理数据的。

2.处理数据时，一定要先明确数据源，与数据目的地（数据汇）。

3.数据源可以是文件，可以是键盘。

4.数据目的地可以是文件、显示器或者其他设备。

5.而流只是在帮助数据进行传输,并对传输的数据进行处理，比如过滤处理.转换处理等。

继承体系图：