黑马程序员—IO流1

---------------------- JavaEE+Android、Java培训、期待与您交流！ ----------------------

IO流

输入输出流，即Input Output的缩写

特点：

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

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

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

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

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

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

IO流的常用基类

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

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

字符流

字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。字符流只用于处理文字数据，而字节流可以处理媒体数据。

字符流的读写

<span style="font-family:Arial;font-size:10px;">import java.io.*;class IODemo{public static void main(String[] args){FileWriter fw =null;FileReader fr = null;//检测异常try{//创建读写对象，并指定目的地fw = new FileWriter("Demo.txt");fr = new FileReader("Demo.txt");//将数据写入到指定文件中for(int i=0;i<5;i++){fw.write("abcde" + i + "\r\n");fw.flush();}//从指定文件中读取数据int len = 0;char[] ch = new char[1024];while((len=fr.read(ch))!=-1){System.out.println(new String(ch,0,len));}}//捕获异常catch (IOException e){throw new RuntimeException("读写文件失败");}//最终关闭两个流资源finally{if(fw!=null){try{fw.close();}catch (IOException e){throw new RuntimeException("关闭流资源失败。");}}if(fr!=null){try{fr.close();}catch (IOException e){throw new RuntimeException("读取流资源失败。");}}}}}</span>

文件的拷贝：

原理：其实就是将一个磁盘下的文件数据存储到另一个磁盘的一个文件中
步骤：
1、在D盘上创建一个文件，用于存储E盘文件中的数据
2、定义读取流和E盘文件关联
3、通过不断读写完成数据存储
方式一：读取一个字符，存入一个字符
方式二：先将读取的数据存入到内存中，再将存入的字符取出写入D盘
4、关闭流资源：输入流资源和输出流资源。

<span style="font-family:Arial;">import java.io.*;class CopyDemo{public static void main(String [] args){FileReader fr = null;FileWriter fw = null;try{fr = new FileReader("E:\\Dmeo.txt");fw = new FileWriter("D:\\Dmeo.txt");char[] ch = new char[1024];int len = 0;//用ch将读取的文件和写入的文件关联起来while((len=fr.read(ch))!=-1){fw.write(ch,0,ch.length);}}catch (IOException e){throw new RuntimeException("文件读写失败");}finally{if(fr!=null){try{fr.close();}catch (IOException e){throw new RuntimeException("读取流资源关闭失败。");}}if(fw!=null){try{fw.close();}catch (IOException e){throw new RuntimeException("写入流资源关闭失败。");}}}}}</span>

字符流缓冲区：BufferedWriter和BufferedReader

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

2、缓冲技术原理：此对象中封装了数组，将数据存入，在一次性取出。

3、写入流缓冲区BufferedWriter的步骤：

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

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

      注意，只要用到缓冲去就需要刷新。

3）其实关闭缓冲区就是在关闭缓冲区中的流对象。该缓冲区中提供了一个跨平台的换行符：newLine()。

4、读取流缓冲区BufferedReader的步骤：

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

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

3）该缓冲区提供了一个一次读一行的方法readLine()，方便与对文本数据的获取，当返回null时，表示读到文件末尾。

      readLine()方法返回的时只返回回车符之前的数据内容，并不返回回车符，即读取的内容中不包含任何行终止符（回车符和换行符）。

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

5、使用缓冲技术拷贝文件，提高效率

<span style="font-family:Arial;">import java.io.*;class CopyBufferedDemo{public static void main(String[] args) {BufferedReader bufr = null;BufferedWriter bufw = null;try{//创建缓冲区，将读写流对象作为参数传入bufr = new BufferedReader(new FileReader("D:\\JAVA\\IO\\buffered\\myJava.txt"));bufw = new BufferedWriter(new FileWriter("D:\\JAVA\\IO\\文件拷贝\\myJava.txt"));//定义字符串，通过readLine一次读一行，并存入缓冲区String line = null;while((line=bufr.readLine())!=null){//将读取到缓冲区的数据通过line存入写入流中bufw.write(line);//换行符方法bufw.newLine();//将数据刷新到指定文件中bufw.flush();}}catch (IOException e){throw new RuntimeException("读写文件失败。");}finally{if(bufr!=null){try{bufr.close();}catch (IOException e){throw new RuntimeException("读取流资源关闭失败。");}}if(bufw!=null){try{bufw.close();}catch (IOException e){throw new RuntimeException("写入流资源关闭失败。");}}}}}</span>

6、自定义BufferedReader

原理：可根据BufferedReader类中特有发那个发readLine()的原理，自定义一个类中包含相同功能的方法

步骤：a.初始化自定义的类，加入流对象。

            b.定义一个临时容器，原BufferedReader封装的是字符数组，此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。

import java.io.*;//自定义一个功能与BufferedReader相似的类，继承Readerclass MyBufferedReader extends Reader{//定义变量，用于全局private Reader r;//构造函数，传入读取流对象MyBufferedReader(Reader r){this.r = r;}//复写readLine放，并将异常抛出，有调用者处理public String MyReadLine()throws IOException{//定义存储字符串的容器StringBuilder sb = new StringBuilder();int ch = 0;//read()方法遍历文件，当达末尾时判断是否为-1结束循环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();//读到结尾处，返回nullreturn 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();}//创建自定义close方法public void MyClose()throws IOException{r.close();}}//测试class MyBufferedDemo{public static void main(String [] args){MyBufferedReader mbr = null;//检测异常try{mbr = new MyBufferedReader(new FileReader("Demo.txt"));String line = null;//遍历文件，读取数据while ((line=mbr.MyReadLine())!=null){System.out.println(line);}}//捕获异常catch (IOException e){throw new RuntimeException("读取文件失败。");}//最终关闭资源finally{if(mbr!=null){try{mbr.MyClose();}catch (IOException e){throw new RuntimeException("读取流关闭失败。");}}}}}

7、LineNumberReader

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

setLineNumber()和getLineNumber()

示例：

......try{fr = new FileReader("myJava.txt");lnr = new LineNumberReader(fr);lnr.setLineNumber(100);String line = null;while((line=lnr.readLine())!=null){System.out.println(lnr.getLineNumber() + ":  " + line);}}......

装饰设计模式

1、简述：当想对已有对象进行功能增强是，可定义类：将已有对象传入，基于已有对象的功能，并提供加强功能，那么自定义的该类称之为装饰类。即对原有类进行了优化。

2、特点：装饰类通常都会通过构造方法接收被装饰的对象，并基于被装饰的对i型那个的功能提供更强的功能。

3、装饰和继承的区别：

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

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

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

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

        要继承相应的父类，就需要将所有的抽象方法实现，或交给子类实现。

示例：其中MyBufferedReader的例子就是最好的装饰设计模式的例子。

字节流

字节流和字符流的原理是相似的，只不过字节流可以对媒体进行操作。

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

拷贝媒体文件：

1、思路：

1）用字节流读取流对象和媒体文件相关联

2）用字节写入流对象，创建一个媒体文件，用于存储获取到的媒体文件数据

3）通过循环读写，完成数据的存储

4）关闭资源

import java.io.*;class CopyPic{public static void main(String[] args) {//创建流对象引用FileOutputStream fos = null;FileInputStream fis = null;try{//创建读写流对象fos = new FileOutputStream("2.gif");fis = new FileInputStream("1.gif");int len = 0;//定义字节数组，存储读取的字节流byte[] arr = new byte[1024];//循环读写流，完成数据存储while((len=fis.read(arr))!=-1){fos.write(arr,0,len);}}catch (IOException e){throw new RuntimeException("复制图片失败");}//最终关闭资源finally{if(fos!=null){try{fos.close();}catch (IOException e){throw new RuntimeException("写入流关闭失败");}}if(fos!=null){try{fis.close();}catch (IOException e){throw new RuntimeException("读取流关闭失败");}}}}}

字节流缓冲区：

1、读写特点：

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

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

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

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

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

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

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

5）到了文件的结尾处，存入最后一组数据，当取完数组中的元素，就会减少到0，这是全部数据就取完了

自定义字节流缓冲区：

思路：
1、定义一个固定长度的数组
2、定义一个指针和计数器用于读取数组长度，和计数数组元素是否取完为0
3、每次将字节数据存入元素要先将数组中的元素取完

注：取出的是byte型，返回的是int型，这里存在提升的动作，
当byte中的八位全为1的时候是byte的-1，提升为int类型，就变为int型的-1，，read循环条件就结束了
变为-1的原因是由于在提升时，将byte的八位前都补的是1，即32位的数都是1，即为int型的-1了。
如何保证提升后的最后八位仍为1呢？就需要将前24位补0，就可以保留原字节数据不变，又可以避免转为int型出现-1的情况；
那么要如何做呢？
这就需要将提升为int的数据和前24位为0，后八位仍为原字节数据的这个值做与运算。即和255做与运算即可

import java.io.*;class MyBufferedInputStream{private InputStream in;byte[] by = new byte[1024*4];private int pos=0,count=0;//传入加强的类MyBufferedInputStream(InputStream in){this.in = in;}//自定义读取方法public int myRead()throws IOException{//先判断计数器if(count==0){//计数器为0则存入数据count = in.read(by);//计数器为负则返回-1，说明结束数据读取if(count<0)return -1;//每次从数组中读取数据完，指针要归零，重新移动指针pos = 0;//获取存入数组的元素，并需要让指针和计数器相应变化byte b = by[pos];count--;pos++;//返回读取的值，需要与运算return b&255;}//计数器大于零时，不需要存数据，只需读取else if(count>0){byte b = by[pos];count--;pos++;return b&0xff;}//为-1时即到数据结尾return -1;}public void myClose()throws IOException{in.close();}}

File类

文件和目录路径的抽象表现形式

特点：

1）用来将文件或文件夹封装成对象

2）方便于对文件与文件夹的属性信息进行操作

3）File对象可以作为多数传递给流的构造函数

创建File对象：

方式一：File f1 = new File("a.txt");将a.txt封装成对象，可将已有的和未出现的文件或文件夹封装成对象

方式二：File f2 = new File("c:\\abc","b.txt");分别指定文件夹和文件。好处：降低了两者的关联程度，

方式三：File d = new File("c:\\abc");     File f3 = new File(d,"c.txt");可以传入父目录和文件名。

目录分隔符：调用File.separator，相当于是反斜杠 \

File类常见方法：

1、创建：

boolean createNewFile()  在指定位置创建文件，若文件存在，则返回true，与输出流不同，输出流对象已建立就创建文件，如果存在，就会被覆盖 

boolean mkdir()创建文件夹，只能创建一级目录

boolean mkdirs()创建多级文件夹。

2、删除：

boolean delete()   删除文件。文件存在，返回true；文件不存在或者正在被执行，返回false

void deleteOnExit() 在程序结束时删除文件

3、判断：

boolean canExecute()        当前文件是否能被执行

boolean exists()当前文件是否存在

boolean isFile()       当前文件是否是文件

boolean isDirectory()       当前文件是否是文件夹（目录）；注意：在判断文件对象是否是文件或目录是们必须要判断该文件对象封装的内容是否存在，通过exists判断

boolean isHidden()     当前文件是否是隐藏文件

boolean isAbsolute()      测试此抽象路径名是否为绝对路径名

4、获取信息：

String getName()      获取文件名

String getPath()     获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）

String getParent()   获取父目录，该方法返回绝对路径中的父目录，获取相对路径，返回null， 如果相对路径中有上一级目录，则返回的即为该目录

String getAbsolutePath()     获取绝对路径

long length()      返回文件的大小

long lastModified()       返回上次修改的时间

static File[] listRoots() 获取文件的系统根，即各个盘符

String[] list()     列出当前目录所有文件，包含隐藏文件。注：调用了list方法的file对象，必须是封装了一个目录，且该目录必须存在。

boolean renameTo(File dest)对文件重命名为dest

5、列出及过滤文件：

String[] list()列出当前目录所有文件，包含隐藏文件，调用list方法的file对象，必须是封装了一个目录，且该目录必须存在。

File[] list(FilenameFilter filter)

FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(File dir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。

File[] listFiles()获取当前文件夹下的文件和文件夹，返回类型为File数组

ListFiles(FilenameFilter filter)同list，是对获取的 当前文件夹下的文件和文件夹的 文件名过滤器。

Properties类

Properties是Hashtable的子类，它具备Map集合的特点，而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术想结合的集合容器。

特点：

1）可用于键值对形式的配置文件

2）在加载时，需要数据有固定的格式，常用的是：键=值

特有方法：

1、设置和获取元素：

Object setProperty(String key,String value)调用Hashtable的方法put

String getProperty(String key)指定key搜索value

Set<String> stringPropertyName()返回属性列表的键集，存入Set集合

void load(InputStream ism)从输入字符流中读取属性列表

void load(Reader reader) 从输入字符流中读取属性列表

//load方法public static void loadMthod()throws IOException{Properties pop =new Properties();FileInputStream fis = new FileInputStream("info.txt");//将流中的数据加载进集合pop.load(fis);pop.setProperty("zz","25");pop.setProperty("ww","24");FileOutputStream fos = new FileOutputStream("info.txt");pop.store(fos,"hehe");pop.list(System.out);fis.close();fos.close();}

//将流中的数据存储到集合中public static void method()throws IOException{BufferedReader bufr = null;try{Properties pop = new Properties();bufr = new BufferedReader(new FileReader("info.txt"));String line = null;while((line=bufr.readLine())!=null){String[] arr = line.split("=");pop.setProperty(arr[0],arr[1]);}System.out.println(pop);}catch (IOException e){throw new RuntimeException("文件操作失败");}finally{try{if(bufr!=null)bufr.close();}catch (IOException e){throw new RuntimeException("关闭流资源操作失败");}}}

用于记录应用程序运行次数

如果使用次数已到，那么给出注册提示需要使用计数器，但是在程序结束后，会在内存中消失，此时就需要将其存入到文件中，所以需要一个配置文件，用于记录该软件使用的次数。便于阅读和操作数据

键值对数据 --->   Map集合；数据以文件形式存储 --->   IO技术。 --->Map+IO=Properties

import java.util.*;

import java.io.*;class RunCount{public static void main(String [] args)throws IOException{//创建一个Properties对象，集合和io的结合Properties pop = new Properties();//创建一个文件对象，用于操作文件File file = new File("count.ini");//先判断文件是否存在，如果不存在就创建一个if(!file.exists())file.createNewFile();//创建读取流对象，读取文件中的信息FileInputStream fis = new FileInputStream(file);//将流中的文件信息存入集合中pop.load(fis);//定义计数器int count = 0;//获取文件中键所对应的值String value = pop.getProperty("time");//判断值是否为null，不为空就将值传给计数器if(value!=null){count = Integer.parseInt(value);//判断计数器是否为到达次数if(count>=5){System.out.println("次数已到，请注册");return ;}}count++;//将获得的键值设置后存入集合中pop.setProperty("time",count+"");FileOutputStream fos = new FileOutputStream(file);pop.store(fos,"");fos.close();fis.close();}}

---------------------- JavaEE+Android、Java培训、期待与您交流！ ----------------------

详细请查看： http://edu.csdn.net