java中关于文件读写的各种类及其作用

流：

字符流：一次读写一个字符，一个中文算一个字符占三个字节

字节流：一次读写一个字节

● 输入流：往程序中读叫输入流。

● 输出流：从程序中往外写叫输出流。

Reader和Writer的子类都是字符流 主要处理字符或字符串

InputStream和OutputStream的子类都是字节流

● 字节流中常用类

字节输入流 FileInputStream

字节输出流 FileOutputStream

● 字符流中常用类

字符输入流 FileReader

字符输出流 FileWriter

流：stream

		//创建一个输入流对象
        FileInputStream in = new FileInputStream("D:/a.txt");
		//创建一个输出流对象
        FileOutputStream out = new FileOutputStream("D:/a1.txt");
        int t = 0;
		//当a读取结束时暂停循环，循环每次把a的数据输出到a1
        while ((t = in.read()) != -1) {//读取结束为-1
            System.out.println(t);
            out.write(t);
        }
        //关闭流对文件的占用
        in.close();
        out.close();
1
2
3
4
5
6
7
8
9
10
11
12
13

in.read一次读取一个太慢

用in.read(byte[])优化，每次读取一个数组

		FileInputStream in=new FileInputStream("D:/a.txt");
        FileOutputStream out=new FileOutputStream("D:/b.txt");
        /*
        int read()默认一次读一个字节，返回的是读到的字节编码，效率低
        int read(byte[] b)默认一次读一个指定大小的byte数组个字节,返回的是数组中一次实际装入的字节个数
        两个方法相同之处都是读完后返回-1
         */
        byte[]bytes=new byte[100];
        int size=0;
        //循环读取数组长度为100的字节数直到结束
        while((size=in.read(bytes))!=-1){
            System.out.println(size);//显示实际读取的字节个数
            out.write(bytes,0,size);//把bytes的数据输出到b.txt里，从0索引开始输出，size是根据实时长度决定输出多少个字节
        }
        in.close();
        out.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

带缓冲区的处理流BufferInputStream:

		//默认缓冲区数组长度8192，每次存8192字节放在缓冲区
        FileInputStream in=new FileInputStream("D:/a.txt");//节点流，直接包含文件(数据)
        BufferedInputStream iin=new BufferedInputStream(in);//处理流-->带缓冲功能的流

        FileOutputStream out=new FileOutputStream("D:/c.txt");
        BufferedOutputStream oout=new BufferedOutputStream(out,2048);//构造函数，限制缓冲区为2048

        byte[] bytes=new byte[2049];
        int size=0;
        while((size=iin.read(bytes))!=-1){
            System.out.println(size);
            oout.write(bytes,0,size);
        }
        iin.close();
        oout.flush();//刷新缓冲区
        oout.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

把数据输入输出流：

//数据输入输出流

        /*
        String s="666";
        FileOutputStream out=new FileOutputStream("D:/d.txt");
        out.write(s.getBytes());//实际向外发送时，要转为byte数组

        FileInputStream in=new FileInputStream("D:/d.txt");
        byte[]bytes=new byte[100];
        int size=in.read(bytes);//对方接收到后也是byte数组
        String str=new String(bytes,0,size);//把bytes从0索引开始转化size长度为String放进str
        System.out.println(str);
         */


        String s="666";
        FileOutputStream out=new FileOutputStream("D:/d.txt");
        DataOutputStream dout=new DataOutputStream((out));
        dout.writeUTF(s);//将字符串直接写出，但是底层转为字节数组

        FileInputStream in=new FileInputStream("D:/d.txt");
        DataInputStream din=new DataInputStream(in);
        String str=din.readUTF();//直接可以读到一个字符串，在底层将读到的字节数组转为字符串
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

字符输入输出流：

		//字符输入输出流
        
        FileReader reader=new FileReader("D:/g.txt");
        FileWriter writer=new FileWriter("D:/g1.txt");

        int c=0;
        while((c=reader.read())!=-1){
            writer.write(c);
        }
        reader.close();
        writer.close();
        
        
        //用reader的数组读取方法
        FileReader reader=new FileReader("D:/f.txt");
        FileWriter writer=new FileWriter("D:/f1.txt");
        
        char[]chars=new char[10];
        int size=0;
        while((size=reader.read(chars))!=-1){
            writer.write(chars,0,size);
        }
        reader.close();
        writer.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

字符流缓冲：

		FileReader fileReader =new FileReader("D:/e.txt");
        BufferedReader bufferedReader=new BufferedReader(fileReader);

        FileWriter writer=new FileWriter("D:/e1.txt",true);//输出行会覆盖上一行，因此要append追加
        BufferedWriter bufferedWriter=new BufferedWriter(writer);

        String line=null;//一次可以读入一行数据，读完返回null
        while((line=bufferedReader.readLine())!=null){
            bufferedWriter.write(line);//一次向外输出一个字符串
            bufferedWriter.newLine();//插入一个换行符
        }
        bufferedReader.close();
        bufferedWriter.flush();
        bufferedWriter.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14

对象的输入输出：

		/*
        对象输入输出流：
        有时候，需要将运行中的对象信息持久保存起来，因为对象再内存中，如果程序终止，对象也会消失
        将对象信息输出到文件的过程，称之为对象的序列化，使用ObjectOutputStream(处理流)
        将对象信息从文件中输入到java程序的过程，称之为对象反序列化，使用的ObjectInpuStream
        对象的反序列化，会在内存中重新创建新的对象保存数据，所以，也是java中创建对象的一种方式
         */
        String s=new String("666");
        Date date=new Date();
        FileOutputStream out=new FileOutputStream("D:/ty.txt");
        ObjectOutputStream outputStream=new ObjectOutputStream(out);
        //输出乱码
        outputStream.writeObject(s);
        outputStream.writeObject(date);

        outputStream.flush();
        outputStream.close();

        //想要使用必须读取乱码的文件
        FileInputStream in=new FileInputStream("D:/ty.txt");
        ObjectInputStream oin=new ObjectInputStream(in);
        String str=(String)oin.readObject();
        Date date1=(Date)oin.readObject();
        System.out.println(str);
        System.out.println(date1);

        oin.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

一旦一个类实现了Serializable接口,会自动的为每个生成一个序列化编号(唯一的) //1234

虽然实现Serializable接口,可以生成一个序列化id号,但是一旦类信息发生了修改,序列化编号就会变 //4321

如果重新输入对象，两次的序列化版本号就不一致了

解决办法:
显示的在类中生成一个序列化版本号

private static final long serialVersionUID = 8402381433702375963L;//类的序列化id
1