IO流

1
FileOutputStream(String name)
2
•     创建一个向具有指定名称的文件中写入数据的输出文件流。
3
FileOutputStream(File file)
4
•     创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
5
FileOutputStream(File file, boolean append) –追加
6
•     创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

1
package io;
2
​
3
import java.io.File;
4
import java.io.FileNotFoundException;
5
import java.io.FileOutputStream;
6
import java.io.IOException;
7
​
8
/**
9
 * FOS FileOutputStream 文件输出流
10
 * 对File文件进行写出Output,使用的方式是Stream字节流
11
 */
12
public class FOSDemo {
13
    public static void main(String[] args) throws IOException {
14
        //1.创建FileOutputStream输出流,将数据输出到./test.txt文件中
15
        //File file = new File("./test.txt");
16
        //FileOutputStream fos = new FileOutputStream(file);
17
        //可以直接将文件的相对路径当做参数传递给流的构造方法
18
        //true如果不写,则默认是覆盖模式,每次写入内容,都会覆盖原有内容
19
        //如果写true,就是追加模式,不会覆盖原有内容
20
        FileOutputStream fos = new FileOutputStream("./test.txt",true);
21
        //2.开始向test.txt
22
        //向文件写出一个字节 参数单位是int
23
        //一个整数4个字节 传的是给定的int值的最后一个字节
24
        //00000000 00000000 00000000 00000001
25
        fos.write(1);//00000001
26
        fos.write(97);
27
        fos.write(98);
28
        fos.write(99);
29
        fos.write(13);//回车
30
        fos.write(10);//换行
31
        //输出byte数组 \r\n 是回车换行
32
        fos.write("Hello EveryBody\r\n".getBytes());
33
        //输出byte数组的一部分,输出BCD,1表示ABCDE中的下标1处的元素(B),3表示输出后面的3个字节
34
        fos.write("ABCDE".getBytes(),1,3);
35
        System.out.println("输出完成");
36
        //3.关闭流(释放资源)
37
        fos.close();
38
    }
39
}

1
package io;
2
​
3
import java.io.File;
4
import java.io.FileInputStream;
5
import java.io.FileNotFoundException;
6
import java.io.IOException;
7
​
8
/**
9
 * FIS FileInputStream 文件字节输入流
10
 */
11
public class FISDemo {
12
    public static void main(String[] args) throws IOException {
13
        FileInputStream fis = new FileInputStream("./test.txt");
14
        //使用read方法每次读取文件中的一个字节
15
        //System.out.println((char)fis.read());
16
        //....
17
        //read方法读取不到内容时,会返回-1
18
        //System.out.println(fis.read());
19
        //System.out.println(fis.read());
20
        //while一般用于循环次数不确定  for一般用于利用循环次数
21
        int data;
22
        //循环条件是判断读取的字节是否是-1,并且把读取到的字节整数赋值给data,便于输出
23
        while ((data = fis.read())!=-1){//不等于-1说明能读到东西
24
            System.out.print((char)data);
25
        }
26
        //关闭流
27
        fis.close();
28
    }
29
}

1
package io;
2
​
3
import java.io.*;
4
​
5
/**
6
 * @author 老安
7
 * @data 2022/6/14 21:31
8
 * 使用缓冲流实现高效率文件复制
9
 */
10
public class CopyDemo3 {
11
    public static void main(String[] args) throws IOException {
12
        FileInputStream fis = new FileInputStream("./aaa.jpg");
13
        BufferedInputStream bis = new BufferedInputStream(fis);
14
        FileOutputStream fos = new FileOutputStream("./ddd.jpg");
15
        BufferedOutputStream bos = new BufferedOutputStream(fos);
16
        //此案例还是用单字节读取,之前读取很慢,现在用高级流测试
17
        int d;
18
        long start = System.currentTimeMillis();
19
        while ((d = bis.read())!=-1){//使用缓冲流读取字节
20
            bos.write(d);//使用缓冲流写入字节
21
        }
22
        long end = System.currentTimeMillis();
23
        System.out.println("耗时:"+(end-start)+"ms");
24
        //关闭流 如果使用了高级流,就只需要关闭高级流就可以了,会自动关闭所连接的低级流
25
        bis.close();
26
        bos.close();
27
    }
28
}

1
package io;
2
​
3
import java.io.BufferedOutputStream;
4
import java.io.FileOutputStream;
5
import java.io.IOException;
6
import java.nio.charset.StandardCharsets;
7
​
8
/**
9
 * @author 老安
10
 * @data 2022/6/14 21:55
11
 * 缓冲流写出数据的缓冲区问题
12
 */
13
public class BOS_flushDemo {
14
    public static void main(String[] args) throws IOException {
15
        FileOutputStream fos = new FileOutputStream("./bos.txt");
16
        BufferedOutputStream bos = new BufferedOutputStream(fos);
17
        bos.write("你是我的眼~~~~~~".getBytes(StandardCharsets.UTF_8));
18
        //如果不调用close方法,执行完毕,bos.txt没有内容
19
        //bos.flush();
20
        bos.close();
21
    }
22
}

1
package io;
2
​
3
import java.io.Serializable;
4
import java.util.Arrays;
5
​
6
/**
7
 * @author 老安
8
 * @data 2022/6/16 19:50
9
 * 使用当前类测试对象流的序列化和反序列化操作
10
 * 对象序列化:将一个java对象按照其结构转换为一组字节的过程
11
 * 序列化一个对象时,底层会为当前的Person生成一个版本号serialVersionUID
12
 * 在读取对象,会先比对被序列化对象的版本号,和还原的对象类型的版本是否一致,
13
 * 不一致,会抛出异常
14
 * 如何解决?
15
 * 开启兼容模式:自己指定一个版本号
16
 *  static final long serialVersionUID = 1L;
17
 */
18
public class Person implements Serializable {
19
    //控制死当前类的版本号是1,将来如何改当前类的内容,版本号都不会发生改变
20
    static final long serialVersionUID = 1L;
21
    private String name;//姓名
22
    //transient 当一个属性被transient修饰时,序列化时,就会忽略这个属性的值
23
    //transient 转瞬即逝的,短暂的
24
    private transient int age;//年龄
25
    private String gender;//性别
26
    private transient String[] otherInfo;//其他信息
27
    //private int salary;//薪资
28
    //全参构造
29
    //alt+insert/右键 Generate-->Constructor crtl+A全选属性
30
    public Person(String name, int age, String gender, String[] otherInfo) {
31
        this.name = name;
32
        this.age = age;
33
        this.gender = gender;
34
        this.otherInfo = otherInfo;
35
    }
36
    //get和set方法
37
    //alt+insert/右键 Generate-->getter and setter crtl+A全选属性
38
    public String getName() {
39
        return name;
40
    }
41
    public void setName(String name) {
42
        this.name = name;
43
    }
44
    public int getAge() {
45
        return age;
46
    }
47
    public void setAge(int age) {
48
        this.age = age;
49
    }
50
    public String getGender() {
51
        return gender;
52
    }
53
    public void setGender(String gender) {
54
        this.gender = gender;
55
    }
56
    public String[] getOtherInfo() {
57
        return otherInfo;
58
    }
59
    public void setOtherInfo(String[] otherInfo) {
60
        this.otherInfo = otherInfo;
61
    }
62
    //toString
63
    //alt+insert/右键 Generate-->toString()
64
    @Override
65
    public String toString() {
66
        return "Person{" +
67
                "name='" + name + '\'' +
68
                ", age=" + age +
69
                ", gender='" + gender + '\'' +
70
                ", otherInfo=" + Arrays.toString(otherInfo) +
71
                '}';
72
    }
73
}

1
package io;
2
​
3
import java.io.FileNotFoundException;
4
import java.io.FileOutputStream;
5
import java.io.IOException;
6
import java.io.ObjectOutputStream;
7
​
8
/**
9
 * @author 老安
10
 * @data 2022/6/16 20:05
11
 * 对象流
12
 * java.io.ObjectOutputStream 对象输出流 序列化流
13
 * java.io.ObjectInputStream 对象输入流 反序列化流
14
 * 对象流是一对高级流,在流链接中完成对象与字节的转换,
15
 * 学会了使用这组流,就可以轻松读取任何的java对象
16
 */
17
public class OOSDemo {
18
    public static void main(String[] args) throws IOException {
19
        String name = "康荐文";
20
        int age = 18;
21
        String gender = "男";
22
        String[] otherInfo = {"单身的","帅气的","网络鉴黄师","多金"};
23
        Person p = new Person(name, age, gender, otherInfo);
24
        System.out.println(p);
25
        //将p对象序列化到person.obj文件中
26
        //创建一个文件输出流,绑定文件
27
        FileOutputStream fos = new FileOutputStream("./person.obj");
28
        //创建一个对象输出流,连接fos低级流
29
        ObjectOutputStream oos = new ObjectOutputStream(fos);
30
        /*
31
        * writeObject(Object obj)
32
        * 对象输出流独有的方法:该方法会将对象转换为字节,并将字节通过
33
        * 所连接的流写出
34
        * */
35
        oos.writeObject(p);
36
        System.out.println("写出完毕!");
37
        //关闭流资源
38
        oos.close();
39
        /*
40
        * java.io.NotSerializableException 执行这个程序时,出现此异常,
41
        * 一定要检查序列化的类,是否实现了一个Serializable接口
42
        * */
43
    }
44
}

1
package io;
2
​
3
import java.io.FileInputStream;
4
import java.io.FileNotFoundException;
5
import java.io.IOException;
6
import java.io.ObjectInputStream;
7
​
8
/**
9
 * @author 老安
10
 * @data 2022/6/16 20:27
11
 * 使用对象输入流进行对象的反序列化
12
 */
13
public class OISDemo {
14
    public static void main(String[] args) throws IOException, ClassNotFoundException {
15
        FileInputStream fis = new FileInputStream("./person.obj");
16
        //创建一个对象输入流,连接fis低级流
17
        ObjectInputStream ois = new ObjectInputStream(fis);
18
        /*
19
        * Object readObject() 可以将文件中的字节读取出来,并且转换为java对象
20
        * 这个方法的返回值是Object,一般都需要强转为实际类型
21
        * */
22
        Person p = (Person) ois.readObject();
23
        System.out.println(p);
24
        ois.close();
25
    }
26
}

1
package io;
2
​
3
import java.io.FileNotFoundException;
4
import java.io.FileOutputStream;
5
import java.io.IOException;
6
import java.io.OutputStreamWriter;
7
import java.nio.charset.StandardCharsets;
8
​
9
/**
10
 * @author 老安
11
 * @data 2022/6/16 21:22
12
 * java IO 将流按照读写的单位分为字节流和字符流
13
 * java.io.InputStream和OutputStream 是所有字节输入流和输出流的超类,
14
 * 读写的最小单位是字节
15
 * 而java.io.Reader和Writer 是所有字符输入流和输出流的超类,
16
 * 读写的最小单位是字符
17
 * 转换流:是一对常用字符流实现类:(写代码不常用,但是流链接很重要)
18
 * java.io.InputStreamReader
19
 * java.io.OutputStreamWriter
20
 * 作用:
21
 * 1:在流链接中衔接其他的高级字符流和下面的字节流(这也是转换流名字的由来)
22
 * 2:负责将字符与对应的字节按照指定的字符集自动转换方便读写操作
23
 */
24
public class OSWDemo {
25
    public static void main(String[] args) throws IOException {
26
        //向osw.txt写入文本数据
27
        //创建一个低级的字节流
28
        FileOutputStream fos = new FileOutputStream("./osw.txt");
29
        //String line = "super idol的笑容都没你的甜~~~";
30
        //fos.write(line.getBytes(StandardCharsets.UTF_8));
31
        //创建一个字符流(转换流),连接低级的字节流fos
32
        //通常都需要指定字符集编码
33
        OutputStreamWriter osw = new OutputStreamWriter(fos,StandardCharsets.UTF_8);
34
        osw.write("super idol的笑容都没你的甜~~~");
35
        osw.write("八月正午的阳光都没你耀眼");
36
        osw.write("天天向上");
37
        osw.close();
38
    }
39
}

1
package io;
2
​
3
import java.io.FileInputStream;
4
import java.io.FileNotFoundException;
5
import java.io.IOException;
6
import java.io.InputStreamReader;
7
​
8
/**
9
 * @author 老安
10
 * @data 2022/6/16 21:43
11
 * 使用转换流测试读取文本数据
12
 */
13
public class ISRDemo {
14
    public static void main(String[] args) throws IOException {
15
        //将osw.txt中所有内容读取出来,并输出到控制台
16
        FileInputStream fis = new FileInputStream("./osw.txt");
17
        //创建一个字符转换流,连接fis低级输入流
18
        InputStreamReader isr = new InputStreamReader(fis);
19
        //读取一个字符,返回的int值内容本质上是一个char
20
        //但是如果返回的是-1,表示读取到了末尾
21
        //int d = isr.read();
22
        //System.out.println((char)d);
23
        int d;
24
        while ((d = isr.read())!=-1){
25
            System.out.print((char)d);
26
        }
27
        isr.close();
28
    }
29
}

1
package io;
2
​
3
import java.io.FileNotFoundException;
4
import java.io.PrintWriter;
5
import java.io.UnsupportedEncodingException;
6
import java.nio.charset.StandardCharsets;
7
​
8
/**
9
 * 缓冲字符流
10
 * java.io.BufferedWriter和BufferedReader
11
 * 缓冲字符流内部维护了一个数组,可以块读写文本数据进行读写性能的提升
12
 *
13
 * java.io.PrintWriter 具有自动行刷新功能的缓冲字符输出流,内部总是连接着BufferedWriter
14
 * 实际开发中,缓冲输出字符流我们就用这个PW
15
 * 特点:
16
 * 1:可以按行写字符串
17
 * 2:可以自动行刷新
18
 * 3:可以提高读写字符的效率
19
 */
20
public class PWDemo {
21
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
22
        //向文件pw.txt中写入文本数据
23
        //此处可以指定编码,但是StandardCharset还没有发现,所以需要字符串指定编码
24
        PrintWriter pw = new PrintWriter("./pw.txt", "UTF-8");
25
        //print 不带换行 println 自带换行
26
        pw.println("该配合你演出的我视而不见");
27
        pw.println("阿巴阿巴阿巴阿巴阿巴阿巴");
28
        System.out.println("写出完毕");
29
        pw.close();
30
    }
31
}

1
package io;
2
​
3
import java.io.*;
4
import java.nio.charset.StandardCharsets;
5
import java.util.Scanner;
6
​
7
public class PWDemo2 {
8
    public static void main(String[] args) throws FileNotFoundException {
9
        //文件字节输出流(是一个低级流),向文件中写出数据
10
        FileOutputStream fos = new FileOutputStream("pw2.txt",true);
11
        //转换输出流(是一个高级流),1:衔接字符与字节 2:将写出的字符转换字节
12
        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
13
        //缓冲输出字符流(是一个高级流) 块写文本数据加速
14
        BufferedWriter bw = new BufferedWriter(osw);
15
        //具有自动行刷新功能的缓冲字符输出流
16
        //当值设置为true时,表示打开了自动行刷新,每次调用println方法时,会自动调用flush一次
17
        PrintWriter pw = new PrintWriter(bw,true);
18
        Scanner scanner = new Scanner(System.in);
19
        while (true){
20
            String line = scanner.nextLine();
21
            if ("exit".equalsIgnoreCase(line)){
22
                break;
23
            }
24
            pw.println(line);
25
        }
26
        pw.close();
27
    }
28
}