JAVA--IO流（二）

一.字节流
 

    字节流的抽象基类:

    |---->InputStream：字节输入流

    |---->OutputStream：字节输出流

    它的操作与字符流类似，可以参与字符流的定义、读取、写入、处理异常的格式，只不过是处理的数据不同，因为对于非字符的数据，比如图片、视频、音频文件(例如mp3)等，这些文件只能用字节流对之进行操作。
 

    FileInputStream

    FileInputStream是InputStream的一个子类，用于读取诸如图像数据之类的原始字节流

    构造方法：

    |--->FileInputStream(File file) 

            通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。 

    |--->FileInputStream(FileDescriptor fdObj) 

            通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。 

    |--->FileInputStream(String name) 

            通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。 

    常用方法：

    |--->int available()返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。 

    |--->void close()关闭此文件输入流并释放与此流有关的所有系统资源。 

    |--->int read()从此输入流中读取一个数据字节。 

    |--->int read(byte[] b)从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 

    |--->int read(byte[] b, int off, int len)从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。 
 

字节读取流代码示例：

public class InputStreamDemo {  

      public static void main(String[] args)  {  

        read1();  

    }  

    //第一种读取方式：按字节来读取  

    public static void read1() {  

        FileInputStream fis = null;  

        try {  

            fis = new FileInputStream("D:\\Demo\\demo.java");//新建字节读取的对象，明确源文件  

            int x = 0;  

            while((x = fis.read())!=-1) {  

                System.out.print((char)x);  

            }  

        }catch (IOException e) {  

            e.printStackTrace();  

        }  

        finally { //执行关闭资源的操作  

          if(fis!=null) {  

                try{  

                    fis.close();  

                }catch(IOException e2){  

                    e2.printStackTrace();  

                }  

            }  

        }  

    }  

    //第二种读取方式：按字节数组读取  

    public static void read2() {  

        FileInputStream fis = null;  

        try {  

            fis = new FileInputStream("D:\\Demo\\demo.java");//新建字节读取的对象，明确源文件  

            int len = 0;  

            byte[] buff = new byte[1024];//定义一个字节数组，用于存储字节  

            while((len=fis.read(buff))!=-1) {   //每次将读取到的字节存储进buff数组  

                System.out.println(new String(buff,0,len));//将字节数组转换成字符串输出  

            }  

        } catch (IOException e) {  

            e.printStackTrace();  

        }  

        finally {   //执行关闭资源的操作  

            if(fis!=null)  {  

                try {  

                    fis.close();  

                } catch (IOException e2) {  

                    e2.printStackTrace();  

                }  

            }  

        }  

    }  

}  

    注意available()这个方法的用法，取文件字节数，然后定义一个刚好大小的字节数组。代码如下：

    fis =new FileInputStream(file);  

    byte [] ch =newbyte[fis.available()];  

    fis.read(ch);  

    System.out.println(new String(ch));  

    但是如果文件过大，会造成内存溢出。
 

    FileOutputStream

    FileOutputStream是OutputStream的一个子类，用于写入诸如图像数据之类的原始字节的流。
 

    构造方法：

    |--->FileOutputStream(File file) 

            创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 

    |--->FileOutputStream(File file,boolean append) 

            创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 

    |--->FileOutputStream(FileDescriptor fdObj) 

            创建一个向指定文件描述符处写入数据的输出文件流，该文件描述符表示一个到文件系统中的某个实际文件的现有连接。 

    |--->FileOutputStream(String name) 

            创建一个向具有指定名称的文件中写入数据的输出文件流。 

    |--->FileOutputStream(String name, boolean append) 

            创建一个向具有指定 name 的文件中写入数据的输出文件流。 
 

    常用方法：

    |--->close():关闭此文件输出流并释放与此流有关的所有系统资源。  

    |--->write(byte[] b):将 b.length 个字节从指定byte数组写入此文件输出流中。 

    |--->write(byte[] b, int off, int len):将指定byte数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 

    |--->write(int b):将指定字节写入此文件输出流。 
 

字节写入流代码示例：

public class OutputStreamDemo {  

     public static void main(String[] args) {  

        FileOutputStream fos = null;  

        try {  

            fos =  new FileOutputStream("D:\\Demo\\fos.txt");  

            //定义一个字符串，因为字节流只能以字节或字节数组的形式读取  

            String str = "努力努力";  

            byte [] by =str.getBytes();//转成字节数组形式  

            fos.write(by);//不用刷新  

        }   

        catch (Exception e)  {  

            // TODO Auto-generated catch block  

            e.printStackTrace();  

        }  

        finally {  

            if(fos!=null) {  

                try {  

                    fos.close();  

                }   

                catch (IOException e)  {  

                    // TODO Auto-generated catch block  

                    e.printStackTrace();  

                }  

            }  

        }  

    }  

}  

二.字节流缓冲区
 

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

    对应类：

        BufferedOutputStream (extends OutputStream)

        BufferedInputStream (extends InputStream)
 

利用缓冲区的技术，拷贝Mp3文件

public class copyMp3 {  

     public static void main(String[] args) {  

        BufferedInputStream buis=null;  

        BufferedOutputStream buos=null;  

        try {  
 

            buis=new BufferedInputStream(new FileInputStream("D:\\play.mp3"));  

            buos=new BufferedOutputStream(new FileOutputStream("D:\\play_copy2.mp3"));  

              

            //第一种复制方式  

            int num=0;  

            while((num=buis.read())!=-1) {  

                buos.write(num);  

            }  

              

            //第二种复制方式  

            byte[] buff = new byte[1024];  

            int len = 0;  

            while((len=buis.read(buff))!=-1) {  

                buos.write(buff,0,len);  

            }     

        }  

        catch(IOException e)  {  

            throw new RuntimeException("复制失败");  

        }  

        finally {  

            if(buis!=null) {  

                try {  

                    buis.close();  

                }catch (Exception e2) {  

                    throw new RuntimeException("关闭读取流失败");  

                }  

            }  

            if(buos!=null) {  

                try {  

                    buos.close();  

                } catch (Exception e2) {  

                    throw new RuntimeException("关闭写入流失败");  

                }  

            }  

        }       

    }  

}  

三.转换流

    转换流包括:

        InputStreamReader:字节流通向字符流的桥梁

        OutputStreamWriter:字符流通向字节流的桥梁

    转换流的由来:是字节流和字符流的桥梁;方便了字节流和字符流之间的操作

    转换流的应用:字节流中的数据都是字符时，转成字符流操作更高效
 

    InputStreamReader

    是字节流通向字符流的桥梁。

    每次调用 InputStreamReader 中的一个 read()方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader。
 

    构造方法：

    InputStreamReader(InputStream in)

    InputStreamReader(InputStream in, String charsetName)

    示例：BufferedReader in = new BufferedReader(new InputStreamReader(System.in));(必须记住)

    OutputStreamWriter 

    是字符流通向字节流的桥梁，将要写入流中的字符编码成字节。

    每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器。

    构造方法：

    OutputStreamWriter(OutputStream out)

    OutputStreamWriter(OutputStream out, String charsetName)
 

    示例：

    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

    System.in 默认设备为键盘

        System.setIn(InputStream in)\\ 重新分配“标准”输入流。

    System.out 默认设备为控制台

        System. setOut(PrintStream out) \\重新分配“标准”输出流。

四.标准输入与输出

    System类中的字段：in，out，它们各代表了系统标准的输入和输出设备，默认输入设备是键盘，输出设备是显示器。

    System.in的类型是InputStream.

    System.out的类型是PrintStream

        java.lang.Object

        |--java.io.OutputStream

           |--java.io.FilterOutputStream

              |---java.io.PrintStream

    示例：

    例:获取键盘录入数据，然后将数据流向显示器，那么显示器就是目的地。

    通过System类的setIn，setOut方法对默认设备进行改变：

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

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

    因为是字节流处理的是文本数据，可以转换成字符流，操作更方便。

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

    BufferedWriter bufw =new BufferedWriter(new OutputStreamWriter(System.out)); 

五 File类
     File类是文件和目录路径名的抽象表示形式。 是io包中唯一代表磁盘文件本身的对象，其定义了一些与平台无关的方法来操作文件，可以通过调用File类中的方法，实现创建.删除.重命名文件等操作，File类是对象主要用来获取未文件本身的一些信息，如文件所在的目录、文件的长度、文件的读写权限等。File对象可以作为参数传递给流的构造函数。
 

    构造方法：

    |--->File(File parent, String child) 

            根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 

    |--->File(String pathname) 

            通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 

    |--->File(String parent, String child) 

            根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。 

    |--->File(URI uri) 

            通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。 
 

    常见方法：

    1.创建

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

        boolean mkdir():创建文件夹。

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

        注：File类创建文件的方法createNewFile()与输出流的方法不同点：

            File类通过createNewFile方法来创建文件的话，如果文件存在则不创建

            输出流是对象一建立就创建文件，如果文件存在就会覆盖原文件。

    2.删除

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

        void deleteOnExit()：在程序退出时删除指定文件。

    3.判断

        boolean  exists()：文件或目录是否存在。

        boolean isFile()：是否是一个标准文件。

        boolean isDirectory()：是否是一个目录。

        boolean isHidden()：是否是一个隐藏文件。

        boolean isAbsolute()：是否为绝对路径名。

        boolean canRead()是否可读

        boolean canWrite()是否可写

    4.获取

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

        String getPath():获取相对路径

        String getParent():获取父级目录，如果此路径名没有指定父目录，则返回 null。

        String getAbsolutePath():获取绝对路径

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

        long length():返回由此抽象路径名表示的文件的长度.

        static File[] listRoots()：列出系统的可用的根

        String[] list()：获取指定目录下的所有文件和文件夹的名称数组

        File[] listFiles()：获取指定目录下的所有文件和文件夹的File数组

    5.修改

        boolean renameTo(File dest)：重新命名此抽象路径名表示的文件。

class FileDemo  {  

    public static void main(String[] args) throws IOException  {  

        method_5();  

    }  

     //renameTo()方法，相当于剪切  

    public static void method_5() {  

        File f1 = new File("c:\\Test.java");  

        File f2 = new File("d:\\hahah.java");  

  

        sop("rename:"+f2.renameTo(f1));  //false

  

    }  

     //获取各种路径  

    public static void method_4() {  

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

  

        sop("path:"+f.getPath());  

        sop("abspath:"+f.getAbsolutePath());  

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

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

    }  

    //创建文件，判断文件，以及查询文件  

    public static void method_3()throws IOException {  

        File f = new File("d:\\java1223\\day20\\file2.txt");  

  

        f.createNewFile();  

  

        f.mkdir();//创建此抽象路径名指定的目录  

  

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

        //通过exists判断。  

        sop("dir:"+f.isDirectory());  

        sop("file:"+f.isFile());  

  

        sop(f.isAbsolute());  

    }  

     public static void method_2() {  

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

  

        sop("exists:"+f.exists());//判断是否存在  

  

        //测试应用程序是否可以执行此抽象路径名表示的文件。  

        sop("execute:"+f.canExecute());  

  

        //创建多级文件夹  

        File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");  

  

        sop("mkdir:"+dir.mkdirs());  

    }  

    //删除相关文件  

    public static void method_1()throws IOException {  

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

        sop("create:"+f.createNewFile());  

        sop("delete:"+f.delete());  

    }  

    //创建File对象  

    public static void consMethod() {  

        //将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象。  

        File f1 = new File("c:\\abc\\a.txt");  

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

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

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

  

        sop("f1:"+f1);//打印结果c:\\abc\\a.txt  

        sop("f2:"+f2);//打印结果c:\\abc\\b.txt  

        sop("f3:"+f3);//打印结果c:\\abc\\c.txt  

  

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

  

    }  

    public static void sop(Object obj) {  

        System.out.println(obj);  

    }  

} 

六、Properties类

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

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

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

    构造方法：

    |--->Properties():创建一个无默认值的空属性列表。 

    |--->Properties(Properties defaults):创建一个带有指定默认值的空属性列表。
 

    常用方法：

    |--->Object setProperty(String key,String value)

            调用Hashtable的put方法，设置键值对

    |--->String getProperty(String key)

            用指定的键在此属性列表中搜索属性

    |--->Set<String> stringPropertyNames

            获取集合中所有的键

    |--->void load(InputStream in)

            从输入流中读取属性列表（键和元素对）。

    |--->void load(Reader reader)

            按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

    |--->void list(PrintStream out)  

            将属性列表输出到指定的输出流。

    |--->void list(PrintWriter out)   

            将属性列表输出到指定的输出流。

    |--->void Store(OutputStream out,String comments)

            以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。 

    |--->void store(Writer writer, String comments) 

            以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。 
 

class PropertiesDemo {  

    public static void main(String[] args) throws IOException {  

        loadDemo();  

    }  

    public static void loadDemo()throws IOException{  

        Properties prop = new Properties();  

        FileInputStream fis = new FileInputStream("info.txt");  

  

        //将流中的数据加载进集合。  

        prop.load(fis);  

        prop.setProperty("wangwu","39");//并没有写入到硬盘中，只写入到流中  

  

        FileOutputStream fos = new FileOutputStream("info.txt");  

        prop.store(fos,"haha");//将流中的数据写入到硬盘中  

        prop.list(System.out);//列出目录  

  

        fos.close();  

        fis.close();  

    }  

    //设置和获取元素。  

    public static void setAndGet() {  

        Properties prop = new Properties();  

        prop.setProperty("zhangsan","30");//设置元素  

        prop.setProperty("lisi","39");  

  

        String value = prop.getProperty("lisi");  

        System.out.println(value);//打印出39  

              

        prop.setProperty("lisi",89+"");  

  

        Set<String> names = prop.stringPropertyNames();  

        for(String s : names){  

            System.out.println(s+":"+prop.getProperty(s));  

        }  

    }  

}   

七.打印流

    可以直接操作输入流和文件，该流提供了打印方法，可以将各种数据类型的数据都原样打印。
 

    字节打印流：PrintStream

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

        1.file对象：File

        2.字符串路径：String

        3.字节输出流：OutputStream

    字符打印流：PrintWriter

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

        1.file对象：File

        2.字符串路径：String

        3.字节输出流：OutputStream

        4.字符输出流：Writer

    注：与其他输出流不同，PrintStream 永远不会抛出IOException，而且打印流可以根据指定编码转成字符！

class  PrintStreamDemo {  

    public static void main(String[] args) throws IOException {  

        BufferedReader bufr =   

            new BufferedReader(new InputStreamReader(System.in));//读取键盘输入  

  

        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);//ture代表自动刷新  

  

        String line = null;  

  

        while((line=bufr.readLine())!=null) {  

            if("over".equals(line))  

                break;  

            out.println(line.toUpperCase());//转换成大写  

            //out.flush();//刷新  

        }  

        out.close();  

        bufr.close();  

    }     

}  

八..序列流

    SequenceInputStream是能对多个流进行合并成一个读取流，它在构造时需要传入Enumeration，而这个只用Vector中有，所以这个多个读取流要加入Vector集合中。
 

    注意：它只是对读取流进行合并。所以此对象没有对应的OutputStream

    使用步骤：

    1.创建Vector<InputStream>

    2.将要合并的InputStream加入Vector

    3.通过Vector获取Enumeration

    4.创建SequenceInputStream对象，将Enumeration作为参数传入。

class SequenceDemo  {  

    public static void main(String[] args) throws IOException  {  

        //创建Vector集合  

        Vector<FileInputStream> v = new Vector<FileInputStream>();  

        //将要合并的InputStream加入Vector  

        v.add(new FileInputStream("c:\\1.txt"));  

        v.add(new FileInputStream("c:\\2.txt"));  

        v.add(new FileInputStream("c:\\3.txt"));  

  

        //通过Vector获取Enumeration  

        Enumeration<FileInputStream> en = v.elements();  

        创建SequenceInputStream对象  

        SequenceInputStream sis = new SequenceInputStream(en);  

  

        //定义输出流  

        FileOutputStream fos = new FileOutputStream("c:\\4.txt");  

        byte[] buf = new byte[1024];  

        int len =0;  

        while((len=sis.read(buf))!=-1) {  

            fos.write(buf,0,len);  

        }  

         fos.close();  

        sis.close();  

     }  

}