• 文本我们能读懂的都可以认为是字符流，文章 java文件都是字符流数据

  • 流的分类 输入流 输出流

• 1。输出流 Writer：关于字符流的父类，抽象类。与之相对的输入流 Reader类

• 一、字符流

  • 字符流的命名规则：如果是输出流那么就以Writer结尾，如果是输入流就以Reader结尾

案例1：

使用字符流向一个文件输入Hello 沃得；

publicstaticvoid main(String[] args) {

File file =new File("test.txt");

System.out.println(file.length());

Writer writer = null;

try {

//I/O流是需要关闭的，如果不这样做就不能关闭资源

writer = new FileWriter(file);

writer.write("hellow");

} catch (IOException e) {

e.printStackTrace();

}finally {

//判断writer不是空 防止空指针异常

if(writer != null) {

try {

//writer.close的功能和flash一样都是清除缓存

writer.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

主要考虑异常的处理，writer的声明方法也需要仔细查看，根据写入的数据类型决定选择哪个方法来写入内容

文件的追加：

publicstaticvoid
main(String[] args)
{

Filefile
=new
File("test.txt");

System.out.println(file.length());

Writer
writer
= null;

try
{

//I/O流是需要关闭的，如果不这样做就不能关闭资源

//后面的布尔值如果为true则是在文件后面追加内容

writer
= new
FileWriter("text2.txt",true);

for(inti
= 0; i
< 100; i++)
{

writer.write("halloword");

个哈喽沃得就清除一下缓存

if(i
% 10 == 0) {

System.out.println("\n");

writer.flush();

}

}

}
catch
(IOException e)
{

e.printStackTrace();

}finally
{

//判断writer不是空
防止空指针异常

if(writer
!= null)
{

try
{

//writer.close的功能和flash一样都是清除缓存

writer.close();

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}

}

}

字符输出流的换行:

• 在写入的内容中的换行符\n前加上\r才能实现换行

try
{

//I/O流是需要关闭的，如果不这样做就不能关闭资源

//后面的布尔值如果为true则是在文件后面追加内容

writer
= new
FileWriter("text2.txt",true);

for(inti
= 0; i
< 100; i++)
{

writer.write("halloword\r\n");

个哈喽沃得就清除一下缓存

if(i
% 10 == 0) {

System.out.println("");

writer.flush();

}

}

}
catch
(IOException e)
{

e.printStackTrace();

}

writer的写入方法：

writer
= new
FileWriter("text3.txt",true);

char[]
c = {'a','b','c','d','e','f','g'};

writer.write(c,
2, 3);

• 字符的输入流：

publicstaticvoid
main(String[] args)
{

File
file
=new
File("test.txt");

Readerreader
=null;

try
{

reader
= new
FileReader(file);

//单个字符的读取,读取的字符被转换为ASCII码

/*

* 通过char可以将获得的ASCII强转为char的字符型，

* read()方法在读取到最后的时候值会变成-1，所以可以用while

* 循环遍历文本中的内容，这种单个字符的读取性能不高。一般不用

*/

intc;

try
{

while((c
= reader.read())
!= -1) {

System.out.print((char)c+"\r\n");

}

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}
catch
(FileNotFoundException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}finally
{

if(reader
!= null)
{

try
{

reader.close();

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}

}

}

• 字符输入流2：用数组读取内容

publicstaticvoid
main(String[] args)
{

File
file
=new
File("test.txt");

Reader
reader
= null;

try
{

reader
= new
FileReader(file);

//定义一个数组，这个方法是较为常用的方法

char[]
arr
= newchar[10];

//向字符数组填数据

try
{

intlen
= 0;

//intlen
= reader.read(arr);

//System.out.println("len的值"+len+"读取的内容"+Arrays.toString(arr));

输出结果为len的值10
读取的内容…（个元素）
如果数组中的元素不够10个，则长度变为文本内容长度，

* 元素有多长替换多长的，空出来的数组下标位置，还是为以前的元素值

* 知道最后完全没有元素了，读取长度变为-1

* while循环获得文本中的所有内容，由于最后一次读取，不一定能读取够

* 定义的数组长度，所以在将其转成字符串的使用用String（数组名,取值开始位置，取值结束位置）

* 将结束位置设置为从read（）方法获得的长度。直到其返回为-1，while结束循环。

*/

while((len
= reader.read(arr))
!= -1) {

String
str
= new
String(arr,0,len);

System.out.print(str);

}

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}
catch
(FileNotFoundException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}finally
{

try
{

reader.close();

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}

}

• 文件的拷贝

  publicstaticvoid
  main(String[] args)
  {

  * 1.通过输入流将文件读取到字符串中；

  File
  file
  =new
  File("D:\\Users\\Administrator\\eclipse-workspace\\7.13\\src\\ExtendOne.java");

  Reader
  reader
  = null;

  File
  file1
  = new
  File("javaCopy.java");

  Writer
  writer
  = null;

  try
  {

  intlen;

  //创建字符输入流的对象

  reader
  = new
  FileReader(file);

  try
  {

  //创建字符输出流的对象

  writer
  =new
  FileWriter(file1);

  }
  catch
  (IOException e1)
  {

  //
  TODO
  Auto-generated catch block

  e1.printStackTrace();

  }

  char[]
  arr
  = newchar[10];

  try
  {

  while((len
  = reader.read(arr))
  != -1){

  //把输入流读取到的数据写入字符输出流，输出流被写入玩后需要writer.flush()清除缓存；

  writer.write(arr,
  0, len);

  }

  writer.flush();

  }
  catch
  (IOException e)
  {

  //
  TODO
  Auto-generated catch block

  e.printStackTrace();

  }

  }
  catch
  (FileNotFoundException e)
  {

  //
  TODO
  Auto-generated catch block

  e.printStackTrace();

  }finally
  {

  //需要将打开的输入输出流关闭

  //原则为：先打开的后关闭，后打开的先关闭.都需要异常处理

  //两个异常处理可以合一块，在同一个try内判断是否为空并关闭对象即可。

  if(writer
  != null)
  {

  try
  {

  writer.close();

  }
  catch
  (IOException e)
  {

  //
  TODO
  Auto-generated catch block

  e.printStackTrace();

  }

  }

  if(reader
  != null)
  {

  try
  {

  reader.close();

  }
  catch
  (IOException e)
  {

  //
  TODO
  Auto-generated catch block

  e.printStackTrace();

  }

  }

  }

  }

  • 字节流的高效缓冲字节流

publicstaticvoid
main(String[] args)
{

//定义一个高效缓冲字节流，可以复制图片

BufferedInputStream
in
=null;

BufferedOutputStream
out
= null;

try
{

//创建一个高效缓冲字节流对象

//和输入输出流一样都是需要关闭的，先开的后关，后开的先关

in
=new
BufferedInputStream(new
FileInputStream("E:\\Program
Files\\冒泡排序.jpg"));

out
= new
BufferedOutputStream(new
FileOutputStream("maopao.jpg"));

//定义一个字节数组

byte[]
bs
= newbyte[1024];

//定义一个标志

intlen;

try
{

while((len
= in.read(bs))
!= -1) {

out.write(bs,0,len);

}

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}
catch
(FileNotFoundException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}finally
{

if(out
!= null)
{

try
{

out.close();

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}

if(in
!= null)
{

try
{

in.close();

}
catch
(IOException e)
{

//
TODO
Auto-generated catch block

e.printStackTrace();

}

}

}

}

字符流和字节流的转换桥梁：

• 字符流操作文本，字节流操作二进制，字节是最小的基本单位，一个字符占两个字节。

• OutputStreamWriter:是字符流转换为字节流的桥梁，可使用指定的charset将要写入流中的字符编码成字节。

  • 编码：不同的编码格式得到的值不同！utf-8表和GBK表，可以通过右键工程选择Propertise菜单进入编码格式编辑菜单。设置的编码格式如果和写入时保存的文件格式不同则会产生乱码，因此需要进行编码设置。字符流通向字节流的桥梁可以指定存储编码