黑马程序员JAVA基础IO流其他类

一.Properties 类

　　Properties 类是HashTable 的子类，它具备Map 集合的特点，而且它里面存储的键值对都是字符串。同时，Properties 类是集合中和IO技术相结合的集合容器。

　　该对类的特点：可以用于键值对形式的配置文件。通常键与值用“=”连接。

　　1.设置和获取Properties 对象元素。

　　步骤：

　　1、创建Properties 对象。

　　2、调用setProperty 方法设置元素。 

　　3、通过调用 stringPropertyNames() 方法返回 Set<String> 集合进行遍历。

public class PropertiesDemo {
    public static void main(String[] args)throws IOException { 
        setAndGet();
    }   
//    设置和获取元素
    public static void setAndGet() {
        Properties prop = new Properties() ; 
        
//        设置元素：
        prop.setProperty("张三", "10000") ; 
        prop.setProperty("李四", "12") ; 
//        获取元素：
        Set<String> names = prop.stringPropertyNames(); 
        for (String name : names) {
            System.out.println(name +"="+prop.getProperty(name));
        }
    } 
}

　　>  Set<String> stringPropertyNames() : 返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。 

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

 　2.将流中的数据存储到集合中。

　　练习：将info.txt 中键值对数据存到集合中进程操作。

　　步骤：

　　1、用一个流和info.txt文件关联。

　　2、读取一行数据，将该行数据用“=”进行切割。

　　3、等号左边为键，右边为值，存储Properties 集合中即可。

public class PropertiesDemo {
    public static void main(String[] args)throws IOException { 
        Method_1();
    }  
    public static void Method_1() {
        BufferedReader br = null  ; 
        Properties prop = new Properties() ;
        try {
            br = new BufferedReader(new FileReader("D:\\info.txt"));
            String str = null ; 
            while ((str = br.readLine()) != null) {
                String[] name = str.split("=") ;
                prop.setProperty(name[0] , name[1]) ;
            } 
//            获取元素：
            Set<String> names = prop.stringPropertyNames(); 
            for (String name : names) {
                System.out.println(name +"="+prop.getProperty(name));
            }
//            System.out.println(prop);
        }
        catch (IOException e) { 24         }
        finally {
            if (br != null) 
                try {
                    br.close()  ;
                }
                catch(Exception e) {
                }
        }
    }
34　}

　　以上代码其实相当于模拟Properties 类中的 load 方法。

　　> void list(PrintStream out) 将属性列表输出到指定的输出流。 

　　> void list(PrintWriter out) 将属性列表输出到指定的输出流。

　　> void load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。 

　　> void load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）(JDK 1.6才出现的)。  

public class PropertiesDemo {
    public static void main(String[] args)throws IOException { 
        LoadDemo();
    } 
    
    public static void LoadDemo() throws IOException {
        Properties prop = new Properties() ;
        FileReader fis = new FileReader("D:\\info.txt") ;
//        将流中的数据加载进集合。那么在加载数据是，需要数据有固定格式： 键=值。
        prop.load(fis) ; 
        prop.list(System.out) ;
        
        prop.setProperty("萧鼎", "诛仙") ; 
//        将修改的集合存储到文件中、
        FileWriter fw = new FileWriter("D:\\info.txt") ;
        prop.store(fw, "info") ;
        prop.list(System.out) ; 
        
        fw.close() ; 
        fis.close() ;
        
    }
}

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

　　>void store(Writer writer, String comments) 以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符(JDK 1.6才出现的)。

　　通过load 方法和store 方法可以很方便的操作配置文件数据的存储。

　3.练习：用于记录应用程序运行的次数。如果使用次数已到，那么给出注册提示。

　　步骤：

　　1、创建File 对象用于封装文件路径。

　　2、设置读取流 。

　　3、读取配置文件，如果time 的值等于大于规定次数，则给出提示并结束程序。

　　4、如果没到规定次数，则设置配置文件。

public class PropertiesTest {
    public static void main(String... args) throws IOException {
//        该程序运行一次，运行次数增加一次，当次数达到限定的使用次数，
//        那么给出注册提示。
        
//        封装文件
        File file = new File("D:\\count.ini") ; 
        if (! file.exists())
            file.createNewFile() ; 
        
//        设置读取流
        FileInputStream fis = new FileInputStream(file) ;
        Properties prop = new Properties() ; 
        
//        读取配置文件。
        prop.load(fis) ; 
        String values = prop.getProperty("time") ; 
        int count = 0 ; 
        if (values != null) {
            count = new Integer(values).intValue() ; 
            if (count >= 5) { 
                System.out.println("免费使用次数已经到了！");
                return ;
            }
        }
        count ++ ;  
//        设置配件信息
        prop.setProperty("time", count+"") ;
        FileOutputStream fos = new FileOutputStream(file) ;
        prop.store(fos, "" ) ; 
        fos.close() ; 
        fis.close() ;
    }
}

　　

二.PrintStream 与PrintWriter 类：

　　该流提供了打印方法，可以将各种数据类型的数据都原样打印，如：print、printf、println等等。

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

　　字节打印流：PrintStream

　　1、File 对象 : 

　　　　　　> PrintStream(File file)  创建具有指定文件且不带自动行刷新的新打印流.

　　　　　　> PrintStream(File file, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。

 　　2、字符串路径：String

 　　3、字节输出流：

　　　　　　>PrintStream(OutputStream out) 创建新的打印流。 

　　　　　　>PrintStream(OutputStream out, boolean autoFlush) 创建新的打印流。如果为 true，则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 ('\n') 时都会刷新输出缓冲区。

　　字符打印流：PrintWriter  

　　1、File 对象 : 

　　　　　　> PrintWriter(File file)  创建具有指定文件且不带自动行刷新的新打印流.

　　　　　　> PrintWriter(File file, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。

 　　2、字符串路径：String

 　　3、字节输出流：

　　　　　　>PrintWriter(OutputStream out) 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。

　　　　　　>PrintWriter(OutputStream out, boolean autoFlush) 创建新的打印流。autoFlush - boolean 变量；如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区。

　　 4、字符输出流：

　　　　　　>PrintWriter(Writer out) 创建不带自动行刷新的新 PrintWriter。 

　　　　　　>PrintWriter(Writer out, boolean autoFlush) 创建新 PrintWriter。 autoFlush - boolean 变量；如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区。

import java.io.*;
public class PrintStreamDemo {
    public static void main(String... args) throws IOException {
//        键盘读入流
        BufferedReader br = 
            new BufferedReader (new InputStreamReader(System.in)) ;
//        打印流：
        PrintWriter out = new PrintWriter(System.out , true) ;
        
        String line = null ; 
        while((line = br.readLine()) != null) {
            if ("over".equals(line))
                break ; 
            out.println(line.toUpperCase()) ;  
        }
    }
}

 　　

三.切割文件和合并流：

　1、切割文件

　　顾名思义，切割文件则是将一个文件切割成多个碎片。没有专门用于切割文件的类，其步骤：

　　1、关联被切割的文件。

　　2、创建一个容器，容器大的小定为没块碎片的大小。

　　3、每次读取容器大小文件，并创建输出流，将其存储到硬盘上。

import java.io.*; 
import java.util.*; 
public class SpiltFile {
    public static void main(String[] args ) throws IOException {
//        关联被切割的文件。
        FileInputStream fis = new FileInputStream("F:\\KuGou\\Celine Dion - I Surrender.mp3") ;
        
        FileOutputStream fos = null  ;
        
//        创建每块文件碎片的大小。
        byte[] bt = new byte[1024 * 1024] ; 
        int count = 1 ;
        int len = 0 ;
        while((len = fis.read(bt)) != -1 ) {
//            每次创建一个 bt 数组大小的文件碎片。
            fos = new FileOutputStream("D:\\Celine Dion - I Surrender"+(count++)+".part") ; 
            fos.write(bt,0,len) ;
            fos.close() ; 
        }
        fis.close() ; 
    } 
}

　

　2、合并流：

　　合并流则是将多个源文件组装成一个源文件，然后再通过输出流将其保存到目标文件。实现该操作则要用到SequenceInputStream 类。

　　SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。  

　　构造函数：

　　>SequenceInputStream(Enumeration<? extends InputStream> e) 通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。 

　　>SequenceInputStream(InputStream s1, InputStream s2) 通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。

　　操作步骤：

　　1、创建Vector 集合。将要合并的文件添加至Vector 集合

　　2、通过Vector 集合，创建Enumeration 对象。

　　3、创建 SequenceInputStream 对象进行合并流。

　　4、输出文件。

　　将切割文件时切割出的文件碎片进行合并：

import java.io.*; 
import java.util.*; 
public class SpiltFile {
    public static void main(String[] args ) throws IOException {
        merger() ;
    } 
    public static void merger() throws IOException {
//        创建Vector 集合。
        Vector<FileInputStream> v = new Vector<FileInputStream>() ; 
        File file = new File("D:\\") ; 
//        筛选出后缀名是.part的文件进行合并。
        File[] files = file.listFiles(new FileFilter() { 
            public boolean accept(File pathname) { 
                if (pathname.getName().endsWith(".part")) 
                    return true;
                return false ; 
            }
        }) ;
//        Vector 集合添加元素。
        for (File name : files) {
            v.add(new FileInputStream(name)) ; 
        }
//        创建Enumeration 对象
        Enumeration<FileInputStream> en = v.elements() ; 
//        创建SequenceInputStream 对象
        SequenceInputStream sis = new SequenceInputStream(en) ; 
//        输出文件。
        FileOutputStream fos = new FileOutputStream("D:\\I.mp3") ;
        byte[] by = new byte[1024] ; 
        int len = 0 ; 
        while((len = sis.read(by)) != -1) {
            fos.write(by,0,len) ;
        }
        sis.close() ;
        fos.close() ; 
    }
}

 四.对象的序列化:

　　ObjectInputStream 和 ObjectOutputStream 被操作的对象需要实现Serializable （标记接口：没有方法的接口）。把对象存储到硬盘上，实现对象的持久化（序列化） 。

　　注意：

　　关于 Serializable 接口，类通过实现 java.io.Serializable 接口以启用其序列化功能。序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程

中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致

InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：如果可序列化

类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值。

 static final long serialVersionUID = 42L

　　注意：静态属性无法被序列化。

import java.io.*; 
public class ObjectInputStreamDemo {
    public static void main(String[] args )throws  Exception {
//        writerObj();
        readObj();
    }
    public static void readObj() throws  Exception  {
//        创建 ObjectInputStream 对象。
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\person.object")) ; 
        
        Person p = (Person ) ois.readObject() ; 
        System.out.println(p) ; 
        ois.close() ;
    }
    public static void writerObj() throws IOException {
        ObjectOutputStream oos = 
            new ObjectOutputStream(new FileOutputStream("D:\\person.object")) ;
        
        Person p = new Person("李四" , 22 , "beijing") ;
        oos.writeObject(p ) ; 
        System.out.println(p);
        oos.close() ;
        
    }
}
class Person implements Serializable {
    private String name ; 
    private int age ; 
    static String city = "hunan" ; 
    public Person(String name , int age , String city) {
        this.name  = name ;
        this.age = age ;
        this.city = city ; 
    }
    public String toString() {
        return name + ":" + age + ":"+city;
    }
}

　　先运行writerObj() 方法时，第21行打印出来的是”李四:22:beijing“ ， 然后再运行readObj() 方法时，第12行打印出来的是”李四:22:hunan" 。所以静态属性是不能被序列化的，但是如果想让不是静态的属性也不被序列化，则可以用 transient 关键字进行修饰。

 　  注意：如果是 ObjectOutputStream 做的文件，只能用ObjectInputStream 来进行读取。

五.管道流：PipedInputStream 与PipedOutputStream 类输入和输出可以直接进行连接，通过结合线程使用。

　　管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的

PipedOutputStream。不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。

　　PipedInputStream 与 PipedOutputStream 类 输入和输出可以直接进行连接，通过结合线程使用。

　　如何将PipedInputStream 与 PipedOutputStream类进行连接呢？ 

　　1、通过构造函数：

　　　　> PipedInputStream(PipedOutputStream src) 创建 PipedInputStream，使其连接到管道输出流 src。

　　　　> PipedOutputStream(PipedInputStream snk) 创建连接到指定管道输入流的管道输出流。

　　2、通过connect 方法：

　　　　> void connect(PipedOutputStream/PipedOutputStream src) 使此管道输入/输出流连接到管道输入/输出流 src。 

import java.io.*; 
class ReadThread implements Runnable {
    private PipedInputStream pis ; 
    public ReadThread(PipedInputStream pis){
        this.pis = pis ; 
    }
    public void run() {
        try {
            byte[] by = new byte[1024] ;  
//            如果没有数据，则会线程阻塞在这，当有数据时，继续运行。
            int len = pis.read(by) ;  
            String s = new String(by,0,len) ;
            System.out.println(s);
            pis.close() ;
        }
        catch(Exception e) {
        }
    }
}
class WriterThread implements Runnable {
    private PipedOutputStream pos ;
    public WriterThread(PipedOutputStream pos) {
        this.pos = pos ; 
    }
    public void run() {
        try {
//            Thread.sleep(9000) ;
//            开始写入数据，
            String str = "hi！" ; 
            pos.write(str.getBytes()) ; 
            pos.close() ; 
        }
        catch(Exception e) { 
        }
    }
}
public class PipedDemo {
    public static void main(String[] args) throws IOException {
        PipedInputStream pis = new PipedInputStream() ; 
        PipedOutputStream pos = new PipedOutputStream() ; 
//        连接输入输出流
        pis.connect(pos) ; 
        
//        创建线程
        ReadThread rt = new ReadThread(pis) ; 
        WriterThread wt = new WriterThread(pos) ;
        
        new Thread(rt).start() ; 
        new Thread(wt).start() ;  
    }
}

　　　　

六.RandomAccessFile 类：

 　　此类的实例支持对随机访问文件的读取和写入。随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。存在指向该隐含数组的光标或索引，称为文件指针；输入操作从文件指针开始读

取字节，并随着对字节的读取而前移此文件指针。该文件指针可以通过 getFilePointer 方法读取，并通过 seek 方法设置。

 　　简单来说就是：内部封装了一个数组，而且通过指针对数组的元素进行操作。

 　　其构造方法：

　　　　> RandomAccessFile(File file, String mode) : 创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。 

　　　　> RandomAccessFile(String name, String mode)   创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。 

 　　其中 mode 参数指定用以打开文件的访问模式，允许的值及其含义为：

"r"	以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
"rw"	打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。
"rws"	打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。
"rwd"	打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备。

　　所以：通过构造函数知道，该类的局限性

　　1、只能操作文件。

　　2、操作文件还有模式规定。

import java.io.*; 
public class RandomAccessFileDemo {
    public static void main(String[] args)throws IOException {
        readFile() ;
    }
//    读取文件
    public static void readFile() throws IOException {
        RandomAccessFile raf = new RandomAccessFile("D:\\Random.txt", "r") ; 
//        调整对象中指针
        raf.seek(8*1) ; 
        byte[] buf = new byte[4] ; 
        raf.read(buf) ;
        String name = new String(buf) ; 
        System.out.println(name); 
//        RandomAccessFile 类中提供读取基本类型的方法
        int age = raf.readInt() ; 
        System.out.println(age);
    }  
//    写入文件
    public static void writeFile() throws IOException {
        RandomAccessFile raf = new RandomAccessFile("D:\\Random.txt" , "rw"); 
        raf.write("李四".getBytes()) ;
//        RandomAccessFile 类中提供写基本类型的方法
        raf.writeInt(65) ; 
        raf.write("张三".getBytes()) ;
//        RandomAccessFile 类中提供写基本类型的方法
        raf.writeInt(69) ;
    }
}

　　seek 方法不仅可以在读取文件时调整文件指针，再写入文件时，也可以调整文件指针，进行覆盖前面的数据，或者跳一个位置写入数据。

　　口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 

　　个

     指针（0）

　　当运行 raf.seek(8) 时。

　　口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 口 

　　  　　　　　　　　　　 个

　　　　　　　　　　　　 指针（8）

七.DataInputStream 和DataOutputStram 类

　　可以用操作基本数据类型的数据，只要是操作基本数据类型的数据则用该流。

　　注意：虽然ObjectInputStream 流 也有操作基本数据类型数据的方法，但它主要是用来操作对象的。

import java.io.*; 
public class DataStreamDemo {
    public static void main(String[] args) throws IOException{
        readData() ; 
    }
    public static void writeData() throws IOException {
        DataOutputStream dos = 
            new DataOutputStream (new FileOutputStream("D:\\data.txt")) ;
        
        dos.writeInt(2388) ;  
        
        dos.writeBoolean(false) ;
        
        dos.writeDouble(8989.423) ;
        
        dos.close() ;
    }
    public static void readData() throws IOException {
        DataInputStream dis = 
            new DataInputStream (new FileInputStream("D:\\data.txt")) ;
//        读取的顺序要和写入的顺序一致，否则会出现错误。
        int num = dis.readInt() ; 
        System.out.println(num);
        
        boolean b = dis.readBoolean() ;
        System.out.println(b) ; 
        
        double doub = dis.readDouble() ;
        System.out.println(doub);
        
        dis.close();
    }
}

 　　> void writeUTF(String str) : 以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。 

　　 注意：使用DataOutputStram 类中的writeUTF 方法写入时，必须只能用DataInputStream 类中的 readUTF 方法读取出来。

 　　

八.ByteArrayInputStream 与ByteArrayOutputStream 类：

　　这两个流是用来操作字节数组的流。

　　ByteArrayInputStream : 在构造的时候，需要接收数据源，而且数据源是一个字节组。包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。

　　> ByteArrayInputStream(byte[] buf) 创建一个 ByteArrayInputStream，使用 buf 作为其缓冲区数组。 

　　> ByteArrayInputStream(byte[] buf, int offset, int length) 创建 ByteArrayInputStream，使用 buf 作为其缓冲区数组。

　　ByteArrayOutputStream ： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。此类实现了一个输出流，其中的数据被写入一个 byte 数

组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。

　　注意：因为该流没有调用底层资源，关闭 ByteArrayInputStream 和ByteArrayOutputStream无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。 

import java.io.*;
public class ByteArrayStreamDemo {
    public static void main(String[] args) {
        ByteArrayInputStream bais = new ByteArrayInputStream("afewfa".getBytes()) ; 
        
        ByteArrayOutputStream baos = new ByteArrayOutputStream() ; 
        
        int len = 0 ;
        while ((len = bais.read()) != -1) {
            baos.write(len) ; 
        } 
        System.out.println(baos.toString()); 
    }
}

　　除了ByteArrayInputStream/ByteArrayOutputStream 操作字节数组流外，还有操作字符数组的流 CharArrayReader/CharArrayWrite和操作字符串流 StringReader/StringWrite。