JAVA IO流

IO流

IO流的概述

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

　　流按流向分为：输入流、输出流

　　数据类型分为：

　　字节流

　　　　字节输入流读取数据 InputStream

　　　　字节输出流写出数据 OutputStream

　　字符流

　　　　字符输入流读取数据 Reader

　　　　字符输出流写出数据 Writer

FileWriter与FileReader

　　FileWriter 向文件中写数据步骤：

　　1、使用FileWriter流关联文件

　　2、利用FileWriter的写方法写数据

　　3、利用FileWriter的刷新方法将数据从内存刷到硬盘中去

　　4、利用FileWriter的关闭方法将释放占用的系统底层资源

FileWriter写数据

package wdnmd.io;

import java.io.FileWriter;
import java.io.IOException;

/*
输出流写数据的步骤：
    A:创建输出流对象
    B:调用输出流对象的写数据的方法
    C:释放资源
*/

public class FileWriterDemo {

    public static void main(String[] args) throws IOException {
        FileWriter fileWriter = new FileWriter("f:\\a.txt");

        fileWriter.write("wdnmd IO");
//数据没有直接写到文件，其实是写到了内存缓冲区
        fileWriter.flush();
        fileWriter.close();
    }

}

FileWriter向文本末尾追加

public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("c.txt",true); 
        //表示追加写入，默认是false
    
    for(int x=0; x<10; x++) {
        fw.write("hello"+x);
        fw.write("\r\n");
    }

        fw.close();
    }

FileReader读数据

package wdnmd.io.demo02;

import java.io.FileReader;
import java.io.IOException;

/*
输入流读文件的步骤：
    A:创建输入流对象
    B:调用输入流对象的读数据方法
    C:释放资源
*/

public class FileReaderDemo01 {

    public static void main(String[] args) throws IOException {
       FileReader fr = new FileReader("f:\\a.txt");

        int ch;
        while((ch=fr.read())!=-1){
            //读取数据的返回值是-1的时候，就说明没有数据了
            System.out.print(ch);
        }

       　　 fr.close();
    }

}

FileWriter和FileReader完成文件复制（读一次写一次）

package wdnmd.io.demo03;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFileDemo01 {

    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("StudentTest.java");

        FileWriter fw = new FileWriter("Copy.java");

        int ch;
        while((ch=fr.read())!=-1){
            fw.write(ch);
        }
        fw.close();
        fr.close();
    }

}

FileWriter和FileReader完成文件复制（字符数组）

package wdnmd.io.demo03;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFileDemo02 {

    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("StudentTest.java");
        FileWriter fw = new FileWriter("Copy.java");
        char[] ch = new char[1024];
        int len;
        while((len = fr.read(ch)) != -1){
            fw.write(ch,0,len);
　　　　　　//写一个字符数组的一部分数据
        }
        fw.close();
        fr.close();
    }
}

Close（）与flush（）方法的区别

　　　　flush():刷新缓冲区。流对象还可以继续使用。

　　　　close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

路径

　　　　相对路径：相对当前项目而言的，在项目的根目录下(a.txt)

　　　　绝对路径：以盘符开始的路径(d:\\a.txt)

BufferedWriter与BufferedReader

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

　　　　BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

package wdnmd.io.demo04;

import java.io.*;

public class BufferedWriterDemo01 {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("StudentTest.java"));
        
        int ch;
        char[] chs = new char[1024];
        while((ch = br.read(chs))!=-1){
            System.out.print((char)ch);
        }
    }
}

缓冲流特有方法

　　　　BufferedWriter: newLine():写一个换行符，这个换行符由系统决定

　　　　BufferedReader: readLine():一次读取一行数据，但是不读取换行符

IO流复制文件的5中方式

A:利用基本流一次读写一个字符

B:利用基本流一次读写一个字符数组

C:利用缓冲流一次读写一个字符

D:利用缓冲流一次读写一个字符数组

E:利用缓冲流的特有方法一次读写一个字符串

  1 package wdnmd.io;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.BufferedWriter;
  5 import java.io.FileReader;
  6 import java.io.FileWriter;
  7 import java.io.IOException;
  8 
  9 /*
 10  * 复制文本文件(5种方式)
 11  * 
 12  * 数据源：
 13  *         FileWriterDemo.java
 14  * 目的地：
 15  *         Copy.java
 16  */
 17 public class CopyFileTest {
 18     public static void main(String[] args) throws IOException {
 19         /*
 20         method1("FileWriterDemo.java","Copy.java");
 21         method2("FileWriterDemo.java","Copy.java");
 22         method3("FileWriterDemo.java","Copy.java");
 23         method4("FileWriterDemo.java","Copy.java");
 24         method5("FileWriterDemo.java","Copy.java");
 25         */
 26         
 27         String srcFileName = "FileWriterDemo.java";
 28         String destFileName = "Copy.java";
 29         
 30 //        method1(srcFileName,destFileName);
 31 //        method2(srcFileName,destFileName);
 32         method3(srcFileName,destFileName);
 33 //        method4(srcFileName,destFileName);
 34 //        method5(srcFileName,destFileName);
 35     }
 36     
 37     //缓冲流一次读写一个字符串
 38     public static void method5(String srcFileName,String destFileName) throws IOException {
 39         //创建输入缓冲流对象
 40         BufferedReader br = new BufferedReader(new FileReader(srcFileName));
 41         //创建输出缓冲流对象
 42         BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
 43         
 44         //一次读写一个字符串
 45         String line;
 46         while((line=br.readLine())!=null){
 47             bw.write(line);
 48             bw.newLine();
 49             bw.flush();
 50         }
 51         
 52         //释放资源
 53         bw.close();
 54         br.close();
 55     }
 56     
 57     //缓冲流一次读写一个字符数组
 58     public static void method4(String srcFileName,String destFileName) throws IOException {
 59         //创建输入缓冲流对象
 60         BufferedReader br = new BufferedReader(new FileReader(srcFileName));
 61         //创建输出缓冲流对象
 62         BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
 63         
 64         //一次读写一个字符数组
 65         char[] chs = new char[1024];
 66         int len;
 67         while((len=br.read(chs))!=-1) {
 68             bw.write(chs,0,len);
 69         }
 70         
 71         //释放资源
 72         bw.close();
 73         br.close();
 74     }
 75     
 76     //缓冲流一次读写一个字符
 77     public static void method3(String srcFileName,String destFileName) throws IOException {
 78         //创建输入缓冲流对象
 79         BufferedReader br = new BufferedReader(new FileReader(srcFileName));
 80         //创建输出缓冲流对象
 81         BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));
 82         
 83         //一次读写一个字符
 84         int ch;
 85         while((ch=br.read())!=-1) {
 86             bw.write(ch);
 87         }
 88         
 89         //释放资源
 90         bw.close();
 91         br.close();
 92     }
 93     
 94     //基本流一次读写一个字符数组
 95     public static void method2(String srcFileName,String destFileName) throws IOException {
 96         //创建输入流对象
 97         FileReader fr = new FileReader(srcFileName);
 98         //创建输出流对象
 99         FileWriter fw = new FileWriter(destFileName);
100         
101         //一次读写一个字符数组
102         char[] chs = new char[1024];
103         int len;
104         while((len=fr.read(chs))!=-1) {
105             fw.write(chs,0,len);
106         }
107         
108         //释放资源
109         fw.close();
110         fr.close();
111     }
112     
113     //基本流一次读写一个字符
114     public static void method1(String srcFileName,String destFileName) throws IOException {
115         //创建输入流对象
116         FileReader fr = new FileReader(srcFileName);
117         //创建输出流对象
118         FileWriter fw = new FileWriter(destFileName);
119         
120         //一次读写一个字符
121         int ch;
122         while((ch=fr.read())!=-1) {
123             fw.write(ch);
124         }
125         
126         //释放资源
127         fw.close();
128         fr.close();
129     }
130 }

FileInputStream

public static void main(String[] args) throws IOException  {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("IODemo.java");
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\a\\a.java");
        
        //一次读写一个字节
        /*int by;
        while((by = fis.read()) != -1) {
            fos.write(by);
        }*/
        //一次读写一个字节数组
        int len;//存储读到的字节个数
        byte[] bys = new byte[1024];
        while((len = fis.read(bys)) != -1) {
            fos.write(bys,0,len);
        }
        
        
        //释放资源
        fos.close();
        fis.close();
    }

字节流与字符流

字节流可以操作所有类型的文件,因为所有的文件在计算机中都是以字节形式存储

而字符流只能用来操作纯文本类型的文件,不能操作字节类型的文件

二进制文件只能使用字节流进行复制（使用windows自带记事本打开读不懂的）

文本文件的复制即可使用字符流，也可以使用字节流

标准输入输出流

标准输入输出流：
        public static final InputStream in：字节输入流,用来读取键盘录入的数据
            public static final int x;
            InputStream is = System.in;
            Scanner sc = new Scanner(System.in);
        public static final PrintStream out：字节输出流,将数据输出到命令行
            System.out.println();

转换流

由于标准输出流是一个字节输出流，所以只能输出字节或者字节数组，但是我们读取到的数据则是字符串，如果想进行输出还需要转换成字节数组

我们要想通过标准输出流输出字符串，把标准输出流转换成一种字符输出流即可，OutputStreamWriter

　　　　OutputStreamWriter(OutputStream out) :转换流，把字节输出流转换成字符输出流

public static void main(String[] args) throws IOException   {
        //method2();
        
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        
        
        //进行数据的读写
        String line;//用于存储读取到的数据
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }
        

        //释放资源
        bw.close();
        br.close();
        
        
    }

InputStreamReader:将字节输入流转换为字符输入流

public static void main(String[] args) throws IOException  {
        //创建输入流对象
        InputStream is = System.in;
        Reader r = new InputStreamReader(is);
        //创建输出流对象
        FileWriter fw = new FileWriter("a.txt");
        
        //读写数据
        char[] chs = new char[1024];
        int len;
        while((len = r.read(chs)) != -1) {
            fw.write(chs,0,len);
            fw.flush();
        }
        
        
        //释放资源
        fw.close();
        is.close();
        
    }

打印流

打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.

字符打印流 PrintWriter

void print(String str): 输出任意类型的数据，

void println(String str): 输出任意类型的数据，自动写入换行操作

public static void main(String[] args) throws IOException  {
        //创建打印流对象
        PrintWriter pw = new PrintWriter("b.txt");
        
        //写出数据
        pw.write("hello");
        pw.write("world");
        pw.write("java");
        
        //释放资源
        pw.close();
    }

对象操作流

用于从流中读取对象的

ObjectInputStream 称为反序列化流,利用输入流从文件中读取对象

ObjectOutputStream 称为序列化流,利用输出流向文件中写入对象

　　特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象。

　　注意：使用对象输出流写出对象，只能使用对象输入流来读取对象

　　　　　只能将支持 java.io.Serializable 接口的对象写入流中

利用序列化流读写对象

class Student implements Serializable

public static void main(String[] args) throws IOException, ClassNotFoundException  {//创建对象输入流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
   
        try {
            while(true) {
                Object obj = ois.readObject();
                System.out.println(obj);
            }
        } catch(EOFException e) {
            System.out.println("读到了文件的末尾");
        }
        
        //释放资源
        ois.close();
    }

Properties集合

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

特点：

1、Hashtable的子类，map集合中的方法都可以用。

2、该集合没有泛型。键值都是字符串。

3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。

4、有和流技术相结合的方法。

　　利用properties存储键值对

public static void main(String[] args) {
        //创建属性列表对象
        Properties prop = new Properties();
        //添加映射关系
        prop.put("CZBK001", "zhangsan");
        prop.put("CZBK002", "lisi");
        prop.put("CZBK003", "wangwu");
        
        //遍历属性列表
        //获取所有的key，通过key获取value
        Set<Object> keys = prop.keySet();
        for (Object key : keys) {
            Object value = prop.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("------------------");
        //获取所有的结婚证对象
        Set<Map.Entry<Object,Object>> entrys = prop.entrySet();
        for (Map.Entry<Object, Object> entry : entrys) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    
    }

　　properties与流结合

public static void main(String[] args) throws IOException{    
        //创建属性列表对象
        Properties prop = new Properties();
        //添加映射关系
        prop.setProperty("CZBK001", "zhangsan");
        prop.setProperty("CZBK002", "lisi");
        prop.setProperty("CZBK003", "wangwu");
        //创建输出流对象
        FileWriter fw = new FileWriter("e.txt");
        
        //void store(Writer writer, String comments) 
        prop.store(fw, "hello world");
        
        //释放资源
        fw.close();
        
    
    }

posted on 2019-08-01 17:21 viper23333 阅读(112) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部