Java学习笔记Day21:流

缓冲流

BufferedOutputStream:字节缓冲输出流
java.io.BufferedOutputStream extends OutputStream

构造方法：
1. BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流
2. BufferedOutputStream(OutputStream out,int size）创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流

BufferedInputStream：字节输入流
java.io.BufferedInputStream extends InputStream

构造方法：
1. BufferedInputStream(InputStream in)
2. BufferedInputStream(InputStream in,int size）

关闭时只需要关闭缓冲流

//文件复制
public class CopyFile {
    public static void main(String[] args) throws IOException {
        long s=System.currentTimeMillis();
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("c:\\1.jpg"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("d:\\1.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)+"毫秒");
    }
}

BufferedWriter:字符缓冲输出流
java.io.BufferedWriter extends Writer

构造方法：
1. BufferedWriter(Writer out)
2. BufferedWriter(Writer out,int size)

特有的成员方法：
void newLine()写入一个行分隔符。会根据不同系统，获取不同的行分隔符

BufferedReader：字符缓冲输入流
java.io.BufferedReader extends Reader
构造方法：
1. BufferedReader(Reader in)
2. BufferedReader(Reader in,int size)

特有的成员方法：
String readLine()读取一个文本行

while((line=br.readLine())!=null){
    System.out.println(line);
}

//对文本内容进行排序
public class SortFile {
    public static void main(String[] args) throws IOException {
        HashMap<String,String> map=new HashMap<>();
        BufferedReader br=new BufferedReader(new FileReader("d:\\a.txt"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("e:\\a.txt"));
        String line;
        while((line=br.readLine())!=null){
            String[] arr=line.split("\\.");
            map.put(arr[0],arr[1]);
        }
        for(String str:map.keySet()){
            String value=map.get(str);
            line=str+"."+value;
            bw.write(line);
            bw.newLine();
        }
        bw.close();
        br.close();
    }
}

转换流

OutputStreamWriter: 是字符流通向字节流的桥梁，可使用指定的charset将要写入流中的字符编码成字节。
java.io.OutputStreamWriter extends Writer

构造方法：

• OutputStreamWriter(OutputStream out)创建使用默认字符编码，默认使用UTF-8

• OutputStreamWriter(OutputStream out,String
  charsetName)创建使用指定字符集的OutputStreamWriter

InputStreamReader: 是字节流通向字符流的桥梁
InputStreamReader extends Reader

构造方法：

• InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader

• InputStreamReader(InputStreamReader,String charsetName)

注意事项：
构造方法中指定的编码表名称要和文件的编码相同，否则会发生乱码

//转换文件编码
public class TransCode {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr=new InputStreamReader(new FileInputStream("d:\\a.txt"),"gbk");
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d:\\b.txt"));
        int len=0;
        while((len=isr.read())!=-1){
            osw.write(len);
        }
        osw.close();
        isr.close();
    }
}

序列化和反序列化

把对象以流的方式，写入到文件中保存，叫写对象，也叫对象的序列化
对象中包含的不仅仅是字符，使用字节流ObjectOutputStream:对象的序列化流
构造方法:ObjectOutputStream(OutputStream out)
特有成员方法：void writeObject(Object obj)
--------------------------------------------------------------------------------------------

把文件中保存的对象，以流的形式读取出来，叫做读对象，也叫作对象的反序列化
读取的文件保存的都是字节，使用字节流
ObjectInputStream:对象的反序列化流
构造方法：ObjectInputStream(InputStream in)
特有成员方法：readObject()方法声明抛出了classNotFoundException(class文件找不到异常)

序列化和反序列化的时候，会抛出NotSerializableException没有序列化异常
类通过实现java.io.Serializable接口以启用其序列化功能。（标记性接口）

transient关键字：瞬态关键字

被transient修饰的成员变量不能序列化

//序列化集合
public class Serial {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ArrayList<Person> list=new ArrayList<>();
        list.add(new Person("zhangsan",13));
        list.add(new Person("lisi",17));
        list.add(new Person("wangwu",14));
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("d:\\a.txt"));
        oos.writeObject(list);
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("d:\\t.txt"));
        Object o=ois.readObject();
        ArrayList<Person> list2=(ArrayList<Person>)o;
        for(Person p:list2){
            System.out.println(p);
        }
        ois.close();
        oos.close();
    }
}

打印流

PrintStream为其他输出流添加了功能，使他们能够方便地打印各种数据值表示形式
java.io.PrintStream:打印流
PrintStream的特点：
1. 只负责数据的输出，不负责数据的读取
2. 与其他输出流不同，PrintStream永远不会抛出IOException
3. 特有的方法，print,println

• void print(任意类型的值)

• void println(任意类型的值并换行)

构造方法：
PrintStream(File file)
PrintStream(OutputStream out)
PrintStream(String fileName)
PrintStream extends OutputStream

注意：
1. 如果使用继承自父类的write方法写数据，那么查看数据的时候会查询编码表
2. 如果使用自己特有的方法print/println方法写数据，写的数据会原样输出

可以改变输出语句的目的地（打印流的流向）
输出语句默认在控制台输出
使用System.setOut方法改变输出语句的目的地改为参数中传递的打印流的目的地
Static void setOut(PrintStream out)