Java篇:IO流

流(IO)

四个基本流:  

  InputStream(输入字节流)、OutputStream(输出字节流)、writer(输出字符流)、reader(输入字符流)-四个基本流都是抽象类不能实例化,固只能用其子类;
    注意:流结束后一定要关流(close())和将引用设为null;以便被GC回收。

流的一般异常处理:
    1. 流对象要外置定义内置初始化
    2. 判断流对象是否初始化成功---判断流对象是否为空
    3. 关流操作无论成功与否,都需要将流对象值为null

    // 流对象需要外置定义内置初始化
    FileWriter writer = null;
    try {
        writer = new FileWriter("E:\\b.txt");
        writer.write("bbb");

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //需要判断流对象是否为空,以防对象初始化失败出现空指针异常
        if (writer != null) {
            try {
                    writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                writer = null;
            }
        }
    }

 

字符流:
    FileWriter(String name):传入文件路径,创建新文件。

// 需要准备一个流对象---布尔值表示是否向文件中追加内容
FileWriter writer = new FileWriter("E:\\a.txt",true);

// 利用write方法向文件中写入数据
// 数据不是直接写到文件中而是写到了缓冲区中
// 当缓冲区没有满的时候,数据不会写到文件中
// 程序一旦结束,数据死在了缓冲区中
writer.write("aaa\r\n");

// 冲刷缓冲区
// writer.flush();

// 关闭流
//流在关闭之前会自动冲刷一次缓冲区以防有数据死在缓冲区中
//流在关闭之后并没有被销毁,只是不能再次使用
writer.close();
System.out.println(writer);
writer = null;

  FileReader(String name):传入文件路径,读取文件

 1 //创建一个输入流对象
 2 FileReader reader = new FileReader("D:\\a.txt");
 3 //定义一个变量来记录读取的数据
 4 int len = -1;
 5 while((len = raeder.read()) != -1){
 6     System.out.println((char)len);
 7 }
 8 
 9 //需要一个数组来作为盛放读出的数据容器
10 char[] char = new char[1024];
11 //定义一个变量来记录读出的数据保存在数组的数
12 int len = -1;
13 //将数据读取到char数组中。读到末尾返回的是-1则表示读完了
14 while((len = rader.read(char))!=-1){
15     //将char数组中的数据拿出来拼接成一个字符串并打印
16     System.out.println(new String(char,0,len));
17 }
18 reader.close();
19 reader = null;

  两个缓冲流:BuffReader、BufferedWriter---->主要的作用提供缓冲区

  BuffReader:从字符输入流中来获取数据;Reader对象来指名数据的具体来源.(需要传入字符流);

 1 //BufferedReader需要一个字符输入流对象---字符输入流指名数据的具体来源,BufferedReader从流中来获取数据,然后提供一个缓冲区
 2 BufferedReader br = new BufferedReader(new FileReader("D:\\a.txt"));
 3         
 4 //来定义一个变量来记录每一行的数据
 5 String line = null;
 6         
 7 //读取文件
 8 while((line = br.readLine()) != null){
 9     System.out.println(line);
10 }
11         
12 br.close();

  BufferWriter:主要是提供了newLine这个方法。方便开发时换行在不同的平台实现相同的换行效果。只有BufferWriter这个对象才有newLine方法。

 

字节流:  InputStream:输入字节流【如文件不存在时会自动创建,若文件存在则会被新创建的文件所覆盖】
          |--FileInputStream(子类)

1 FileInputStream fis = new FileInputStream("D:\\a.txt");
2 int len = -1;
3 byte[] by = new byte[1024*1024];
4 while((len = fis.raeder(by))!=-1){  //将数据读取到字节数组内。
5     System.out.println(by,0,len);
6 }

  OutputStream:输出字节流【如文件不存在时会自动创建,若文件存在则会被新创建的文件所覆盖】
          |--FileOutputStream(子类)

 1 //准备了一个输出流来向文件中写入数据
 2 FileOutputStream fos = new FileOutputStream("E:\\c.txt");
 3         
 4 //创建一个Scanner对象
 5 Scanner s = new Scanner(System.in);
 6 String str = s.nextLine();
 7 s.close();
 8         
 9 //写出数据---字节流没有缓冲区
10 fos.write(str.getBytes());
11         
12 //关流
13 fos.close();

  转换流:

    OutputStreamWriter:将字节输出流转换成字符输出流。

1 //创建了一个流对象---没有指定编码的时候,采用的是系统平台码
2 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\d.txt"),"utf-8");
3         
4 //写出数据
5 osw.write("达内大数据~~~");
6         
7 //关流
8 osw.close();

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

 1 //创建一个输入流对象
 2 InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\d.txt"), "utf-8");
 3         
 4 //创建一个缓冲流
 5 BufferedReader br = new BufferedReader(isr);
 6         
 7 //记录每行的数据
 8 String line = null;
 9         
10 //读取数据
11 while((line = br.readLine()) != null){
12     System.out.println(line);
13 }
14         
15 //关流
16 br.close();

  系统流:
          System.out   标准输出流
          System.in     标准输入流
          System.err    标准错误流

  打印流:
          PrinteWriter:是一个输出流

 1 // 创建打印流对象
 2 PrintWriter pw = new PrintWriter("D:\\a.txt");
 3 
 4 // 写出数据
 5 // pw.write("aaa");
 6 
 7 // 打印数据
 8 pw.print("aaaa");
 9 pw.println(1.234);
10 // 打印对象的时候,默认调用了这个对象的toString方法
11 pw.println(new A());
12 
13 pw.println("bbbb");
14 
15 // System.out.println();
16 
17 // 关流
18 pw.close();

  合并流:
          关键字:SequenceInputStream

 1 //创建三个流对象指向三个文件
 2 FileInputStream f1 = new FileInputStream("E:\\a.txt");
 3 FileInputStream f2 = new FileInputStream("E:\\b.txt");
 4 FileInputStream f3 = new FileInputStream("E:\\c.txt");
 5         
 6 //创建 一个向量对象
 7 //Vector是List的一个实现类,是最早期的列表,在List之前产生的
 8 Vector<InputStream> vector = new Vector<InputStream>();
 9         
10 //将流添加到集合中
11 vector.add(f1);
12 vector.add(f2);
13 vector.add(f3);
14         
15 //利用集合产生枚举对象
16 Enumeration<InputStream> e = vector.elements();
17         
18 //创建合并流对象
19 SequenceInputStream sis = new SequenceInputStream(e);
20         
21 //读取数据
22 BufferedReader br = new BufferedReader(new InputStreamReader(sis));
23         
24 //记录每一行的数据
25 String line = null;
26         
27 //读取数据
28 while((line = br.readLine()) != null){
29     System.out.println(line);
30 }
31         
32 //关流
33 br.close();
View Code

  序列化和反序列化:
          ObjectOutputStream:是个输出流。----序列化

 1 //实例化一个对象(对象中自己的基本信息)
 2 Person p = new Person;
 3 
 4 //创建一个序列化流
 5 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\test.txt"));
 6 
 7 //序列化对象;writerObject 写入的是一个对象。
 8 oos.writerObject(p);    
 9 
10 //关流     
11 oos.close();

    ObjectInputStream:是个输入流。 ---反序列化

 1 //创建反序列化流
 2 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\test.txt"));
 3 
 4 //反序列化对象;从 ObjectInputStream 读取对象。 返回是个Object
 5 Person person = (Person)ois.readObject;  
 6 
 7 //关流
 8 ois.close();
 9 
10 //测试;输出Person对象中需要的基本信息
11 System.ou.println(person.name+","+person.age); 

  Properties
          Properties本质上是一个映射,继承了Hashtable类。---可持久的映射。---将映射保存到 properties文件中。
          Properties中键值对的类型都是String。
          properties文件中不能直接存储中文,一旦输入中文会将中文转化成对应的编码
        
          HashMap---默认的初始大小是16,加载因子是0.75f---扩容,扩容一倍---是一个异步式线程不安全的映射---允许一个键为null,允许值为null
          Hashtable---默认的初始大小是11,加载因子是0.75f;每次不是一倍---是一个同步式线程安全的映射---不允许键值为空
          ConcurrentHashMap---是一个异步式线程安全的映射

    下面的代码是序列化Properties

 1 //创建properties对象
 2 Properties prop = new Properties();
 3         
 4 //添加键值对---键值的类型只能是String类型
 5 prop.put("name", "wade");
 6 prop.setProperty("age", "15");
 7 prop.setProperty("gender", "Male");
 8         
 9 //将prop对象序列化到硬盘上
10 //第一个参数需要的是一个流对象
11 //第二个参数需要一个字符串---注释
12 prop.store(new FileWriter("person.properties"), "This is a person .");

    下面的代码是反序列化Properties

 1 //创建一个properties对象
 2 Properties p = new Properties();
 3         
 4 //需要将对象反序列化回来
 5 p.load(new FileInputStream("person.properties"));
 6         
 7 //根据键来获取值
 8 System.out.println(p.get("name"));
 9 
10 //给了一个默认值,如果这个键不存在或者没有对应的值,那么返回默认值;反之返回对应值
11 System.out.println(p.getProperty("hobby","打篮球!!!"));

 

posted @ 2017-05-04 15:27  大大大圣  阅读(275)  评论(0编辑  收藏  举报