IO流实践

IO 四大抽象类

InputStream

FileInputStream

public class FileInputStram_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\a.txt";
        FileInputStream fileInputStream = new FileInputStream(filePath);
        int data;
        byte[] bytes = new byte[8];
        while((data = fileInputStream.read(bytes)) != -1){
//            System.out.println(new String(bytes));
            System.out.println(new String(bytes,0,data));
        }
//        System.out.println((char)fileInputStream.read());
        fileInputStream.close();
    }
}

BufferedInputStream

public class BufferedInputStream_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\a.txt";

        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));

        //按行读取
        byte[] buff = new byte[1024];
        int readLen;
        while((readLen = bufferedInputStream.read(buff)) != -1){
            System.out.println(new String(buff,0,readLen));
        }

        bufferedInputStream.close();
    }
}

ObjectInputStream

反序列化

需要先进行序列化

public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filePath = "d:\\b.txt";

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));

        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readDouble());
        System.out.println(objectInputStream.readUTF());

        Object dog = objectInputStream.readObject();
        System.out.println(dog);


        Dog dog2 = (Dog)dog;
        System.out.println(dog2.toString());
        objectInputStream.close();

        System.out.println("反序列化完毕");
    }
}

OutputStream

FileOutputStream

public class FileOutputStream_{
    public static void main(String[] args) throws IOException {
        String inPath = "C:\\Users\\sdas\\Pictures\\头像2.jpg";
        String outPath = "d:\\b.jpg";

        FileInputStream fileInputStream = new FileInputStream(inPath);
        FileOutputStream fileOutputStream = new FileOutputStream(outPath,true);

        byte[] buff = new byte[8];
        int data ;

        while ((data = fileInputStream.read(buff)) != -1){
//        while ((data = fileInputStream.read()) != -1){
            fileOutputStream.write(buff,0,data);//推荐
//            fileOutputStream.write(buff);
        }
        fileOutputStream.close();
        fileInputStream.close();
    }
}

BufferedOutputStream

public class BufferedOutputStream_ {
    public static void main(String[] args) throws IOException {
        //字节流可以操作二进制文件  可以拷贝 图片/视频/音频等

        String inPath = "C:\\Users\\sdas\\Pictures\\头像2.jpg";
        String outPath = "d:\\头像2.jpg";

        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(inPath));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(outPath));

        byte[] buff = new byte[1024];
        int readLen;

        while ((readLen = bufferedInputStream.read(buff)) != -1){
            bufferedOutputStream.write(buff,0,readLen);
        }

        bufferedInputStream.close();
        bufferedOutputStream.close();

    }
}

ObjectOutputStream

序列化

• 当序列化化对象时 给对象类serialVersionUID属性 序列化版本号 可以提高兼容性 当对象类中的成员修改是不会被视为新的类 而是当作当前了做了修改
• 当序列化对象时 默认将里面所有属性都进行序列化 但除了static或transient修饰的成员
• 序列化对象时 要求里面的属性都需要实现序列化接口
• 序列化具有继承性 其子类都默认实现了序列化

该DOG给作用于序列化和反序列化

public class Dog implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int age;

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

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

public class ObjectOutputStream_ {
    public static void main(String[] args) throws IOException {
        //序列化之后需要反序列化 在ObjectOutputStream_中反序列化
        String filePath = "d:\\b.txt";

        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));

        objectOutputStream.writeInt(100);
        objectOutputStream.writeBoolean(true);
        objectOutputStream.writeChar('c');
        objectOutputStream.writeDouble(9.9);
        objectOutputStream.writeUTF("阿萨德");

        //实现序列化接口 相当于标识符

        objectOutputStream.writeObject(new Dog("dog",1));

        objectOutputStream.close();

        System.out.println("序列化完成");

    }
}

PrintStream

public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        PrintStream out = System.out;
        /*
        * public void print(Object obj) {
        write(String.valueOf(obj));
    }
        * */
        String str = "hello";
        out.print(str);
        //print的底层时write
        System.out.println(String.valueOf("123"));
        out.write(str.getBytes());
        //修改输出位置
        System.setOut(new PrintStream("d:\\b.txt"));
        System.out.print("hello");
    }
}

Reader

FileReader

public class FileReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\a.txt";
        FileReader fileReader = new FileReader(filePath);

        int readLen;
        char[] buff = new char[1024];
        while ((readLen = fileReader.read(buff)) != -1) {
            System.out.println(new String(buff,0,readLen));
        }
        fileReader.close();
    }
}

BufferedReader

public class BufferedReader_{
    public static void main(String[] args) throws IOException {
        String filePath = "d:\\a.txt";

        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));

        //按行读取
        String line;
        while((line = bufferedReader.readLine()) != null){
            System.out.println(line);
        }
        //这里只需要关闭处理流即可 底层就是关闭节点流
        bufferedReader.close();
    }
}

Writer

FileWriter

需要flush或者close 不然无法读写到硬盘

public class FileWriter_ {
    public static void main(String[] args) throws IOException {
        //1. 该类是字符流 操作字符
        //2. 不要操作二进制文件 可能造成文件损坏

        String inPath = "d:\\a.txt";
        String outPath = "d:\\b.txt";

        FileReader reader = new FileReader(inPath);
        FileWriter writer = new FileWriter(outPath,true);

        int readLen;
        char[] buff = new char[1024];

        while ((readLen = reader.read(buff)) != -1){
//            writer.write(buff);
            writer.write(new String(buff,0,readLen));
            System.out.println(new String(buff));

        }
        writer.close();//必须关闭流 或者 使用flush 才能读写到文件
        reader.close();
    }
}

BufferedWriter

public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        //1. 该类是字符流 操作字符
        //2. 不要操作二进制文件 可能造成文件损坏

        String inPath = "d:\\a.txt";
//        String outPath = "C:\\Users\\sdas\\Pictures\\头像2.jpg";
        String outPath = "d:\\b.txt";

        BufferedReader bufferedReader = new BufferedReader(new FileReader(inPath));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(outPath));

        String line;
        while((line = bufferedReader.readLine()) != null){
            bufferedWriter.write(line);
            bufferedWriter.newLine();
        }
        bufferedWriter.close();
        bufferedReader.close();
    }
}

PrintWriter

public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
//        PrintWriter printWriter = new PrintWriter(System.out);
        PrintWriter printWriter = new PrintWriter(new FileWriter("d:\\b.txt"));

        printWriter.print("hi");
        printWriter.close();
    }
}