JavaIO流简单入门

流的分类

一般情况下是按照流的流向来分通常分为输入流和输出流 （输入和输出是相对于真在写的程序而言的：输入是从磁盘往程序里面输入，输出也是从程序里面输出到磁盘中）。

• 输入流：只能从输入流中读取数据，而不能从输入流中写入数据；
• 输出流：只能向输出流中写入数据，而不能从输出流中读取数据。

IO流的一个使用规则

• 如果进行输入输出的内容是文本内容（常用的文档，.txt文件等），则使用字符流，即 Reader/Writer
• 如果进行输入输出的内容是二进制内容（如图片等），则使用字节流，即 InputStream/OutputStream
  

InputStream使用案例

import java.io.FileInputStream;
import java.io.IOException;
public class Test {
    public static void main(String[] args) {
        FileInputStream fileInputStream=null;
        try{
            fileInputStream=new FileInputStream("D:\\abc.txt" );
            byte[] bbuf=new byte[1024];
            int hasRead=0;
            while ((hasRead=fileInputStream.read(bbuf))>0){
                System.out.println(new String(bbuf,0,hasRead));
            }
            /**
            //这种方法要比上面的简单一点
            fileInputStream=new FileInputStream("D:\\abc.txt" ); // 根据path路径实例化一个输入流的对象
            int size=fileInputStream.available(); //返回这个输入流中可以被读的剩下的bytes字节的估计值；
            byte[] array = new byte[size];  //根据输入流中的字节数创建byte数组；
            fileInputStream.read(array);   //把数据读取到数组中；
            System.out.println(new String(array)); //根据获取到的Byte数组新建一个字符串，然后输出；
            */


        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                fileInputStream.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

OutputStream使用案例

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class IoStreamTest2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        FileOutputStream fileOutputStream=null;
        try{
            fileOutputStream=new FileOutputStream("D:\\abcd.txt");
            System.out.println("Please input :");
            String str=scanner.nextLine();
            fileOutputStream.write(str.getBytes());
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                fileOutputStream.close();
                scanner.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

小结

案例中使用了字节流所以不管是文件字节输入流还是文件字节输出流它们的 read(参数) 方法和**write(参数)**方法都应该传入字节数字这个参数。

字符流使用

Reader使用案例

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

public class IoStreamTest3 {
    public static void main(String[] args) {
        //声明一个BufferedReader
        BufferedReader bufferedReader=null;
        try{
            //实例化BufferedReader流，连接FileReader流用于读文件。
            bufferedReader=new BufferedReader(new FileReader("D:\\abc.txt"));
            String result=null;
            //循环读文件，一次读一行
            while ((result=bufferedReader.readLine())!=null){
                System.out.println(result);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                bufferedReader.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

Writer使用案例

import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class IoStreamTest4 {
    public static void main(String[] args) {
        //声明一个BufferedReader
        Scanner scanner=new Scanner(System.in);
        FileWriter fileWriter=null;
        try{
            //实例化文件字符输出流
            fileWriter=new FileWriter("D:\\abcde.txt");
            System.out.println("请输入内容：");
            String str=scanner.nextLine();
            fileWriter.write(str);
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                fileWriter.close();
                scanner.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

对象序列化

对象的序列化和反序列化过程如图所示。

定义一个实体类

package ioStream;

import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private int age;
    private String address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

序列化过程

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamDemo {
    public static void main(String[] args) {
        try{
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("D:\\object.txt"));
            Person person=new Person("曾",22,"江西南昌");
            objectOutputStream.writeObject(person);
            objectOutputStream.flush();
            System.out.println("序列化完毕");
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

读取序列化对象的输入流

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamDemo {
    public static void main(String[] args) {
        try{
            ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("D:\\object.txt"));
            Person person=(Person)objectInputStream.readObject();
            System.out.println("序列化完毕！读出的对象信息如下");
            System.out.println(person);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

Web开发中IO流的应用

等待更新。。。