JAVA中的那些流 你知道么

字节输出流

FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(file file) 创建一个向指定file对象中写入数据的输出文件流
作用：
1.创建一个FileOutputStream对象
2.会根据构造方法中传递的文件文件路径 创建一个空的文件
3.会把FileOutputStream对象指定向创建好的文件
使用：
1.创建一个FileOutputStream对象，写入目的地
2.调用FileOutputStream对象中的方法，写入数据
3.释放资源

close() 关闭输出流释放资源
flush() 刷新内容
write(byte[] b) 把字节数组写入输出流
write(byt[] b,int off,int len) 从指定的字节数组邪恶如len字节，从偏移量off开始输出到此输出流
write(int b) 将指定的字节输出流

import java.io.FileOutputStream;
import java.io.IOException;

public class DemoFileOutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\Program Files\jichu\src\file\a.txt");
        fos.write(97);
        fos.close();
    }
}

package file;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class DuoFileOutputStream {
    public static void main(String[] args) throws IOException {

        FileOutputStream fos = new FileOutputStream("D:\Program Files\jichu\src\file\b.txt");
        // 字节数组
        byte[] bytes = {66,67,68,69,70};
        fos.write(bytes);

        // 字节数组 分割
        byte[] bytes1 = {65,66,67,68,69,70};
        // 从索引2开始 ，写为五个字节
        fos.write(bytes1,2,2);

        // 中文字符写入
        byte[] bytes2 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes2)); //[-28, -67, -96, -27, -91, -67]
        fos.write(bytes2);

        fos.close();

    }
}

true : 追加写入
flase：覆盖重写

package file;

import java.io.FileOutputStream;
import java.io.IOException;

public class Huanhang {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\Program Files\jichu\src\file\c.txt",true);
        for (int i = 0; i <10 ; i++) {
            fos.write("你好".getBytes());
            fos.write("rn".getBytes());
        }
        fos.close();
    }
}

字节输入流

import java.io.FileInputStream;
import java.io.IOException;

public class DemoRead {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\Program Files\jichu\src\file\a.txt");
        int a = 0;
        while ((a = fis.read())!= -1){
            System.out.println((char)a);
        }
        fis.close();
    }
}

import java.io.FileInputStream;
import java.io.IOException;

public class Duoread {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\Program Files\jichu\src\file\a.txt");
        // 字符读取
        byte[] bytes = new byte[4];
        // 布尔表达式
        int len = 0;
        while ((len = fis.read(bytes))!=-1){
            System.out.println(new String(bytes));
        }
    }
}

数据源：c:\1.jpg
目的地：c:\2.jpg
   
创建字节输入流，读取图片
创建字节输出流，写入图片
字节输入流，读取文件
字节输出流，写入文件
关闭资源

package file;

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

public class CopyFile {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\2.jpg");
        // 第一种
        //int len = 0;
        //while ((len = fis.read())!=-1){
        //    fos.write(len);
        //}

        // 第二种
        byte[] bytes = new byte[1024];
        int a = 0;
        while ((a = fis.read(bytes))!=-1){
            fos.write(bytes,0,a);
        }

        fos.close();
        fis.close();
    }
}

GBK: 两个字节
UTF-8: 三个字节
字节流读取文件 中文字符 导致乱码 故引用字符输入流

字符输入流

字符出入流，是字符输入流的顶层父类，定义一些共性成员方法，一个抽象类
read() 读取单个字符并返回
read(char[] cbuf) 读取多个字符 并返回数组
close() 关闭资源

package file;

import java.io.FileReader;
import java.io.IOException;

public class ZiFuRead {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("D:\Program Files\jichu\src\file\c.txt");
        // 第一种方法 单个读取
//        int len = 0;
//        while ((len = fr.read())!= -1){
//            System.out.println((char)len);
//        }

        // 第二种方法 字符数组
        char[] chars = new char[4];
        int ch = 0;
        while ((ch = fr.read(chars))!=-1){
            System.out.println(new String(chars));
        }
        fr.close();
    }
}

字符输出流

write(int c) 写入单个字符
write(char[] char) 写入字符数组
write(char[] char,int off,int len) 写入字符某一部分，从索引n开始，写入n个字符
write(String str) 写入字符串
write(String str,int off,int len) 写入字符串某一部分，从索引n开始，写入n个字符
flush() 刷新缓冲
close() 关闭资源

package file;

import java.io.FileWriter;
import java.io.IOException;

public class DuoWrite {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\Program Files\jichu\src\file\d.txt");
        fw.write("abc");
        fw.write("你好");
        fw.write(97);
        char[] bytes = {96,97,99};
        fw.write(bytes);

        fw.flush();
        fw.close();
    }
}

package file;

import java.io.FileWriter;
import java.io.IOException;

public class HuanhangWriter {
    public static void main(String[] args) throws IOException {
        // true 追加写入
        // false 覆盖重写
        FileWriter fw = new FileWriter("D:\Program Files\jichu\src\file\f.txt",true);
        fw.write("test, 你好");
        fw.write("rn");
        fw.write("heihie");

        fw.close();
    }
}

属性集合

properties 表示一个持久性的属性集，可保存在流中或从流中加载
可以使用store 把集合中的临时数据 持久化写入到硬盘中
可以使用load ，把硬盘中保存的文件，读取到集合中使用
properties 是一个双列集合 key 和value 都是字符串 默认

setProperty(String key,String value) 写数据
getProperty(String key) 读数据 指定key 读value
stringPropertyNames() 返回此属性集列表中的键集，相当于map中的keyset方法

package file;

import java.util.Properties;
import java.util.Set;

public class DemoProperties {
    public static void main(String[] args) {
        // 创建属性集
        Properties p = new Properties();
        // 添加数据
        p.setProperty("张三","166");
        p.setProperty("李四","176");
        p.setProperty("王五","186");

        // 获取key 存储到集合里
        Set<String> s = p.stringPropertyNames();
        // 遍历集合 获取key值
        for (String key : s) {
            // 通过key 获取value
            String value = p.getProperty(key);
            System.out.println(key +"---"+ value);
        }
    }
}

package file;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class DemoProperties {
    public static void main(String[] args) throws IOException {
        // 创建属性集
        Properties p = new Properties();
        // 添加数据
        p.setProperty("张三","166");
        p.setProperty("李四","176");
        p.setProperty("王五","186");

        // 创建字符写入流
        FileWriter fw = new FileWriter("D:\Program Files\jichu\src\file\properties.txt");

        // 使用store写入数据到文件
        p.store(fw,"save data");

        // 关闭资源
        fw.close();

    }
}

package file;

import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class DemoProperties {
    public static void main(String[] args) throws IOException {
        // 创建属性集
        Properties p = new Properties();
        // 使用load 读取文件
        p.load(new FileReader("D:\Program Files\jichu\src\file\properties.txt"));

        // 获取key 存储set集合
        Set<String> set = p.stringPropertyNames();

        // 遍历数据
        for (String key : set) {
            String value = p.getProperty(key);
            System.out.println(key +"----"+value);
        }

    }
}

缓冲流

缓冲流 也叫高效流
字节缓冲流 BufferedInputStream BufferedOutputStream
字符缓冲流 BufferedReader BufferedWriter
缓冲流的基原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统ID次数，从而提高读写的效率。

BufferedInputStream() 创建一个新的缓冲输入流
BufferedOutputStream() 创建一个新的缓冲输出流

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoBufferedOutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fs = new FileOutputStream("D:\Program Files\jichu\src\file\e.txt");
        BufferedOutputStream bs = new BufferedOutputStream(fs);
        bs.write("你好".getBytes());
        bs.close();

    }
}

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DemoBufferedOutputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\program Files\jichu\src\file\e.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        int len = 0;
        while ((len = bis.read())!=-1){
            System.out.println(len);
        }
        bis.close();
    }
}

package file;

import java.io.*;

public class DemoBufferedOutputStream {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        // C:Users20185Desktop1.jpg
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\Users\20185\Desktop\1.jpg"));
        // C:Users20185Desktop2.jpg
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\Users\20185\Desktop\2.jpg"));
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
        long e = System.currentTimeMillis();
        System.out.println("共花费"+(e-s)+"毫秒");
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class DemoBufferedWirte {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\Program Files\jichu\src\file\g.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("你好");
        bw.newLine();
        bw.write("世界");
        bw.close();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class DemoBufferedWirte {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("D:\Program Files\jichu\src\file\g.txt"));
        // 获取内容 一行输出
//        String s = br.readLine();
//        System.out.println(s);
        // 定义一个空字符
        String len ="";
        // 当字符不为null 循环打印
        while ((len = br.readLine())!=null){
            System.out.println(len);
        }
        br.close();
    }
}

3.老虎没打到
4.打到小松鼠
2.上山打老虎
1.一二三四五

package file;

import java.io.*;
import java.util.HashMap;

public class DemoBufferedWirte {
    public static void main(String[] args) throws IOException {
        // 定义一个集合 存储键值
        HashMap<String,String> map = new HashMap<>();
        // 读文件
        BufferedReader br = new BufferedReader(new FileReader("D:\Program Files\jichu\src\file\g.txt"));
        // 写文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\Program Files\jichu\src\file\out.txt"));
        // 读行文字
        String line ="";
        while ((line = br.readLine())!=null){
            // . 分割内容 存储到集合里
            String[] array = line.split("\.");
            map.put(array[0],array[1]);
        }
        // 遍历集合 取key 和 value 重新组合
        for (String key : map.keySet()) {
            String vaule = map.get(key);
            line = key +"."+vaule;
            bw.write(line);
            bw.newLine();
        }
        bw.close();
        br.close();
    }
}


1.一二三四五
2.上山打老虎
3.老虎没打到
4.打到小松鼠

转换流

OutputStreamWrite()  写文件
InputStreatRead() 读文件

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class DemoOutputStreamWrite {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\Program Files\jichu\src\file\a.txt"),"gbk");
        osw.write("你好");
        osw.close();
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class DemoOutputStreamWrite {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr =new InputStreamReader(new FileInputStream("D:\Program Files\jichu\src\file\a.txt"),"gbk");
        int len = 0;
        while ((len = isr.read())!=-1){
            System.out.println((char)len);
        }
        isr.close();
    }

gbk 转 utf-8

import java.io.*;

public class DemoOutputStreamWrite {
    public static void main(String[] args) throws IOException {
        // gbk 格式读取文件
        InputStreamReader isr =new InputStreamReader(new FileInputStream("D:\Program Files\jichu\src\file\a.txt"),"gbk");
        // utf-8 格式 保存文件
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\Program Files\jichu\src\file\a1.txt"),"utf-8");
        // 读文件 二写入 utf-8的格式 
        int len = 0;
        while ((len = isr.read())!=-1){
            osw.write(len);
        }
        osw.close();
        isr.close();
    }

序列化流

ObjectOutputStream() 写文件
ObjectInputStream() 读文件

特有方法：
writeObject() 写文件
readObjet() 读文件

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class DemoObjectOutputStream {
    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\Program Files\jichu\src\file\a.txt"));
        oos.writeObject("test");
        oos.close();
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DemoObjectOutputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\Program Files\jichu\src\file\a.txt"));
        Object o = ois.readObject();
        System.out.println(o);
        ois.close();
    }
}

package file;

import java.io.Serializable;

public class Persin implements Serializable {
    private String name;
    private int age;

    public Persin(){}


    public Persin(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Persin{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}


package file;

import java.io.*;
import java.util.ArrayList;

public class DemoObjectOutputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ArrayList<Persin> list = new ArrayList<>();
        list.add(new Persin("张三",18));
        list.add(new Persin("李四",19));
        list.add(new Persin("王五",20));

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\Program Files\jichu\src\file\a.txt"));
        oos.writeObject(list);

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\Program Files\jichu\src\file\a.txt"));
        Object o = ois.readObject();

        ArrayList<Persin> list1 = (ArrayList<Persin>) o;
        for (Persin p : list1) {
            System.out.println(p);
        }
        ois.close();
        oos.close();
    }
}

打印流

PrintStream() 创建文件

import java.io.*;

public class DemoOutputStreamWrite {
    public static void main(String[] args) throws IOException {
        PrintStream ps = new PrintStream("D:\Program Files\jichu\src\file\a.txt");
        ps.println("aaa");
        ps.println(97);
        ps.print("test");

        ps.close();
    }
}

原文始发于微信公众号（轩公子谈技术）：JAVA中的那些流 你知道么