Java IO_java iocsdn-CSDN博客

本文链接：https://blog.csdn.net/weixin_40683252/article/details/80711529

流：

数据传输的方式

节点流&处理流：

节点流：从特定的数据源读写数据；

FileInputStream & FileOutputStream(字节流：一个字节一个字节的读取)

import java.io.*;

public class TestFile2 {
    public static void main(String[] args) {
        int b = 0;
        FileInputStream in = null;
        FileOutputStream ou = null;

        try {
            in = new FileInputStream("TestFile2.java");
            ou = new FileOutputStream("TestFile2Output.java");
            
            while((b = in.read()) != -1) {
                ou.write(b);
            }

            in.close();
            ou.close();

        } catch (FileNotFoundException ex1) {
            System.out.println("file not found!");
            System.exit(-1);
        } catch (IOException ex2) {
            System.out.println("file read fail");
            System.exit(-1);
        }

        System.out.println("file copy success!");
    }

}

FileReader & FileWriter(字符流：一个字符一个字符的读取)

import java.io.*;

public class TestFileReader {
    public static void main(String[] args) {
        FileReader fr = null;
        int c = 0;

        try {
            fr = new FileReader("TestFileReader.java");
            int ln = 0;
            while((c = fr.read()) != -1) {
                System.out.print((char)c);
                
            }
            fr.close();
        } catch (FileNotFoundException ex) {
            System.out.println("file not found!");
            System.exit(-1);
        } catch (IOException ex2) {
            System.out.println("文件读取失败");
            System.exit(-1);
        }
    }

}

import java.io.*;

public class TestFileWriter {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            fw = new FileWriter("TestFileWriterOutput.dat");
            for(int i = 0; i < 5000; i++) {
                fw.write(i);
            }
            fw.close();
          
        } catch (IOException ex) {
            System. out.println("file write fail!");
            System.exit(-1);
        }
        
    }
}

处理流：在已存在的流的基础上，堆数据进行处理，提供更强大的读写功能

BufferedReader & BufferedWriter(提供buffer的处理流，当buffer装满后，才一次性读写，对于硬盘损耗大大降低)

import java.io.*;

public class TestBuffer {
    public static void main(String[] args) {

        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter("TestBufferOutput.txt"));
            BufferedReader br = new BufferedReader(new FileReader("TestBufferOutput.txt"));

            String s = null;
            for(int i = 0; i < 100; i++) {
                s = String.valueOf(Math.random());
                bw.write(s);
                bw.newLine();
            }

            bw.flush();
            while((s = br.readLine()) != null) {
                System.out.println(s);
            }
            bw.close();
            br.close();

        } catch (IOException ex) {
            System.out.println("IO excpetion occurs!");
            System.exit(-1);
        }
        
    }
}

TransformIO: InputStreamReader & OutputStreamWriter(将字节流转化为字符读取的处理流)

import java.io.*;

public class TestTransform {
    public static void main(String[] args) {
        try {
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("TestTransformOut.txt"));
            osw.write("no pain, no gain!");
            System.out.println(osw.getEncoding());
            osw.close();

            osw = new OutputStreamWriter(new FileOutputStream("TestTransformOut.txt", true), "ISO8859_1");
            //true 代表在原有文件基础上继续写入
            
            osw.write("no pain, no gain!");
            System.out.println(osw.getEncoding());
            osw.close();
        } catch (IOException ex) {
            ex.printStackTrace();
            System.exit(-1);
        }

    }

}

import java.io.*;

public class TestTransform2 {
    public static void main(String[] args) {
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            String s = null;

            s = br.readLine();
            while(s != null) {
                if(s.equalsIgnoreCase("exit")) {
                    break;
                }

                System.out.println(s);
                s = br.readLine();
            }
            br.close();
            
        } catch (IOException ex) {
            ex.printStackTrace();
            System.exit(-1);
        }
    }

}

import java.io.*;
import java.util.*;

public class TestPrint3 {
    public static void main(String[] args) {
        String s = null;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        try {
            PrintWriter pw = new PrintWriter(new FileWriter("TestPrint3.txt", true));
            while((s = br.readLine()) != null) {
                if(s.equalsIgnoreCase("exit")) {
                    break;
                }
                System.out.println(s.toUpperCase());
                pw.println("------");
                pw.println(s.toUpperCase());
                pw.flush();
            }
            pw.println("---" + new Date() + "---");
            pw.flush();
            pw.close();
             
        } catch (IOException ex) {
            ex.printStackTrace();
            System.exit(-1);
        }
    
    }
}

数据流：DataIO & ByteArrayIO 读写java原始类型数据的方法

import java.io.*;

public class TestDataStream {
    public static void main(String[] args) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //分配新的内存空间
        DataOutputStream dos = new DataOutputStream(baos);

        try {
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            //拿到刚分配的内存空间的引用
            System.out.println(bais.available());
            DataInputStream dis = new DataInputStream(bais);
            System.out.println(dis.readDouble());
            System.out.println(dis.readBoolean());
            dos.close();
            dis.close();
            
        } catch (IOException ex) {
            ex.printStackTrace();
            System.exit(-1);
        }

    }
}

Object IO: 直接读写对象，将对象序列化后进行存储

import java.io.*;

public class TestObject {
    public static void main(String[] args) throws Exception {
        T t = new T();
        t.k = 8;

        FileOutputStream fos = new FileOutputStream("TestObjectOut.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(t);
        oos.flush();
        oos.close();

        FileInputStream fis = new FileInputStream("TestObjectOut.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        T tReaded = (T) ois.readObject();
        System.out.println(tReaded.i);
        System.out.println(tReaded.j);
        System.out.println(tReaded.d);
        System.out.println(tReaded.k);
    }

}

class T implements Serializable {
    //该接口为标记性接口，没有提供方法，用于告诉编译器该对象可以被序列化
    int i = 10;
    int j = 9;
    double d = 2.3;
    transient int k = 15; // transient 关键字表示在该对象序列化时，不予以考虑
} //externalizable接口 自己定义如何序列化对象