Fork me on GitHub

java-流处理

发表于 | 分类于 | 热度 ℃  |  
字数统计 1,382 字 | 阅读时长 7 分钟

java常用文件处理方法。

File

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.io.File;
//获取一个路径下的所有目录和文件
public class FileDemo {
    public static void main(String[] args) {
        File file = new File("C:\\");
        if(file.isDirectory()) {
            String[] names = file.list();
            for (int i = 0; i < names.length; i++) {
                System.out.println(names[i]);
            }
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                System.out.println(files[i].getAbsolutePath());
            }
        } else {
            System.out.println("不是一个文件夹");
        }
    }
}

字节流

主要学两个类：FileInputStream和FileOutputStream

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
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        byte[] content = null;
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            content = new byte[fis.available()];
            fis.read(content);
            fis.close();
            System.out.println("读取完成");
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("读取失败");
            e.printStackTrace();
        }
        System.out.println(new String(content));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        String str = "写入这个";
        try {
            FileOutputStream fos = new FileOutputStream(file,false); //默认flase表示覆盖文件原有内容；true表示接在文件的最后写入
            fos.write(str.getBytes());
            fos.close();
            System.out.println("写入成功");
        } catch (FileNotFoundException e) {
            System.out.println("文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("写入失败");
            e.printStackTrace();
        }
    }
}

字符流

不同于字节流：

例如要写入整数10到文件中，字节流会把数字10的ASCII码写进去，而字符流是以字符1和0写入。

主要学两个类：FileReader和FileWriter

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
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        char[] content = null;
        try {
            FileReader fr = new FileReader(file);
            content = new char[512];
            fr.read(content);
            fr.close();
            System.out.println("读取成功");
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("读取失败");
            e.printStackTrace();
        }
        System.out.println(new String(content));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        try {
            FileWriter fw = new FileWriter(file);
            fw.write("FileWriter");
            fw.close(); //别忘关，不然东西都在缓冲区里，也可用fw.flush()
            System.out.println("写入成功");
        } catch (IOException e) {
            System.out.println("写入失败");
            e.printStackTrace();
        }
    }
}

缓冲流

BufferedReader类：创建对象时，不能直接用File对象做参数，得用Reader。

可以这样做，先用文件名创建出一个FileReader，再把FileReader作为参数传给BufferedReader。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.io.*;
public class BufferedReaderDemo {
    public static void main(String[] args) {
        File file = new File("test.txt");
        FileReader fr = null;
        try {
            fr = new FileReader(file);
            BufferedReader br = new BufferedReader(fr);
            String str = br.readLine();
            while(str != null) {
                System.out.println(str);
                str = br.readLine();
            }
            br.close();
            fr.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

如果用System.in从控制台读入数据,由于读入的是字节流，而BufferedReader只接受字符流，怎么办呢？

可以用InputStreamReader，将字节流转换为字符流，再传给BufferedReader。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class BufferedReaderDemo2 {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            String str = br.readLine();
            while(str != null) {
                System.out.println(str);
                str = br.readLine();
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedWriter类和BufferedReader类一样，都不能直接用File对象做参数，所以要先建一个FileWriter。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterDemo {
    public static void main(String[] args) {
        String[] strings = {"first","second","third"};
        File file = new File("test.txt");
        FileWriter fw = null;
        try {
            fw = new FileWriter(file);
            BufferedWriter bw = new BufferedWriter(fw);
            for (int i = 0; i < strings.length; i++) {
                bw.write(strings[i]);
                bw.write("\n");
            }
            bw.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象流

对象的序列化：把对象转换为字节序列。

对象的反序列化：把字节序列转换为对象。

主要学两个类：ObjectInputStream和ObjectOutputStream（不能直接用File对象做参数）。

先建一个类，叫做Person。注意，要实现序列化和反序列化，这个类必须implements Serializable接口，这是一个标记接口（即一个方法都没有），所以不必Override。

1
2
3
4
5
6
7
8
9
10
11
import java.io.Serializable;
public class Person implements Serializable{
    private static final long serialVersionUID = 1L;
    String name;
    transient int age;
    @Override
    public String toString() {
        return "Person[姓名="+name+",年龄="+age+"]";
    }
}

把Person的对象输出到文件中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.io.*;
public class ObjectOutputStreamDemo {
    public static void main(String[] args) {
        File file = new File("person.txt");
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            Person person = new Person();
            person.name = "Luson";
            person.age = 20;
            oos.writeObject(person);
            oos.close();
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

从文件中再把Person的对象读回来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.io.*;
public class ObjectInputStreamDemo {
    public static void main(String[] args) {
        File file = new File("person.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person person = (Person)ois.readObject();
            System.out.println(person);
            ois.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

注意到Person类中age的类型前有一个transient，这表明该变量是不参与序列化的，而且不管你怎么修改它的值，从文件里读回来（即反序列化）的时候，它的值永远是0或null。

此外，如果类中还有static类型的变量，那么也不会参与序列化，但是它的值却是可以更改的。

数据流

可以读取和写入java的标准数据类型。

主要学两个类：DataInputStream和DataOutputStream，分别要求传入InputStream和OutputStream。

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
41
42
43
import java.io.*;
public class DataStreamDemo {
    public static void main(String[] args) {
        Person[] persons = new Person[]{new Person("Kate",18),
                new Person("Tom",18),new Person("Lucy",19)};
        File file = new File("persons.txt");
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            DataOutputStream dos = new DataOutputStream(fos);
            for (int i = 0; i < persons.length; i++) {
                dos.writeUTF(persons[i].name);
                dos.writeChar('\t');
                dos.writeInt(persons[i].age);
            }
            dos.close();
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            DataInputStream dis = new DataInputStream(fis);
            for (int i = 0; i < persons.length; i++) {
                String str = dis.readUTF();
                char ch = dis.readChar();
                int age = dis.readInt();
                System.out.println(str+ch+age);
            }
            dis.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
donate the author