黑马程序员_IO流

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

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

Java对数据的操作是通过流的方式，注意：流的操作只有两种：读和写。

流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。

流的分类：

1、流按操作数据分为两种:字符流和字节流

2、流按流向分为:输入流，输出流

 

流的体系:

流因为功能不同，但是有共性内容，不断抽取，形成继承体系。该体系一共有四个基类，而且都是抽象类。

1、字节流：InputStream  OutputStream

2、字符流：Reader  Writer

在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称。

流对象：因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。

1、明确数据源，数据汇(数据目的)
其实就是在明确要使用的IO体系。 InputStream /OutputStream /Reader /Writer

需求中操作的是源，意味着读。
InputStream Reader

需求中操作的是目的，意味着写。
OutputStream Writer


2、明确操作的数据是否是纯文本数据？

是，字符流。
否，字节流。
是，并且是源，Reader
是，并且是目的，Writer


通过前面两个明确，明确了具体要使用的体系。


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


3、明确要操作的具体设备。
源设备:
键盘:System.in
硬盘:File开头
内存:数组 ArrayStream
网络:socket流
目的设备:
显示器:System.out
硬盘:File开头
内存:数组 ArrayStream
网络:socket流

 

字符流：

Reader：

用于读取字符流的抽象类。子类必须实现的方法只有read(char[], int, int) 和 close()。

       |---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

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

       |---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

       |---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

     |---CharArrayReader：

     |---StringReader：

Reader基本方法：    //默认编码GBK.

    read();       //返回一个整数的字符，如果已到达流的末尾，返回-1;一次读取一个字符，而且会自动往下读。

    close();   //关闭流对象。

    |--FileReader()

       构造函数:

           FileReader(Filefile)

           FileReader(StringfileName)

   

    //创建一个文件读取流对象

 FileReader fr = newFileReader("demo.txt");

//该对象一建立就必须和指定名称的文件相关联，当该文件不存在，会发生FileNotFoundException异常

读取文本文件方式:

方式一：

    读一个打印一个。

      int ch = 0;

      while((ch = fr.read())!=-1)

      {

         System.out.println((char)ch);

      }

方式二：(通过自定义缓冲区的方法，该方式较为高效)

    通过字符数组进行读取。

    定义一个字符数组，用于存储读到的字符，read(char[])该函数返回的是读取的字符数

    intlen = 0;

    char[]chs = new char[1024];

    while((len=fr.read(chs))!=-1)

    {

       Stringstr = new String(chs,0,len);

    }

 

BufferedReader：字符流缓冲区，能让字符输入流提高效率，缓冲区对象初始化时，必须要先有流对象。明确要提高具体的流对象的效率。

readLine():

该缓冲区提供了一个一次读一行的方法，方便于对文本数据的获取。返回的是字符串，该方法返回的时候只返回回车符之前的数据内容，并不返回回车符。该方法不包含行终止符，即获取的时候连续获取，没有分行。返回的是有效数据，没有返回换行符。当返回null时，表示读到文件末尾。

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

  

  FileReaderfr = new FileReader("bufdemo.txt");    BufferedReaderbufr  = new BufferedReader(fr);//将流对象作为参数传递到缓冲区中。    Stringline = null;//readLine()方法返回的类型是String类型    while((line=bufr.readLine())!=null)//readLine方法返回的时候是不带换行符的。{         System.out.println(line);    }    bufr.close();

Writer：写入字符流的抽象类。子类必须实现的方法仅有write(char[], int, int)、flush() 和 close()。

     |---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

     |---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

       |---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。

     |---PrintWriter：

     |---CharArrayWriter：

     |---StringWriter：

   

Writer基本方法：

    write():写入单个字符

    flush():刷新内部的缓冲中的数据,将数据刷到目的地中。

    close()：关闭流资源，但是在关闭前会刷新一次内部的缓冲中的数据,将数据刷到目的地中。

 

|--FileWriter()

    构造函数：

    1、FileWriter(File file)

    2、FileWriter(File file, boolean append)

    3、FileWriter(String fileName)

    4、FileWriter(String fileName, boolean append)

创建一个输出流对象的基本做法：

    1、创建一个FileWriter对象

       FileWriterfw = new FileWriter("demo.txt"); //明确数据要存放的目的地。

该流一被初始化就要明确被操作的文件，而且该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖。

    传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行数据续写。

FileWriter fw = new FileWriter("demo.txt",true); 

 

    2、调用write方法，将字符串写入到流中

    fw.write();

3、刷新流对象中的缓冲中的数据，将数据刷到目的地。

fw.flush();

4、关闭流资源：

fw.close();

close()和flush()的区别:flush刷新后，流可以继续使用，close刷新后，会将流关闭。

 

FileWriter写入数据的细节：

1：window中的换行符：\r\n两个符号组成。 linux：\n。

2：续写数据，只要在构造函数中传入新的参数true。

 

FileReader和FileWriter的实例以及IO异常的处理：

/*拷贝文件。*/public class day18 {public static void main(String[] args)  {FileReader fr = null;FileWriter fw = null;try{fr = new FileReader("DesignDemo.java");fw = new FileWriter("demo.txt");//创建一个缓冲区，用来缓冲读到的数据char[] ch = new char[1024];int num = 0;while((num = fr.read(ch))!=-1){fw.write(ch);//将读到的数据写入demo.txt这个文件中fw.fulsh();System.out.println(ch);}}catch(IOException e){throw new RuntimeException("读写失败");}finally//IO处理异常时，一定要用finally释放资源。{try{fw.close();}catch(IOException e){throw new RuntimeException("写入关闭失败");}if(fw!=null)try{fr.close();}catch(IOException e){throw new RuntimeException("读取关闭失败");}}}}

BufferedWriter：为字符输出流提高效率用的，缓冲区对象初始化时，必须要先有流对象。

    

FileWriterfw = new FileWriter("bufdemo.txt");    BufferedWriter bufw = newBufferedWriter(fw);//让缓冲区和指定流相关联。    for(intx=0; x<4; x++){       bufw.write(x+"abc");       bufw.newLine();//写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。       bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。    }    bufw.close();//关闭缓冲区，其实就是在关闭具体的流。

BufferedReader与BufferWriter的结合使用

import java.io.*;/**readLine()方法返回的时候值返回回车符之前的内容，并不返回回车符。 */public class IODemo {public static void main(String[] args) {BufferedReader bufr = null;BufferedWriter bufw = null;try{ bufr = new BufferedReader(new FileReader("demo.txt")); bufw = new BufferedWriter(new FileWriter("writerDemo.txt",true));String line = null;while((line=bufr.readLine())!=null){bufw.write(line);bufw.newLine();bufw.flush();}}catch(IOException e){throw new RuntimeException("读写失败");}finally{try{if(bufr!=null)bufr.close();}catch(IOException e){throw new RuntimeException("读取失败");}try{if(bufw!=null)bufw.close();}catch(IOException e){throw new RuntimeException("写入失败");}}}}

字节流：

InputStream：是表示字节输入流的所有类的超类。

     |--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。

     |---FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。

       |--- BufferedInputStream：该类实现缓冲的输入流。

       |--- Stream：

     |---ObjectInputStream：

     |---PipedInputStream：

InputStream特殊读取方法：

FileInputStream fis = new FileInputStream("demo.txt");byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区，不用再循环。fis.read(buf);System.out.println(new String(buf));fis.close();

OutputStream：此抽象类是表示输出字节流的所有类的超类。

     |--- FileOutputStream：文件输出流是用于将数据写入File 或 FileDescriptor 的输出流。

     |---FilterOutputStream：此类是过滤输出流的所有类的超类。

       |--- BufferedOutputStream：该类实现缓冲的输出流。

       |--- PrintStream：

       |--- DataOutputStream：

     |---ObjectOutputStream：

     |---PipedOutputStream：

用字节流复制一个MP3文件：

import java.io.*;/**readLine()方法返回的时候值返回回车符之前的内容，并不返回回车符。 */public class IODemo {public static void main(String[] args) throws IOException {//定义一个缓冲区缓冲一个输入流对象BufferedInputStream bufi = new BufferedInputStream(new FileInputStream("陈奕迅 - K歌之王.ape"));//定义一个缓冲区缓冲一个输出流对象BufferedOutputStream bufo = new BufferedOutputStream(new FileOutputStream("K歌之王.ape"));int line = 0;//read()方法的返回值是int类型while((line = bufi.read())!=-1){bufo.write(line);//将读取到的数据写入到指定文件中}//释放资源bufi.close();bufo.close();}}

File类：将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。

构造方法摘要：

第一种：   File(File parent, String child)

           Filedir = new File("c:\\");

           Filef3 = new File(dir,"1.txt");

          

          

第二种：   File(String pathname)

           Filef1 = new File("c:\\1.txt");

          

          

第三 种：  File(String parent, String child)

           Filef2 = new File("c:\\","1.txt");

File类字段摘要:

1、File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为“；”。

2、File.Separator：返回当前系统默认的目录分隔符，windows默认为“\”。

File类常见方法：

   

1：创建。

    boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建,并返回false。

    与输出流对象的区别:

对操作文件的输出流而言，输出流对象一建立，就会创建文件，如果文件已存在，会覆盖。除非续写。

    boolean mkdir()：创建此抽象路径名指定的目录。

    boolean mkdirs()：创建多级目录。

2：删除。

    boolean delete()：删除此抽象路径名表示的文件或目录。

    void deleteOnExit()：在虚拟机退出时删除。

注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

    window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。

3：获取.

    long length()：获取文件大小。

    String getName()：返回由此抽象路径名表示的文件或目录的名称。

    String getPath()：将此抽象路径名转换为一个路径名字符串。

    String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

    String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null。

    long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

4：判断：

    boolean exists()：判断文件或者文件夹是否存在。

    boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。

    boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。

    boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

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

5：重命名。

     boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

 

String[]list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

递归：就是函数自身调用自身。

什么时候用递归呢？

当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。

简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

 

递归的注意事项：

1：一定要定义递归的条件。

2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。

其实递归就是在栈内存中不断的加载同一个函数。

递归示例：

public class StreamDemo_1 {public static void mani(String[] args) {File file = new File("E:\\Java学习\\Code");List<File> list = fileList(file,".java");for(File files : list){System.out.println(files);}}public static List<File> fileList(File dir,String suffix){List<File> list = new ArrayList<File>();FileFilter filter = new FileFilterBySuffix(suffix);getFileList(dir,list,filter);return list;}public static void getFileList(File dir, List<File> list, FileFilter filter) {File[] files = dir.listFiles();for (File file : files) {if (file.isDirectory()) {getFileList(file, list, filter);} else {if (filter.accept(file))list.add(file);}}}}public class FileFilterBySuffix implements FileFilter {private String suffix;FileFilterBySuffix(String suffix) {this.suffix = suffix;}public boolean accept(File pathname) {return pathname.getName().endsWith(suffix);}}

Java.util.Properties：一个可以将键值进行持久化存储的对象。

Properties概述：

1、是hashtable的子类。也就是说它具备Map集合的特点，而且它里面存储的键值对都是字符串。

2、是集合和IO技术相结合的集合容器。
3、该对象的特点:可以用于键值对的配置文件。
4、在加载的时候，需要数据有固定的格式:键=值。

Properties特点：

1：可以持久化存储数据。

2：键值都是字符串。

3：一般用于配置文件。

 Properties基本方法：

|--load()：将流中的数据加载进集合。

原理：其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过 = 对该行数据进行切割，左边就是键，右边就是值，将键、值存储到properties集合中。

|--store()：写入各个项后，刷新输出流。

|--list()：将集合的键值数据列出到指定的目的地。

Properties示例：

class PropertiesDemo {public static void main(String[] args) {Properties prop = new Properties();//往Properties集合中添加键值对。prop.setProperty("二虎","20");prop.setProperty("张三","30");//由一个键获取该键对应的值。String value = prop.getProperty("二虎");System.out.println(value);//遍历该集合Set<String> names = prop.stringPropertyNames();for(String s : names){System.out.println(s+"--"+prop.getProperty(s));}}}

 

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