各类流

字节流：操做文件中的数据，通常用byte数组

outputstream：字节输出流的超类 抽象类

fileoutputstream

构造方法：能够传字符串路径   能够传file对象

没有文件的话 直接建立

FileOutputStream fos = new FileOutputStream("d:\\12\\output.txt");

方法：

write（）：能够直接传int数值，能够传byte数组，能够控制数组的写入位置和写入个数

//write(int i) 一次只能操做一个字节   转成了二进制字节
        fos.write(97);
        //往文件里写入100
        fos.write(49);
        fos.write(48);
        fos.write(48);
        fos.close();
        //write(byte[] byte)
        byte[] b= {-65,-66,-67,-68};
        fos.write(b);
        fos.close();

文件的续写和换行：构造方法中加上true表示续写，\r\n表示换行

outputstream：字节输入流的超类 抽象类

fileoutputstream

构造方法：能够传字符串路径，能够传file对象

FileInputStream fis = new FileInputStream("d:\\12\\output.txt");

方法：

read（）：有返回值 空参返回读取值的数，没有读取到数就返回-1   传入byte数组，返回读取的有效个数，没有有效读取的数就返回-1，能够控制传入数组的个数

FileInputStream fis = new FileInputStream("d:\\12\\output.txt");
        int len = 0;
        while((len = fis.read())!=-1){
            System.out.println((char)len);
        }
        fis.close();

FileInputStream fis = new FileInputStream("d:\\12\\output.txt");
        byte[] bytes = new byte[10];
        fis.read(bytes,2,5);
        fis.close();
        for(byte b:bytes){
            System.out.println(b);
        }

FileInputStream fis = new FileInputStream("d:\\12\\output.txt");
        int len = 0;
        byte[] bytes = new byte[2];
        while((len = fis.read(bytes))!=-1){
            
                System.out.println(new String(bytes,0,len));
        }
        fis.close();

文件的复制：通常用write和read方法中的byte数组的方法   注意关闭资源

FileInputStream fis = new FileInputStream("d:\\0328");
        FileOutputStream fos = new FileOutputStream("d:\\12\\0328");
        byte[] bytes = new byte[1024*1024];
        int len = 0;
        while((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();

 字符流：操做字符的流，通常用char数组

字节流是一个个字节去读取，中文一个字是一个字符，表明两个字节，用字节流读取很不方便

writer：全部字符输出流的超类

filewriter：

构造方法：能够传入字符串表示的路径，能够传入file对象，同时能够传入true表示是否续写

FileWriter fw = new FileWriter("d:\\12\\writer.txt",true);

write（）方法：能够传入int数值类型，一个个的写；能够传入char数组，写入数组中的内容，并控制写入多少；能够传字符串，并控制写入多少

字符流的写入必须有flush（）方法，刷新

FileWriter fw = new FileWriter("d:\\12\\writer.txt",true);
        fw.write(100);
        fw.flush();
        fw.close();
        char[] ch = {'你','好','吗'};
        fw.write(ch, 0, 2);
        fw.write("崔永元实话实说",0,3);
        fw.flush();
        fw.close();

reader：全部字符输入流的超类

filereader：

构造方法：能够传字符串表示路径，能够传file对象

FileReader fr = new FileReader("d:\\12\\writer.txt");

read（）方法：有返回值，空参返回读取的字符的数（这个是系统默认的gbk编码表，返回一个多位的数）；char数组，返回的是有效读取个数

字符流的复制：通常用read（）和write（）方法的char数组方法，注意刷新，关闭资源

FileReader fr = new FileReader("d:\\12\\writer.txt");
        FileWriter fw = new FileWriter("d:\\12\\writer1.txt");
        int len =0;
        char[] ch = new char[2];
        System.out.println(fr.read());
        while((len=fr.read(ch))!=-1){
        fw.write(ch, 0, len);
        fw.flush();
        }
        fr.close();
        fw.close();

转换流：在gbk（系统默认编码）和utf-8编码的转换，本质仍是一个字符流

outputstreamwriter：字符流向字节流转换的桥梁

在OutputStreamWriter流中有本身的缓冲区，用OutputStreamWriter对象使用write方法时，

拿着字符到指定的码表中进行查询，把查到的字符编码值转成字节数据存放到OutputStreamWriter缓冲区中，

而后再调用刷新功能，或者关闭流，或者缓冲区存满后会把缓冲区中的字节数据使用字节流写到指定的文件中

构造方法：有outputstreamwriter就必定要先构造一个fileoutputstream对象，把此对象传入到构造方法中，并指定写入的编码

方法：write（）和字符输出流同样

 

FileOutputStream fos = new FileOutputStream("d:\\12\\writer.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
        osw.write("小猪佩奇");
        osw.flush();
        osw.close();

 

inputstreamreader：字节流向字符流转换的桥梁

使用指定的编码表读取字节并将其解码为字符

构造方法：有inputstreamreader就必定要先构造一个fileinputstream对象，把此对象传入到构造方法中，并指定解码的编码

方法：read（）和字符输入流同样

 

FileInputStream fis = new FileInputStream("d:\\12\\writer.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        int len = 0;
        while((len=isr.read())!=-1){
            System.out.print((char)len);
        }
        isr.close();

转换流的复制：

// TODO Auto-generated method stub
        FileInputStream fis = new FileInputStream("d:\\12\\writer.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        FileOutputStream fos = new FileOutputStream("d:\\12\\writer1.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
        int len = 0;
        while((len=isr.read())!=-1){
            osw.write(len);
            osw.flush();
        }
        isr.close();
        osw.close();

缓冲流：加速流，能够把字节流和字符流加速，由于有个缓冲区，先把数据存到缓冲区，而后再一次性读取或者写入，通常使用默认的缓冲区大小（8KB）就能够

字节缓冲流：bufferedoutputstream   字节缓冲输出流；bufferedinputstream   字节缓冲输入流

构造方法：由于是加速字节流的，因此必须传入一个字节输出流或者字节输入流对象

方法：和字节流的方法同样

// TODO Auto-generated method stub
        FileInputStream fis = new FileInputStream("d:\\12\\output.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream("d:\\12\\put.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        byte[] bytes = new byte[1024];
        int len = 0;
        while((len=bis.read(bytes))!=-1){
            bos.write(bytes, 0, len);
            bos.flush();
        }
        bos.close();
        bis.close();

字符缓冲流：bufferedwriter   字符缓冲输出流；bufferedreader   字符缓冲输入流

构造方法：由于是加速字符流的，因此必须传入一个字符输出流或者字符输入流

方法：和字符流的方法同样；可是在字符缓冲输出流中，有一个newline（）方法，换行；在字符缓冲输入流中，有一个readline（）方法，读取一个文本行，返回值是一个字符串

FileWriter fw = new FileWriter("d:\\12\\output.txt",true);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("你好吗");
        bw.newLine();
        bw.flush();
        bw.write("我很好");
        bw.close();

FileReader fr = new FileReader("d:\\12\\output.txt");
        BufferedReader br = new BufferedReader(fr);
        String str = "";
        while((str=br.readLine())!=null){
            System.out.println(str);
        }

复制：加速流复制大文件速度快

FileReader fr = new FileReader("d:\\12\\output.txt");
        BufferedReader br = new BufferedReader(fr);
        FileWriter fw = new FileWriter("d:\\12\\puttwo.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        String str = "";
        while((str = br.readLine())!=null){
            bw.write(str);
            bw.newLine();
            bw.flush();
        }
        bw.close();
        br.close();

properties

一个hashtable的子类，只能存储字符串类型的键值对，持久化的属性集，有方法和流结合

有properties扩展名的文件

构造方法：使用空参构造

方法：store（）方法，传入一个字节输出流或者字符输出流；load（）方法，出入一个字节输入流或者字符输入流

 setproperties（）方法，设置键值对；stringPropertyNames（）方法，遍历键值，返回set集合；getproperties（）方法，得到值

Properties pro = new Properties();
        pro.setProperty("a", "1");
        pro.setProperty("b", "2");
        pro.setProperty("c", "3");
//        String str = pro.getProperty("a");
//        System.out.println(str);
        Set<String> set = pro.stringPropertyNames();
        for(String s:set){
            System.out.println(pro.getProperty(s));

传入字节流：

Properties pro = new Properties();
        FileInputStream fis = new FileInputStream("d:\\12\\pro.properties");
        pro.load(fis);
        Set<String> set = pro.stringPropertyNames();
        for(String s:set){
            System.out.println(pro.getProperty(s));
        }
        fis.close();

Properties pro = new Properties();
        pro.setProperty("school", "qinghua");
        pro.setProperty("father", "ligang");
        FileOutputStream fos = new FileOutputStream("d:\\12\\pro.properties",true);
        pro.store(fos, "message");
        fos.close();

 

复制：

Properties pro = new Properties();
        FileReader fr = new FileReader("d:\\12\\pro.properties");
        FileWriter fw = new FileWriter("d:\\12\\proone.properties");
        pro.load(fr);
        //Set<String> set = pro.stringPropertyNames();
//        for(String s:set){
//            System.out.println(pro.getProperty(s));
//        }
        pro.store(fw, "");

序列化流和反序列化流

操做对象的，对象类的创建必须实现Serializable接口，不然无法存入流中，不想把某个成员变量存入流，要用瞬态关键词修饰transient，这是个字节流

objectoutputstream：序列化流，把对象写入流中

构造方法：传入一个字节输出流

方法：writeobject（），传入一个对象，并把对象写入流中

FileOutputStream fos = new FileOutputStream("d:\\12\\dog.txt");
        ObjectOutputStream os = new ObjectOutputStream(fos);
        Dog d = new Dog();
        d.setName("java");
        d.setColor("white");
        os.writeObject(d);
        os.close();
        System.out.println(d);

objectinputstream：反序列化流，从流中读取对象

构造方法：传入一个字节输入流

方法：readobject（），从流中读取对象，返回一个object超类（要用建立的类接收的话，须要多态-向下转型）

FileInputStream fis = new FileInputStream("d:\\12\\dog.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Dog d = (Dog)ois.readObject();
        System.out.println(d);

注意：对象必定要实现接口

 打印流

printstream：字节打印流   printwriter：字符打印流

通常使用字符打印流，由于字符打印流的构造方法比字节打印流多一个

构造方法：能够传入一个file对象，能够传入一个字符串，能够传入一个字节输出流，能够传入一个字符输出流

方法：print（），println（），write（）

File f = new File("d:\\12\\output.txt");
        PrintWriter pw = new PrintWriter(f);
        pw.print("今天我养了一只狗");
        pw.write(100);
        pw.print(100);
        //write方法走码表,print方法原样输出
        pw.flush();
        pw.close();

自动刷新：在构造方法的字节流或字符流的后面加上一个true

FileOutputStream fos = new FileOutputStream("d:\\12\\output.txt");
        PrintWriter pw = new PrintWriter(fos,true);
        pw.println("你好呀");
        pw.close();

io流操做工具类

须要导入第三方包的class文件

filenameutils类：用来处理文件或目录的名称

getextention（）方法：获取扩展名

getName（）方法：得到文件名

isextention（）：是以哪一个扩展名结尾吗

String str = FilenameUtils.getExtension("d:\\12\\output.txt");
        //System.out.println(str);
        String str2 = FilenameUtils.getName("d:\\12\\output.txt");
        //System.out.println(str2);
        boolean flag = FilenameUtils.isExtension("d\\12\\output.txt","txt");
        //System.out.println(flag);

fileutils类：操做文件

writestringtofile（）方法：把字符串写入文件中

readfiletostring（）方法：从文件中读取内容

copydirectorytodirectory（）方法：赋值文件夹

copyfile（）方法：复制文件

FileUtils.writeStringToFile(new File("d:\\12\\output.txt"), "你好",true);
        String file = FileUtils.readFileToString(new File("d:\\12\\output.txt"));
        System.out.println(file);
        FileUtils.copyDirectoryToDirectory(new File("d:\\123"), new File("d:\\12"));
        FileUtils.copyFile(new File("d:\\12\\output.txt"), new File("d:\\12\\123.txt"));

 

 不是java自带的类，须要创建文件夹导入