Java 常用工具类--输入输出流

• 输出流

  
  image.png

• 输入流

  
  image.png

File类

• File类常用方法

package com.alan.file;

import java.io.File;
import java.io.IOException;
public class FileDemo {
    public static void main(String[] args) {

        // 方式1:创建File对象（即可以创建文件，也可以创建目录）
        //File file1 = new File("/Users/alan/eclipse-workspace/ThreadFileProj/io/hello.txt");
        // 方式2:创建File对象（即可以创建文件，也可以创建目录）
        //File file1 = new File("/Users/alan/eclipse-workspace/ThreadFileProj","io/hello.txt");
        // 方式3:创建File对象（即可以创建文件，也可以创建目录）
        File file = new File("/Users/alan/eclipse-workspace/ThreadFileProj/io");
        File file1 =  new File(file,"hello.txt");
        //判断是文件还是目录
        System.out.println("是否是目录："+file1.isDirectory());
        System.out.println("是否是文件："+file1.isFile());
        //创建目录
        File file2 = new File("/Users/alan/eclipse-workspace/ThreadFileProj","HashSet");
        if(!file2.exists()) {
            file2.mkdirs();
        }
        //创建文件
        if(!file1.exists()) {
            try {
                file1.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

---

字节流

• 字节输入流 InputStream
• 字节输出流 OutputStream

FileInputStream

• 从文件系统中的某个文件中或者输入字节

• 用于读取诸如图像数据之类的原始字节流（如果是字符类型一般使用字符流）

  
  image.png
• 案例1

package com.alan.file;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputDemo1 {

    public static void main(String[] args) {
        // 读取本项目根目录的test.txt文件
        File file = new File("test.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            int n;
            // n为-1时，读取的末尾
            while ((n = fis.read()) != -1) {
                System.out.print((char) n);
            }
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

• 案例2

package com.alan.file;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputDemo2 {

    public static void main(String[] args) {
        // 读取本项目根目录的test.txt文件
        File file = new File("test.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            //通过byte数组进行读操作
            byte[] b = new byte[200];
            fis.read(b);
            System.out.print(new String(b));
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

---

FileOutputStream

• 案例

package com.alan.file;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputDemo2 {

    public static void main(String[] args) {
        // 文件拷贝
        try {
            // FileInputStream实例化，为原文件
            FileInputStream fis = new FileInputStream("12345.jpg");
            // FileOutputStream实例化，为拷贝的新文件
            FileOutputStream fos = new FileOutputStream("12345copy.jpg");
            int n = 0;
            // 定义大小为1kb的数组
            byte[] b = new byte[1024];
            // 通过FileInputStream将文件读取，并保存在byte数组b中
            // 通过FileOutputStream写文件，实现拷贝。
            // n代表实际读取到的字节的个数。用另一个write方法实现，保证拷贝后的文件大小与之前的一致
            while ((n = fis.read(b)) != -1) {
                // fos.write(b);
                fos.write(b, 0, n);
            }
            fis.close();
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

---

缓冲流

• 缓冲输入流 BufferedInputStream
• 缓冲输出流 BufferedOutputStream
• 使用缓冲流，可以提高读写速度。需要与文件输入输出流配合使用。

flush() 当缓冲区不满的时候，需要使用此方法强制输出

• 案例

package com.alan.file;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedDemo {

    public static void main(String[] args) {

        try {
            // 缓冲输出流实例化，将文件输出流的对象赋值给缓冲输出流的构造函数
            FileOutputStream fos = new FileOutputStream("test.txt");
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            // 缓冲输入流实例化，将文件输入流的对象赋值给缓冲输出流的构造函数
            FileInputStream fis = new FileInputStream("test.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            bos.write(50);
            bos.write('a');
            // 清空缓冲区，将数据写入，如果不调用flush方法，最后用close方法也可以达到效果，但一般还是将flush方法写上。
            bos.flush();
            System.out.println(bis.read());
            System.out.println((char)bis.read());
            fos.close();
            bos.close();
            fis.close();
            bis.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

---

字符流

• 字符输入流Reader
• 字符输出流Writer

字节字符转换流

• InputStreamReader 其中InputStream是字节输入流的父类 Reader是字符输入流的父类
• OutputStreamWriter 其中OutputStream是字节输出流的父类 Writer是字符输出流的父类
• 案例

package com.alan.charstream;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("test.txt");
            InputStreamReader isr = new InputStreamReader(fis);
            BufferedReader br = new BufferedReader(isr);
            FileOutputStream fos = new FileOutputStream("test1.txt");
            OutputStreamWriter osw = new OutputStreamWriter(fos);
            BufferedWriter bw = new BufferedWriter(osw);
            //方式1
            int n = 0;
//          while((n = isr.read())!= -1) {
//              System.out.print((char)n);
//          }
            //方式2
            char[] cbuf = new char[10];
            while((n = br.read(cbuf))!= -1) {
                bw.write(cbuf, 0, n);
                bw.flush();
            }
            fis.close();
            isr.close();
            fos.close();
            osw.close();
            br.close();
            bw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

---

对象序列化

1、创建一个类，实现Serializable接口
2、创建对象
3、将对象写入文件
4、从文件读取对象信息

• 对象输入流ObjectInputStream
• 对象输出流ObjectOutputStream
• Goods类

package com.alan.serial;

import java.io.Serializable;

public class Goods implements Serializable {
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    //属性：商品编号、商品名称、商品价格
    private String goodsId;
    private String goodsName;
    private double price;
    
    
    //带参构造
    public Goods(String goodsId, String goodsName, double price) {
        this.goodsId = goodsId;
        this.goodsName = goodsName;
        this.price = price;
    }
    
    
    public String getId() {
        return goodsId;
    }
    public void setId(String goodsId) {
        this.goodsId = goodsId;
    }
    public String getName() {
        return goodsName;
    }
    public void setName(String goodsName) {
        this.goodsName = goodsName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }


    @Override
    public String toString() {
        return "商品编号:" + goodsId + ", 商品名称:" + goodsName + ", 商品价格:" + price;
    }

}

• 测试类

package com.alan.serial;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class GoodsTest {

    public static void main(String[] args) {
        // 定义Goods类的对象
        Goods goods1 = new Goods("gd001","电脑",3000);
        try {
            //写文件
            FileOutputStream fos = new FileOutputStream("test.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            //读文件
            FileInputStream fis = new FileInputStream("test.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            oos.writeObject(goods1);
            oos.flush();
            //读到对象存放
            Goods goods = (Goods)ois.readObject();
            System.out.println(goods);
            fis.close();
            ois.close();
            oos.close();
            fos.close();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

---