【黑马程序员】 java笔记——IO流

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

IO流

IO(InputOutput)流

一、IO概述：

         IO流用来处理设备之间的数据传输

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

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

         流按操作数据分为两种：字节流与字符流

         流按流向分为：输入流、输出流。

IO流常用基类：

         字节流的抽象基类：

         InputStream，OutputStream。

         字符流的抽象基类：

         Reader，Writer。

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

         如：InputStream的子类FileInputStream。

         如：Reader的子类FileReader。

IO流用来对设备（通常为内存或者硬盘）存储的数据进行输入输出操作。

IO流按操作的对象分为字节流（最常用的）和字符流（操作文本数据）。

IO流又可以分为输入流和输出流。

二.字符流和字节流：

字节流两个基类；InputStream   outputStream

字符流两个基类；Reader    Writer

先学习一下字符流的特点；

既然IO流是用于操作数据的，那么数据的最常见体现形式是；文件。那么先以操作文件为主来演示。

例：

/*
需求；在硬盘上，创建一个文件并写入一些文字数据。
 找到一个专门用于操作文件的Writer子类对象。filewriter。后缀名是父类名。前缀名是该流对象的功能。
*/
importjava.IO.*; 
class  FileWriterDemo 
{ 
     public static void main(String[] args)throws IOException 
    { 
  //创建一个Filewriter对象。该对象一被初始化就必须要明确被操作的文件。  
  //而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖。
//其实该步就是在明确数据要存放的目的地。
          FileWriter   fw=newFileWriter("demo.text");  
        //调用Writer方法，将字符串写入到流中  
     fw.writer("abcse"); 
     //刷新流对象中的缓冲区中的数据，将数据刷新到目的地中  
     fw.flush(); 
     //关闭流资源，但是关闭之前会刷新一次
内部的缓冲区的数据  
     //将数据刷新到目的地中。  
     //和flush()区别：flush刷新后，流可以继续使用，close()刷新后，会将流关闭。流不可以继续使用  
     fw.close(); 
 } 
}

对已有文件的数据续写:

publicFileWriter(String fileName, boolean append) throws IOException

例：

importjava.io.*;
class  FileWriterDemo3
{
publicstatic void main(String[] args) throws IOException
{
//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
FileWriterfw = new FileWriter("demo.txt",true);
fw.write("nihao\r\nxiexie");//Windows下\r\n表示换行，如果只是\n则不能识别
fw.close();
}
}

FileReader字符文件的数据读取:

publicint read()  throws IOException//单个字符读取方法

publicint read(CharBuffer target)  throwsIOException//字符数组读取方式

单个字符读取：

例:

importjava.io.*;
class  FileReaderDemo
{
publicstatic void main(String[] args) throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException（IOException的子类）
FileReaderfr = new FileReader("demo.txt");
//调用读取流对象的read方法。
//read():一次读一个字符。而且会自动往下读。
int ch =0;
while((ch=fr.read())!=-1)//file中字符数据读取完了会返回-1
{
System.out.println((char)ch);//强制转换成字符类型
}
fr.close();  //关闭
}
}

字符数组读取：

例:

importjava.io.*;
classFileReaderDemo2
{
publicstatic void main(String[] args) throws IOException
{
FileReaderfr = new FileReader("demo.txt");
//定义一个字符数组。用于存储读到字符。
//该read(char[])返回的是读到字符个数。
char[]buf = new char[3];//通常定义大小是1024，为2KB（字符占2B）
int num= 0;
while((num=fr.read(buf))!=-1)//判断是否读取完
{
/*
调用publicString(char[] value,int offset, int count)
当最后不足三个时，可以避免重复打印出现有字符
*/
System.out.println(newString(buf,0,num));
}
fr.close();
}
}

注：后一次读取到buf中的字符会覆盖前一次的字符，

因为在内存开辟的字符数组空间只能存储三个字符。

IO异常的基本处理方式：

示例：

importjava.io.*;
class  FileWriterDemo2
{
         public static void main(String[] args)
         {
                   //先声明引用，放在try块外面，否则finally中fw.close没法操作，受到作用域的限制
                   FileWriter fw = null;
                   try
                   {
                            /*因为创建、打开都可能抛出异常，而且几个操作都是相关联的
                            所以放在一个try块中进行操作
                            */
                            fw = newFileWriter("demo.txt");
                            fw.write("abcdefg");
                   }
                   catch (IOException e)
                   {
                            System.out.println("catch:"+e.toString());
                   }
                   finally
                  {
                            //colse也需要捕捉异常
                            try
                            {
                                     //先判断是否为空，因为创建出现异常的话，fw为null，使用的话会出现空指向异常
                                     if(fw!=null) 
                                     fw.close(); 
                            }
                            catch (IOExceptione)
                            {
                                     System.out.println(e.toString());
                            }
                   }
         }
}

读取写入同时操作：

有两种方式，一种边读边写，另一种是读完再写，后者效率更高。

示例：

import java.io.*;
classCopyText
{
         public static void main(String[] args)throws IOException
         {
                   copy_2();
         }
         //文本文件读取方式一：从C盘读一个字符，就往D盘写一个字符。
         public static void copy_1()throwsIOException
         {
         //创建目标文件和输出流。
         FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
         //与已有文件关联，输入流。
         FileReader fr = newFileReader("RuntimeDemo.java");
         int ch = 0;
         while((ch=fr.read())!=-1)
         {
                   fw.write(ch);
         }
         fw.close();
         fr.close();
}
 
//文本文件读取方式二：全部读取到内存的缓冲区，再写入。
publicstatic void copy_2()
{
         FileWriter fw = null;
         FileReader fr = null;
         try
         {
                   fw = newFileWriter("SystemDemo_copy.txt");
                   fr = newFileReader("SystemDemo.java");
                   char[] buf = new char[1024];
                   int len = 0;
                   while((len=fr.read(buf))!=-1)
                   {
                   /*
                   public void write(Stringstr,int off, int len) throws IOException
                   避免将char数组后面的空格也都写入
                   */
                   fw.write(buf,0,len);
                   }
         }
         //正规的异常捕获操作
         catch (IOException e)
         {
                   throw newRuntimeException("读写失败");
         }
         finally
         {
                   //多个流对象时需要用多个if来判断
                   if(fr!=null)
                   try
                   {
                            fr.close();
                   }
                   catch (IOException e)
                   {}
                   if(fw!=null)
                   try
                   {
                            fw.close();
                   }
                   catch (IOException e)
                   {}
         }
}
}

三、缓冲输入输出流BufferWriter和BufferReader

         缓冲区的出现是为了提高流的操作效率而出现的。

         所以在创建缓冲区之前，必须要先有流对象。

1、BufferWriter

Java提供的带缓冲功能的Writer类。

缓冲区的出现提高了对数据的读写效率。

将需要被提高效率的流对象作为参数传递给BufferedWrtier的构造函数即可。

常用方法：

publicBufferedWriter(Writer out)//构造方法

publicvoid write(String s,  int off, int len)throws IOException//写方法

publicvoid newLine() throws IOException//BufferWriter中提供的一个跨平台的换行操作

示例：

importjava.io.*;
class  BufferedWriterDemo
{
publicstatic void main(String[] args) throws IOException
{
//创建一个字符写入流对象。
FileWriterfw = new FileWriter("buf.txt");
//为了提高字符写入流效率。加入了缓冲技术。
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriterbufw = new BufferedWriter(fw);
for(intx=1; x<5; x++)
{
//父类方法中有publicvoid write(String s) throws IOException，所以不用传入off和len
//注意查看父类方法
bufw.write("abcd"+x);
bufw.newLine();
bufw.flush();
}
//记住，只要用到缓冲区，就要记得刷新。
//bufw.flush();
//其实关闭缓冲区，就是在关闭缓冲区中的流对象。
bufw.close();
}
}

2、BufferReader

常用方法：

publicBufferedReader(Reader in)//构造方法

publicString readLine()throws IOException//读取一行的读取方法，但是不包含行终止符，输出时不会自动换行

示例：

importjava.io.*;
class  BufferedReaderDemo
{
publicstatic void main(String[] args) throws IOException
{
//创建一个读取流对象和文件相关联。
FileReaderfr = new FileReader("buf.txt");
//为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
BufferedReaderbufr = new BufferedReader(fr);
Stringline = null;
while((line=bufr.readLine())!=null)//返回null时表示字符已经读取完
{
System.out.print(line);
}
bufr.close();
}
}

3、readLine方法的的原理以及模拟

一次读取一行数据，当返回null时，表示读到文件末尾。

打印时需要换行输出，该方法不会读取行末尾的换行符。

示例：

importjava.io.*;
classMyBufferedReader extends Reader//继承Reader
{
privateReader r;
MyBufferedReader(Readerr)
{
this.r =r;
}
//可以一次读一行数据的方法。
publicString myReadLine()throws IOException//自己创建一个功能可以直接抛出给调用者去捕捉异常
{
//定义一个临时容器。原BufferReader封装的是字符数组。
//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
StringBuildersb = new StringBuilder();
int ch =0;
while((ch=r.read())!=-1)
{
if(ch=='\r')
continue;  //跳过不读取
if(ch=='\n')
returnsb.toString();//将一行的字符转换成字符串返回
else
sb.append((char)ch);//添加字符
}
//因为最后一行字符不存在\r\n换行符，没法返回所以需要在末尾进行判断
if(sb.length()!=0)
returnsb.toString();//返回最后一行字符串
returnnull; 
}
/*
必须复写Reader类中的抽象方法。
*/
publicint read(char[] cbuf, int off, int len) throws IOException
{
returnr.read(cbuf,off,len) ;
}
publicvoid close()throws IOException
{
r.close(); 
}
publicvoid myClose()throws IOException//给方法调用者捕捉
{
//BufferWriter的close方法实质也是调用的Write的close方法
//所以关闭BufferWriter之后也不需要再关闭FileWriter了。
r.close();
}
}
class  MyBufferedReaderDemo
{
publicstatic void main(String[] args) throws IOException
{
FileReaderfr = new FileReader("buf.txt");
MyBufferedReadermyBuf = new MyBufferedReader(fr);
Stringline = null;
while((line=myBuf.myReadLine())!=null)
{
System.out.println(line);
}
myBuf.myClose();
}
}

4、return语句的一些问题

示例：

publicclass ReturnDemo01
{
publicstatic void main(String[] args)
{
System.out.println(return01());
}
publicstatic String return01()
{
return"return---";
//返回语句后面不应该存在语句，否则会报错：不能访问的语句
//System.out.println("Afterreturn");
}
}

5、LineNumberReader

BufferReader的子类。

此类定义了方法setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。

常用方法：

publicint getLineNumber()//获取行号

publicvoid setLineNumber(int lineNumber)//设置初始行号

其实质是读取一行的时候设置了一个计数器。

6、转换流OutputWriter、InputReader将字节流转换成字符流

//构造方法，需要传入字节输入流，通常传入System.in使用，源设备是键盘

publicInputStreamReader(InputStream in)

//构造方法，需要传入字节输出流流对象，通常传入System.out使用，目标设备是控制台

publicOutputStreamWriter(OutputStream out)

子类：

publicFileWriter(String fileName)throws IOException//可以直接传入字符文本文件名，

public FileWriter(Filefile) throws IOException//传入字符文本文件对象

publicFileReader(File file)  throwsFileNotFoundException//可以直接传入字符文本文件名

publicFileReader(String fileName)throws FileNotFoundException//传入字符文本文件对象

方式一：

当源设备是键盘，目标设备是控制台，操作的是字符时使用。

示例：

importjava.io.*;
publicclass SystemInOutDemo
{
publicstatic void main(String[] args) throws IOException
{
/*
修改标准输入输出设备
使用System提供的两个静态方法
System.setIn(newFileInputStream("PersonDemo.java"));
System.setOut(newPrintStream("zzz.txt"));//传入一个打印流
*/
BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriterbufw = new BufferedWriter(new OutputStreamWriter(System.out));
Stringstr = null;
while((str=bis.readLine())!=null)
{
bos.write(str);
bos.flush();  //刷新后才能在控制台显示
}
bis.close();
bos.close();
}
}

方式二：

当需要将输出流进行转码时，默认的编码是GBK，如果不要转换编码用其子类FileWriter（使用的是默认编码）输出即可。

示例：

//传入一个FileOutputStream的字节流，编码修改为UTF-8

OutputStreamWriterosw = new OutputStreamWriter(newFileOutputStream("d.txt"),"UTF-8");

四、装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，需要扩展时一般不直接修改已封装的类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。

装饰设计模式的基本格式：

         含有被装饰类的引用。

         通过构造函数传入被装饰类对象。

         和被装饰类含有同样的方法，其中调用被装饰类的方法，对其进行改进、增强。

         和被装饰类继承同一个类或实现同一个接口，可以当做被装饰类来使用。

装饰类通常会通过构造方法接收被装饰的对象。

并基于被装饰的对象的功能，提供更强的功能。

readLine其实就是利用装饰设计模式设计的。

装饰设计模式的应用：

         BufferedReader、BufferedWriter都是装饰类，他们可以装饰一个Reader或Writer，给被装饰的Reader和Writer提供缓冲的功能。

示例：

//SuperPerson就是装饰类
classPerson
{
publicvoid chifan()
{
System.out.println("吃饭");
}
}
classSuperPerson
{
privatePerson p ;
SuperPerson(Personp)
{
this.p =p;
}
publicvoid superChifan()
{
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
System.out.println("来一根");
}
}
class  PersonDemo
{
publicstatic void main(String[] args)
{
Person p= new Person();
//p.chifan();
SuperPersonsp = new SuperPerson(p);
sp.superChifan();
}
}

装饰和继承的区别：

         装饰模式比继承要灵活，避免了继承体系臃肿，而且降低了类于类之间的耦合性。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。

所以装饰类和被装饰类通常是都属于一个体系中的。

实质也是使用的组合，在开发设计中在能够使用组合的时候避免使用继承，需要降低继承的层次。

注：BufferWriter和BufferReader就是两个装饰类。

比如：

需要为某一个类或接口下面的很多子类提供增强功能。如果分别为每个子类设计新的继承类，则需要设计很多结构类似的类。

如果设计一个装饰类，将需要增强的子类通过参数传给这个装饰类，那么只需要设计一个类就能解决所有子类的增强功能的需求。

而这个装饰类只需要和这些子类具有相同的父类和接口即可。

         装饰类增强的是已有对象，具备的功能和已有对象的是相同的，只不过提供了更强功能。

         装饰类和被装饰类通常都是属于一个体系中的（即所属于同一个父类或同一个接口）。

五、字节流

字节流概述：

         基本操作与字符流类相同。

         字节流可以操作任意类型数据。

OutputStream中的常用方法：

         写操作：

         void write(byte[] b);//将 b.length 个字节从指定的 byte 数组写入此输出流。

         void write(byte[] b, int off, intlen);//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

         abstract void write(int b);//将指定的字节写入此输出流。

         刷新流：

         void flush();//OutputStream的flush方法不执行任何操作。

         关闭流：

         void close();//关闭此输出流并释放与此流有关的所有系统资源。  InputStream中的常用方法：

         读操作：读方法是阻塞式方法，如果没有读到数据，就会一直等待。

         abstract int read();//从输入流中读取数据的下一个字节。

         int read(byte[] b);//从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。

         int read(byte[] b, int off, int len);//将输入流中最多len个数据字节读入byte数组。

         关闭流：

         void close();//关闭此输入流并释放与该流关联的所有系统资源。

         注：InputStream中没有刷新流。

FileOutputStream和FileInputStream：

         OutputStream 的 flush 方法不执行任何操作。FileOutputStream没有覆盖OutputStream的 flush 方法，因此也不执行任何操作。

FileInputStream的特有方法：

         int available();//返回文件字节数，用于定义缓冲字节数组的大小。但是不能超过系统内存，因此慎重使用。数据量太大时，建议使用字节数组循环的方式读取数据。

字节流复制图片示例：

/*
需求：复制一个图片
思路：
1.用字节读取流对象和图片关联
2.用字节输出流对象创建一个图片文件，用于存储获取到的图片数据
3.通过循环读写，完成数据的存储
4.关闭资源
*/ 
importjava.io.*;
class  CopyPic
{
publicstatic void main(String[] args)
{
FileOutputStreamfos = null;
FileInputStreamfis = null;
try
{
fos =new FileOutputStream("c:\\2.jpg");
fis =new FileInputStream("c:\\1.jpg");
//接收流读取的数据用字节数组接收，其他操作与字符流类似。
byte[]buf = new byte[1024];
int len= 0;
while((len=fis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
}
catch(IOException e)
{
thrownew RuntimeException("复制文件失败");
}
finally
{
try
{
if(fis!=null)
fis.close();
}
catch(IOException e)
{
thrownew RuntimeException("读取关闭失败");
}
try
{
if(fos!=null)
fos.close();
}
catch(IOException e)
{
thrownew RuntimeException("写入关闭失败");
}
}
}
}

         注意：不能使用字符流对象复制媒体文件，因为字符流读取数据后会根据编码表进行查表，如果编码表没有找到对应的符号，会存储一个近似的符号，导致数据被修改，从而无法完全复制。

字节流缓冲区：

示例：

/*
需求：复制一个mp3文件，通过缓冲区
*/ 
importjava.io.*;
class  CopyMp3
{
publicstatic void main(String[] args) throws IOException
{
longstart = System.currentTimeMillis();
copy_1();
long end= System.currentTimeMillis();
System.out.println((end-start)+"毫秒");//计算复制所花的时间
}
//通过字节流的缓冲区完成复制。
publicstatic void copy_1()throws IOException
{
BufferedInputStreambufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));
BufferedOutputStreambufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));
int by =0;
while((by=bufis.read())!=-1)
{
bufos.write(by);
}
bufos.close();
bufis.close();
}
}

为什么read方法返回的类型是int而不是byte：

         避免因为读到8个1而误以为返回-1，错误地结束读取。所以将byte类型提升为int类型。

         为了保证最高位都为0，read方法将读到的字节数据与255做&运算，从而实现只保留读到的最低字节，int值的其它字节均为0。

         从而保证了程序不会因为读到连续8个1而结束读取。

         为了保证数据的原样性，write方法虽然接收int型参数，但是在输出时，会去掉高字节，只保留最低8位。

转换流

转换流概述：

转换流的由来：

         字符流与字节流之间的桥梁。

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

转换流的应用：

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

读取转换流：InputStreamReader

         字节通向字符的桥梁，可以将字节流对象作为参数传递给InputStreamReader的构造函数。

写入转换流：OutputStreamWriter

         字符通向字节的桥梁，可以将字节流对象作为参数传递给OutputStreamWriter的构造函数。

六、流操作的基本规律

确定使用的流的步骤：

1，明确源和目的。

源：输入流。InputStream  Reader

目的：输出流。OutputStream  Writer。

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

是：字符流。

不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。

通过设备来进行区分：

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

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

4、最后再明确是否需要缓冲区来提高效率。

转换流什么时候使用：

字符和字节之间的桥梁。

涉及到字符编码转换时。

         InputStreamReader和OutputStreamWriter可以在构造函数中指定字符集。

七、File 封装了文件和文件目录的类

1、File的三个构造方法

可以将已有的和未出现的文件或者文件夹封装成对象

publicFile(File parent, String child)

publicFile(String parent,String child)

publicFile(String pathname)

示例：

//将a.txt封装成file对象。

File f1= new File("a.txt");

//在目录c:\\abc下创建文件b.txt

File f2= new File("c:\\abc","b.txt");

//将目录封装成File对象

File d =new File("c:\\abc");

File f3= new File(d,"c.txt");

2、分隔符的使用

Windows下的分隔符有两种：斜杠“/”和双反斜杠“\\”

但是为了保持java程序的跨平台性，通常使用File.separator

示例：

File f4= newFile("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");

3、File类常见方法

3.1创建。

booleancreateNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

booleanmkdir():创建文件夹。

booleanmkdirs():创建多级文件夹。

3.2删除。

booleandelete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。

voiddeleteOnExit();在程序退出时删除指定文件。

3.3判断。

booleanexists() :文件是否存在.

isFile():是否是文件

//记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。

isDirectory();是否是目录

isHidden();是否隐藏

isAbsolute();是否是绝对路径，即使对象中的文件不存在也能判断

3.4获取信息。

getName():  获取名称

getPath():  获取路径

getParent()://该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。

//如果相对路径中有上一层目录那么该目录就是返回结果。

getAbsolutePath()文件不存在也能获取到

longlastModified() 以毫秒为单位返回上次修改的时间

longlength() 以字节单位文件的大小

4、文件列表的获取

常用方法：

publicstatic File[] listRoots()//获取系统可用盘符

publicString[] list()//以String形式返回当前目录下中的文件名

publicString[] list(FilenameFilter filter)//通过自定义过滤规则返回特定文件

publicFile[] listFiles()//返回文件对象的信息，包括文件大小等

5、递归获取文件目录下所以内容，包含子目录中的文件

分析：因为目录中还有目录，只要使用同一个列出目录功能的方法完成即可。

在列出过程中出现的还是目录的话，还可以再次调用本功能。

也就是方法自身调用自身。

递归要注意的事项：

1，限定条件，避免死循环。

2，要注意递归的次数，尽量避免内存溢出。因为递归通常都是先返回最内层的文件。

所以外层需要在栈上存储，在空间上消耗较大。

八、Properties类

Properties是hashtable的子类。

也就是说它具备map集合的特点，而且它里面存储的键值对都是字符串。

是集合中和IO技术相结合的集合容器。

特点：可以用于键值对形式的配置文件，那么在加载数据时，需要数据有固定格式：键=值。

常用方法：

1、获取

publicString getProperty(String key)

publicString getProperty(String key,  StringdefaultValue)

2、打印输出流的的信息 

publicvoid list(PrintWriter out)

publicvoid list(PrintStream out)

3、修改

publicSet<String> stringPropertyNames()

publicObject setProperty(String key,  Stringvalue)

4、加载输入流中的信息

publicvoid load(InputStream inStream) throws IOException

例：

/*
使用Properties父接口的方法来实现存取。
*/
importjava.util.*;
publicclass PropertiesDemo
{
publicstatic void main(String[] args)
{
Propertiesprop = new Properties();
prop.put("name","hezi");
prop.put("age","21");
//Properties没有指定泛型，返回的是Object类型
Set ts =prop.keySet();
for(Objects:ts)
{
System.out.println(s+ "---" + prop.get(s.toString()));
}
}
}

九、打印流PrintWriter和PrintStream

该流提供了打印方法，可以将各种数据类型的数据都原样打印，可以自动刷新。

PrintStream字节打印流：

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

PrintWriter字符打印流：

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

例：

/*
字符打印流的基本操作。
*/
importjava.io.*;
class  PrintStreamDemo
{
publicstatic void main(String[] args) throws IOException
{
BufferedReaderbufr =
newBufferedReader(new InputStreamReader(System.in));
//将控制台输入的数据输出到a.txt字符文件中
PrintWriterout = new PrintWriter(new FileWriter("a.txt"),true);//true表示自动刷新
Stringline = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
//out.flush();//当printWriter的对象是System.out注意刷新才能显示
}
out.close();
bufr.close();
}
}

十、合并流SequenceInputStream

用于将多个流合并成一个流，有以下两个构造方法：

//将两个流合并成一个流

publicSequenceInputStream(InputStream s1, InputStream s2)

//将多个流合并成一个流

publicSequenceInputStream(Enumeration<? extends InputStream> e)

十一、管道流PipedInputStream和PipedOutputStream

    管道流的作用：去连接管道中io流；

    建议：你应该去建立两个线程分别取封装这两个管道，在单线程可能会死锁。

    创建方法：1.PipedInputStream(PipedOutputStream());//在参数的位置去传入一个管道流。

                 2.PipedInputStream(); 利用方法connect(PipedOutputStream());就可以建立连接了。

这样建立了连接之后；用pis。read读取数据；用pos。write写出数据。

管道流到底有什么作用呢？

他可以建立一个连接；方便了程序中的输入与输出同时进行。

十二.RandomAccessFile随机读写文件流

    特殊方法：.getFilePointer();//获得指针位置；

                .seek(long length);//通过length大小可以跳到指定位置。

    首先你必须要建立一个RandomAccessFile(filepath,mode);//对象中mode表示指定的mode即“r”“rw”等。

    raf.write();//要写入一个int的后八位，转化为字节，当你传入259的时候，就会出现错了。

    raf.writeint();//写32位的int整数。

 

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net