学习JAVA.day10 文件I/O流_java .day文件

学习JAVA.day10 文件I/O流

文件的读写操作是编程过程中必不可少组成部分，下边总结近期学习到的几种常用的I/O流操作；根据操作对象的不同，I/O流可以分为字节流和字符流，其具体的实际意义与其字面含义一致；
1.基于字节流的I/O操作
FileInputStream ：从文件系统中的某个文件中获得输入字节；
FileOutputStream ：用于写入诸如图像数据之类的原始字节的流；
应用实例：

public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(
                "D:\\Users\\Chuqi-Yin\\IdeaProjects\\basic-code\\day01-code\\src\\cn\\itcast\\day17\\a.txt");
		//FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
		//FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
        fos.write(97);//分次写入
        fos.write(98);
        fos.write(99);
        byte[] buf = {100,101,102,103};//集合写入
        fos.write(buf);
        byte[] buf2 = {100,101,102,103,104,105,106,107};//指定集合写入
        fos.write(buf2,4,4);
        fos.close();//关闭流，资源释放
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

字节流在直接写入中文字符串时会出现乱码的现象，解决实例：

public class Demo02OutputStream {
    public static void main(String[] args) throws IOException{
        FileOutputStream fos = new FileOutputStream(
                "D:\\Users\\Chuqi-Yin\\IdeaProjects\\basic-code\\day01-code\\src\\cn\\itcast\\day17\\b.txt",true);

        fos.write("迪丽热巴".getBytes(StandardCharsets.UTF_8));
        fos.write("\r\n".getBytes(StandardCharsets.UTF_8));
        fos.write("古力娜扎".getBytes(StandardCharsets.UTF_8));
        fos.write("\r\n".getBytes(StandardCharsets.UTF_8));
        fos.write("巴尔扎哈".getBytes(StandardCharsets.UTF_8));

        fos.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.基于字符流的I/O操作
FileReader ：用于读取字符流；
FileWriter ：用于写入字符流；
应用实例：

public class Demo02FileWriter {
    public static void main(String[] args) throws IOException {
        File filename=new File(
                "D:\\Users\\Chuqi-Yin\\IdeaProjects\\basic-code\\day01-code\\src\\cn\\itcast\\day17\\b.txt");
        FileReader fRead = new FileReader(      //字符输入流
                "D:\\Users\\Chuqi-Yin\\IdeaProjects\\basic-code\\day01-code\\src\\cn\\itcast\\day17\\b.txt");
        char[] buff = new char[1024];
        int len;
        while((len=fRead.read(buff))!=-1){
            System.out.println(new String(buff,0,len));
        }
        fRead.close();

        System.out.println("===========继续写入===========");
        FileWriter fWriter = new FileWriter(filename,true);
        fWriter.write("\r\n");
        fWriter.write("迪丽热巴");
        fWriter.write("\r\n");
        fWriter.write("古力娜扎");
        fWriter.write("\r\n");
        fWriter.write("巴尔扎哈");

        fWriter.flush();
        fWriter.close();

        /*FileReader fRead2 = new FileReader(      //字符输入流
                "D:\\Users\\Chuqi-Yin\\IdeaProjects\\basic-code\\day01-code\\src\\cn\\itcast\\day17\\b.txt");
        char[] buff2 = new char[1024];
        int len2;
        while((len2=fRead2.read(buff2))!=-1){
            System.out.println(new String(buff2,0,len2));
        }
        fRead2.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
28
29
30
31
32
33
34
35

3.序列化/反序列化操作
ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
应用实例：
Person类

/*
序列化和反序列化过程中，类中的静态变量将不能被正常执行序列化和反序列化
原因：
静态变量的加载优先于非静态（对象），导致被static修饰的成员变量不能被序列化
transient 瞬态关键字 修斯的成员变量一样不能被序列化
*/

public class Person implements Serializable {  //Serializable 序列化标志
    //人为添加序列号
    private static final long serialVersionID=1L;
    private String name;

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

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

    public String getName() {
        return name;
    }

    public Person(String name) {
        this.name = name;
    }
}
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
28
29
30
31

主方法

public class Demo02ObjectOutputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(".\\ObjectSerializable.txt"));
        oos.writeObject(new Person("迪丽热巴"));
        oos.flush();
        oos.close();

        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(".\\ObjectSerializable.txt"));
        Object obj=ois.readObject();
        System.out.println(obj);

        Person per=(Person) obj;
        System.out.println(per.getName());
        ois.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.文件I/O小练习
背景：文本文件中存在乱序文本，如下图：

目标：根据每行文本前的标号进行从新排序
代码实现：

public class Demo01Buffered {
    public static void main(String[] args) throws IOException {
        HashMap<String,String> hMap=new HashMap<>();
        File filename = new File(
                "D:\\Users\\Chuqi-Yin\\IdeaProjects\\basic-code\\day01-code\\src\\cn\\itcast\\day19\\test.txt");
        File filename2 = new File(
                "D:\\Users\\Chuqi-Yin\\IdeaProjects\\basic-code\\day01-code\\src\\cn\\itcast\\day19\\output.txt");
        BufferedReader br=new BufferedReader(new FileReader(filename));
        BufferedWriter bw=new BufferedWriter(new FileWriter(filename2));
        String line;
        while((line=br.readLine())!=null){
            String[] arr = line.split("\\.");
            hMap.put(arr[0],arr[1]);
        }
        Set<String> keySet=hMap.keySet();
        List<String> listSet= new ArrayList<String>(keySet);
        listSet.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int a=0,b=0;
                try {
                    a = Integer.parseInt(o1);
                    b = Integer.parseInt(o2);
                } catch (NumberFormatException e) {
                    e.printStackTrace();
                }
                return a-b;
            }
        });
        for (String key:listSet
             ) {
            String value=hMap.get(key);
            line=key+"."+value;
            bw.write(line);
            bw.newLine();
        }
        br.close();
        bw.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
28
29
30
31
32
33
34
35
36
37
38
39
40

实现效果：