java-流处理


java常用文件处理方法。

File

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

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));
    }
}
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

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));
    }
}
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。

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。

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。

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。

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的对象输出到文件中。

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的对象读回来。

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。

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();
        }
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 流处理

    流处理比起之前的批处理而言,需要考虑的东西更多。批处理有个前提,那就是输入必定是固定的大小,而流处理处理的数据是不会暂停的,与线上服务需要处理的数据也不一样,线...

    哒呵呵
  • [第十七周]批处理和流处理

    大数据是收集、整理、处理大容量数据集,并从中获得见解所需的非传统战略和技术的总称。虽然处理数据所需的计算能力或存储容量早已超过一台计算机的上限,但这种计算类型的...

    OrekiShiko
  • Java 8——函数式数据处理(流)

    本篇内容大部分来自《Java 8实战》 流是什么? 流是Java API的新成员,它允许你以声明性方式处理数据集合(通过查询语句来表达,而不是临时写一个实现)...

    我没有三颗心脏
  • MR处理流程

    参考文章: 1、http://zheming.wang/blog/2015/05/19/3AFF5BE8-593C-4F76-A72A-6A40FB140D4...

    YG
  • Django处理流程

    用户通过浏览器发送请求 请求到达request中间件,中间件对request请求做预处理或者直接返回response 若未返回response,会...

    人生不如戏
  • Python流处理Python

    它被用于Robinhood去构建高性能的分布式系统和实时数据通道,每天处理数十亿的数据。

    py3study
  • 统一批处理流处理——Flink批流一体实现原理

    实现批处理的技术许许多多,从各种关系型数据库的sql处理,到大数据领域的MapReduce,Hive,Spark等等。这些都是处理有限数据流的经典方式。而Fli...

    用户6070864
  • 统一批处理流处理——Flink批流一体实现原理

    无限流处理:输入数据没有尽头;数据处理从当前或者过去的某一个时间 点开始,持续不停地进行

    实时计算
  • 其他流---对象处理流

    该流做的是对象持久化处理 java.io.Serializable 空接口,向jvm声明,实现了这个接口的对象即可被存储到文件中 transient(译:...

    shimeath

扫码关注云+社区

领取腾讯云代金券