Java IO初学

javaIO编程

IO体系

avatar

File

常用方法	解释
mkdir	创建单个目录
mkdirs	创建多个目录
getPath	获取文件的路径
length	获取文件的长度
getName	获取文件名字
getParentFile	获取文件的上一层目录
exists	判断文件是否存在
createNewFile	创建文件
list	返回一个字符串数组命名目录中的文件和目录
listFiles	返回一个抽象路径名数组表示用此抽象路径名表示的目录中的文件
getAbsolutePath	返回此抽象路径名的绝对路径名字符串

文件的创建

单文件创建

@Test
    //文件的创建
    public void IoFilePractise() throws IOException {
        File file = new File("D:\\file\\1.txt");
        //判断file目录是否存在
        if (!file.getParentFile().exists()) {
            System.out.println("D:\\file目录不存在,立刻创建该目录");
            file.getParentFile().mkdir();
        }
        //判断1.txt文件是否存在
        if (!file.exists()) {
            System.out.println("1.txt文件不存在，立刻创建该文件");
            file.createNewFile();
        }
    }

多层级文件创建

@Test
    public void IoFilePractise3() throws IOException {
        File file=new File("D:\\file\\B\\B1\\B2\\rose.txt");
        //创建多个层级目录
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        //创建rose.txt文件
        if(!file.exists()){
            file.createNewFile();
        }
    }

文件的删除

删除指定的目录和文件，值得注意的是，如果只是删除指定的目录，目录中还有其他文件或者目录的话，是没办法删除成功的

@Test
    public void IoFilePractise1() throws IOException {
        File file = new File("D:\\file\\A\\jack.txt");
        //在上一个例子的基础上，创建A目录和jack.txt文件
        file.getParentFile().mkdir();
        file.createNewFile();
        //尝试直接删除A目录
        file.getParentFile().delete();
        //判断是否删除A目录成功
        if (file.getParentFile().exists()) {
            System.out.println("A目录没有被删除");
        } else {
            System.out.println("删除A目录成功");
        }
    }

@Test
    //根据上面的为基础
    public void IoFilePractise2() {
        File file = new File("D:\\file\\A\\jack.txt");
        file.delete();
        file.getParentFile().delete();
        //判断是否删除A目录成功
        if (file.getParentFile().exists()) {
            System.out.println("A目录没有被删除");
        } else {
            System.out.println("删除A目录成功");
        }
    }

输出文件目录

统计D盘下面所有的文件的个数并且输出名字，找出所有的txt文件并且输出和统计个数

    private static int fileNumber = 0;
    private static int txtFileNumber = 0;
    private static int directoryNumber = 0;

    @Test
    public void IoFilePractise4() {
        String filePath = "D:\\";
        findFile(filePath);
        System.out.println("文件数：" + fileNumber);
        System.out.println("其中txt文件数：" + txtFileNumber);
        System.out.println("文件目录数：" + directoryNumber);
    }

    public void findFile(String filePath) {
        File file = new File(filePath);
        //遍历该路径下面的所有文件和目录
        File[] listFile = file.listFiles();
        //如果文件目录下面没有文件递归停止
        if(listFile==null)return;
        //递归遍历
        for (File fileTemp : listFile) {
            //如果是文件
            if (fileTemp.isFile()) {
                fileNumber++;
                System.out.println(fileTemp.getName() + "为文件");
                if (fileTemp.getName().endsWith(".txt")) {
                    txtFileNumber++;
                    System.out.println(fileTemp.getName() + "同时为txt文件");
                }
            } else if (fileTemp.isDirectory()) {
                directoryNumber++;
                System.out.println(fileTemp.getName() + "为文件目录");
                findFile(fileTemp.getPath());
            }
        }
    }

IO基本大类

子类的多数方法是继承自父类，将父类的方法了解清楚，子类的使用也会迎刃而解

InputStream 类

方法	方法介绍
public abstract int read()	读取数据
public int read(byte b[])	将读取到的数据放在 byte 数组中
public int read(byte b[], int off, int len)	从第 off 位置读取 len 长度字节的数据放到 byte 数组中
public void close()	读取完，关闭流，释放资源

OutputStream 类

方法	方法介绍
public abstract void write(int b)	写入一个字节
public void write(byte b[])	将数组中的所有字节写入
public void write(byte b[], int off, int len)	将 byte 数组从 off 位置开始，len 长度的字节写入
public void close()	关闭输出流，流被关闭后就不能再输出数据了

Reader 类

方法	方法介绍
public int read()	读取单个字符
public int read(char cbuf[])	读取字符到指定的 char 数组中
abstract public int read(char cbuf[], int off, int len)	从 off 位置读取 len 长度的字符到 char 数组中
abstract public void close()	关闭流释放相关资源

Writer 类

方法	方法介绍
public void write(int c)	写入一个字符
public void write(char cbuf[])	写入一个字符数组
abstract public void write(char cbuf[], int off, int len)	从字符数组的 off 位置写入 len 数量的字符
abstract public void close()	关闭输出流，流被关闭后就不能再输出数据了

FileInputStream和FileOutputStream

一个字节一个字节的读取

@Test
    public void FileRead() throws IOException {
        int count=0;//读取次数
        FileInputStream fis = new FileInputStream("D:\\file\\1.txt");
        int len;
        //一个字节一个字节的读取，读完返回-1
        while ((len = fis.read()) != -1) {
            System.out.print((char)len);
            count++;
        }
        System.out.println("读取次数:"+count);
        fis.close();
    }

一次多个字节的读取

@Test
    public void FileRead() throws IOException {
        int count=0;//读取次数
        FileInputStream fis = new FileInputStream("D:\\file\\1.txt");
        byte[] n=new byte[1024];
        int len;
        //一个字节一个字节的读取，读完返回-1
        while ((len = fis.read(n)) != -1) {
            //new String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String
            System.out.println(new String(n,0,len));
            count++;
        }
        System.out.println("读取次数:"+count);
        fis.close();
    }

文件写入

 @Test
    public void FileWrite() throws IOException {
        //追加写入
        FileOutputStream fos=new FileOutputStream("D:\\file\\1.txt",true);
        //写入单个字节
        fos.write(98);
        //写入多个字节
        fos.write(",Hello World!".getBytes());
        fos.close();
    }

文件拷贝

 @Test
    //1.txt的数据写入到2.txt
    public void FileCopy() throws IOException {
        //没有1.txt和2.txt文件需要提前创建
        FileOutputStream fos=new FileOutputStream("D:\\file\\2.txt");
        FileInputStream fis=new FileInputStream("D:\\file\\1.txt");
        int len;
        byte[] n=new byte[1024];
        while((len=fis.read(n))!=-1){
            fos.write(n,0,len);
        }
        fos.close();
        fis.close();
    }

BuffereInputStream和BuffereOutputStream

缓冲流拷贝

@Test
    public void FileBuffer() throws IOException {
        //里面需要有FileInputStream和FileOutStream的对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\file\\1.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\file\\2.txt"));
        int len;
        while((len = bis.read()) != -1){
            bos.write(len);
        }
        bos.close();
        bis.close();
    }

InputStreamReader和OutputStreamWriter

带有中文的拷贝

  @Test
    public void FileStream() throws IOException {
        //补充：一个字符在GBK编码下占2个字节，即16位，在UTF-8编码下占三个字节，即24位
        InputStreamReader isr=new InputStreamReader(new FileInputStream("D:\\file\\1.txt"),"GBK");
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("D:\\file\\2.txt"),"GBK");
        int len;
        char[] n=new char[1014];
        while((len= isr.read(n))!=-1){
            System.out.println(new String(n,0,len));
            osw.write(n,0,len);
        }
        isr.close();
        osw.close();
    }

ObjectInputStream和ObjectOutputStream

ObjectOutputStream实际是在对流进行序列化操作，ObjectInputStream实际是在对流进行反序列化操作，要实现序列化，必须实现Serializable接口，否则是无法进行序列化和反序列化的，如果对象中的属性加了transient和static关键字的话，则该属性不会被序列化。

写入和读取对象

import java.io.Serializable;

public class Book implements Serializable {
    private String id;
    private String name;
    private int money;
    private transient int weight;

    @Override
    public String toString() {
        return "Book{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", money=" + money +
                ", weight=" + weight +
                '}';
    }

    public Book(String id, String name, int money, int weight) {
        this.id = id;
        this.name = name;
        this.money = money;
        this.weight = weight;
    }
   ----- getter and setter-----
}

 @Test
    public void ObjectTest() throws IOException, ClassNotFoundException {
        //先写入对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\file\\1.txt", true));
        oos.writeInt(99);
        oos.writeObject(new Book("001", "我的中国梦", 100,45));
        oos.close();
        //再读取对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\file\\1.txt"));
        int readInt = ois.readInt();
        Book book = (Book) ois.readObject();
        System.out.println(readInt);
        System.out.println(book);
        ois.close();
    }

结尾

作为java初学者，把IO了解到这个地步也就差不多了，后面可以根据兴趣或者项目实际需要不断的进行学习。我本人也 是一个java菜鸟，还在上学，java基础很差，写博客也主要是抱着学习的心态，如果上面有写的不对的地方希望能够指出。