Java基础--IO流04（IO流中的其他流，编码）

操作对象的流

ObjectOutputStream

1. 被操作的对象需要实现Serializable（标记接口），该类可以将Java对象的基本数据类型和图形写入OutputStream，可以使用ObjectInputStream读取对象，通过在流中使用文件可以实现对象的持久存储；
2. 构造函数：ObjectOutputStream(OutputStream out)；
3. 常用方法：
   write×××(×××　obj)；
   ×××：基本数据类型或Object；
4. 注意：
   write(int val)与writeInt(int val)的区别：前者仅读一个int的最低8位，后者写入一个32位的int值；

ObjectInputStream

ObjectInputStream对以前使用ObjectOutputStream写入的基本数据和对象进行反序列化；
1. 构造函数：
ObjectInpuStream(InputStream in)
2. 常用方法：
××× read×××();×××基本数据类型或Object；
3. 注意：static修饰的成员变量不能被序列化；
4. transient关键字；对于非static修饰的成员如果不想被序列化可用该关键字修饰；

import java.io.*;
class ObjectStreamDemo {
    public static void main(String[] args) throws Exception{
        //writeObj();
        readObj();
    }
    public static void readObj()throws Exception{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
        Person p = (Person)ois.readObject();
        System.out.println(p);
        ois.close();
    }
    public static void writeObj()throws IOException{
        ObjectOutputStream oos = 
            new ObjectOutputStream(new FileOutputStream("obj.txt"));
        oos.writeObject(new Person("lisi0",399,"kr"));
        oos.close();
    }
}

import java.io.*;
class Person implements Serializable{
    public static final long serialVersionUID = 42L;//自定义序列号ID
    private String name;
    transient int age;//非静态成员如果不想被序列化，可以用关键字transient修饰；
    static String country = "cn";//静态成员不能被序列化。
    Person(String name,int age,String country){
        this.name = name;
        this.age = age;
        this.country = country;
    }
    public String toString(){
        return name+":"+age+":"+country;
    }
}

管道流

输入输出可以之间进行连接，通过结合线程使用；

PipedOutputStream

1. 构造函数：
   
   • PipedOutputStream()；可以将PipedOutputStream连接到PipedInputStream来创建通信管道。PipedOutputStream作为发送端；
   • PipedOutputStream(PipedInputStream snk)；参数中需传入一个管道输入流；
   • 若是空参数的构造函数则需要通过connect()方法来获取一个管道输入流，用法：
     connect(PipedInputStream snk);

PipedInputStream

1. 概述：管道输入流应连接到管道输出流，管道输入流提供要写入管道输出流的所有数据字节，通常数据由某个线程从PipedInpuStream对象读取，并由其他线程将其写入到相应的PipedOutputStream，若为单线程容易死锁线程；
2. 构造函数：
   
   • PipedInpuStream(PipedOutputStream src)；构造函数无参可用connect(PipedOutputStream src)使此管道输入流连接到管道输出流

import java.io.*;
class Read implements Runnable{
    private PipedInputStream in;
    Read(PipedInputStream in){
        this.in = in;
    }
    public void run(){
        try{
            byte[] buf = new byte[1024];
            System.out.println("读取前。。没有数据阻塞");
            int len = in.read(buf);
            System.out.println("读到数据。。阻塞结束");
            String s= new String(buf,0,len);
            System.out.println(s);
            in.close();
        }catch (IOException e){
            throw new RuntimeException("管道读取流失败");
        }
    }
}
class Write implements Runnable{
    private PipedOutputStream out;
    Write(PipedOutputStream out){
        this.out = out;
    }
    public void run(){
        try{
            System.out.println("开始写入数据，等待6秒后。");
            Thread.sleep(6000);
            out.write("piped lai la".getBytes());
            out.close();
        }catch (Exception e){
            throw new RuntimeException("管道输出流失败");
        }
    }
}
class  PipedStreamDemo{
    public static void main(String[] args) throws IOException{
        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
        in.connect(out);
        Read r = new Read(in);
        Write w = new Write(out);
        new Thread(r).start();
        new Thread(w).start();
    }
}

---

RandomAccessFile

1. 随机访问文件，自身具备读写的方法；
   通过skipBytes(int x);seek(int x);来达到随机访问；
   此类的实例支持对随机访问文件的读取和写入；

2. 特点：

   • 该类不算是IO体系中的子类而是直接继承Object；但他是IO包中的成员，因为它具备读和写的功能，内部封装了一个数组，而且通过指针对数组的元素进行操作，可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置；
   • 其实完成读写的原理就是内部封装了字节输入流和输出流，通过构造函数可以看出，该类只能操作文件，而且操作文件还有模式：只读(r)；读写(rw)等；
   • 如果模式为只读r，不会创建文件，会去读取一个已存在文件，如果该文件不存在，则会出现异常；
   • 如果模式为只读rw，操作的文件不存在，会自动创建，如果存在则不会覆盖；

3. 构造方法：

   • RandomAccessFile(File file，String mode)；
   • RandomAccessFile(String name，String mode)；
     file-指定文件；
     name-系统文件名；
     mode-访问模式；

4. 该类常用方法：

   • gerFilePointer()；返回此文件的当前偏移量；
   • length()；返回此文件的长度；
   • read()；该功能与InputStream一样；
   • read×××；×××-基本数据类型；
   • readLine()；读一行；
   • seek(long pos)；设置指针偏移量；
   • setLength(long newLength)；设置文件长度；
   • write(byte[] b)/(byte[] b,int off,int len)/(int b)该方法与OutputStream方法一样；
   • write×××(××× ~)；×××基本数据类型；
   • skipBytes(int n)；跳过指定的字节数；

注：该类的常用方式：通过seek()偏移指针，结合多线程实现分段数据同时读写，实际应用：迅雷下载；

class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException{
        //writeFile_2();
        //readFile();
        //System.out.println(Integer.toBinaryString(258));
    }
    public static void readFile()throws IOException{
        RandomAccessFile raf = new RandomAccessFile("ran.txt","r"); 
        //调整对象中指针。
        //raf.seek(8*1);
        //跳过指定的字节数
        raf.skipBytes(8);
        byte[] buf = new byte[4];
        raf.read(buf);
        String name = new String(buf);
        int age = raf.readInt();
        System.out.println("name="+name);
        System.out.println("age="+age);
        raf.close();
    }
    public static void writeFile_2()throws IOException{
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        raf.seek(8*0);
        raf.write("周期".getBytes());
        raf.writeInt(103);
        raf.close();
    }
    public static void writeFile()throws IOException{
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        raf.write("李四".getBytes());
        raf.writeInt(97);
        raf.write("王五".getBytes());
        raf.writeInt(99);
        raf.close();
    }
}

---

操作基本数据类型流

DataInputStream

1. 构造函数：
   
   • DataInputStream(InputStream in)使用指定的底层输入流，创建一个DataInputStream；
2. 常用方法：
   
   • read(byte[] b)/(byte[] b,int off,int len)
   • read×××();×××基本数据类型；
   • skipBytes(int n)；
   • readUTF();读取一个有UTF-8修改版格式编码的字符串；
   • readUTF(DataInput in)；从in中读取由writeUTF写入的数据；

DataOutputStream

1. 构造方法：
   
   • DataOutputStream(OutputStream out)；创建一个新的数据输出流，将数据写入指定基础输出流；
2. 常用方法：
   
   • write(byte[] b,int off,int len)；
   • write(int b);
   • write×××(×××~);×××-基本数据类型；
   • writeChars(String s)；将字符串按字符顺序写入基础输出流；
   • flush()；
   • size()；返回到目前为止写入此数据输出流的字节数；
   • writeUTF(String str);以与机器无关方式使UTF-8修改版编码将一个字符串写入基础输出流。

注：writeUTF();写的数据，只能用readUTF()方法读；
注：写入的不同的类型的数据时，读取也要按该顺序读取，否则会出现乱码，因为不同的数据类型的长度不同；

import java.io.*;
class DataStreamDemo {
    public static void main(String[] args) throws IOException{
        //writeData();
        //readData();
        //writeUTFDemo();
//      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//      osw.write("你好");
//      osw.close();
//      readUTFDemo();
    }
    public static void readUTFDemo()throws IOException{
        DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));
        String s = dis.readUTF();
        System.out.println(s);
        dis.close();
    }
    public static void writeUTFDemo()throws IOException{
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));
        dos.writeUTF("你好");
        dos.close();
    }
    public static void readData()throws IOException{
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        int num = dis.readInt();
        boolean b = dis.readBoolean();
        double d = dis.readDouble();
        System.out.println("num="+num);
        System.out.println("b="+b);
        System.out.println("d="+d);
        dis.close();
    }
    public static void writeData()throws IOException{
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        dos.writeInt(234);
        dos.writeBoolean(true);
        dos.writeDouble(9887.543);
        dos.close();
        ObjectOutputStream oos = null;
        oos.writeObject(new O());   
    }
}

---

操作字节数组

ByteArrayInputStream

1. 构造函数：
   
   • ByteArrayInputStream(byte[] buf);
   • ByteArrayInputStream(byte[] buf,int offset,int length);创建ByteArrayInputStream，使用buf作为其缓冲区数组；
2. 常用方法：
   
   • available()；返回可从输入流读取的剩余字节数；
   • read()；
   • read(byte[] b,int off,int len);

ByteArrayOutputStream

1. 构造函数：
   
   • ByteArrayOutputStream()；创建一个新的byte数组输出流；
   • ByteArrayOutputStream(int size)；创建一个新的byte数组输出流，它具有指定大小的缓冲区容量(内部封装缓冲数组);
2. 常用方法：
   
   • size()；返回缓冲区的当前大小；
   • toByteArray()；创建一个新分配的byte数组；
   • toString()；使用平台默认字符集，将缓冲区内容转换为字符串；
   • write(int b);
   • write(byte[] b,int off,int len);
   • writeTo(OutputStream out);将此byte数组输出流的全部内容写入到指定的输出流参数中；

import java.io.*;
class ByteArrayStream {
    public static void main(String[] args) {
        //数据源。
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());
        //数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int by = 0;
        while((by=bis.read())!=-1){
            bos.write(by);
        }
        System.out.println(bos.size());
        System.out.println(bos.toString());
    //  bos.writeTo(new FileOutputStream("a.txt"));
    }
}

---

操作字符数组

如果操作的数据都是字符则使用字符数组的流；该流使用方式与操作字节数组一样；

CharArrayReader

1. 构造函数：
   
   • CharArrayReader(char[] buf)；
   • CharArrayReader(char[] buf,int offset,int length);
2. 常用方法：
   
   • read();读取单个字符；
   • read(char[] b,int off,int len);将字符读入数组的某一部分；

CharArrayWriter

1. 构造函数：
   
   • CharArrayWriter()；创建一个新的CharArrayWriter；
   • CharArrayWriter(int initialSize);创建一个指定大小的CharArrayWriter；
2. 常用方法：
   
   • append(char c);将指定字符添加到此writer；
   • flush();刷新流到缓冲区；
   • size();返回缓冲区的当前大小；
   • toCharArray()；返回输入数据的副本；
   • toString()；将输入数据转换为你字符串；
   • write(char[] c,int off,int len)；将字符写入缓冲区；
   • write(int c);将一个字符写入缓冲区；
   • write(String str,int off,int len);将字符串某一部分写入缓冲区；
   • writeTo(Write out);将缓冲区的内容写入另一个字符流；

---

操作字符串

StringReader

1. 构造函数：
   
   • StringReader(String s);其源为一个字符串的字符流，创建一个新字符串，reader；
2. 常用方法：
   
   • read();读取单个字符；
   • read(char[] cbuf,int off,int len)；将字符读入数组的某一个部分；

StringWrite

1. 构造函数：

   • StringWrite()；使用默认初始化字符串缓冲区大小创建一个新的字符串writer；
   • StringWrite(int initialSize);使用指定初始字符串缓冲区大小创建一个新字符串 writer；

2. 常用方法：

   • append(char c)/(CharSequence csq)；将指定字符(或字符序列)添加到此 writer
   • flush();刷新该流的缓冲；
   • getBuffer()；返回该字符串缓冲区本身；
   • toString()；以字符串的形式返回该缓冲区的当前值；
   • write(char[] cbuf,int off,int len)；写入字符数组的某一部分；
   • write(int c);写入单个字符；
   • write(String str);写入一个字符串；
   • write(String str,int off,int len);写入字符串的某一部分；

编码表

1. 可以指定编码的流：转换流，打印流；
2. 最常用：
   
   • InputStreamReader
   • OutputStreamWriter
3. 只能打印，不能读取：
   
   • PrintStream
   • PrintWriter

常见编码表

1. ASCII：美国标准信息交换码，用一个字节的7位可以表示；
2. ISO8859-1：拉丁码表，欧洲码表，用一个字节的8位表示；
3. GB2312：中文编码表；
4. GBK：中文编码表升级；
5. Unicode：国际标准码；
6. UTF-8：最多三个字节表示一个字符；

编码

字符串变成字符数组
String——byte[]：str.getBytes(String charsetName)；字符串String方法；charsetName-指定编码表的字符串名称；

解码

byte[]——String：new String(byte[],charsetName);
注：如果中文字符串用“GBK”编码，用“ISO8859-1”解码，会出现乱码（因为不识别），将解码后的乱码再用“ISO8859-1”编码回去，则与“GBK”编码相同（因为不识别，编码未被改变，再用“GBK”解码，则结果为原中文字符串，如果该字符用“UTF-8”去解码，再编码，则编码将发生变化与原“GBK”编码不同，用“GBK”去解码时，结果不是原中文字符串，因为“UTF-8”页识别中文，用“UTF-8”解码再编码后，将按照“UTF-8”编码表中的字符对原解出的乱码进行编码，则结果发生变化，所以只有不识别中文的编码表才能进行解码再编码后，结果不变）；

import java.util.*;
class  EncodeDemo{
    public static void main(String[] args)throws Exception {
        String s = "哈哈";
        byte[] b1 = s.getBytes("GBK");
        System.out.println(Arrays.toString(b1));
        String s1 = new String(b1,"utf-8");
        System.out.println("s1="+s1);
        //对s1进行iso8859-1编码。
        byte[] b2 = s1.getBytes("utf-8");
        System.out.println(Arrays.toString(b2));
        String s2 = new String(b2,"gbk");
        System.out.println("s2="+s2);
    }
}


import java.io.*;
class EncodeStream {
    public static void main(String[] args) throws IOException {
            //writeText();
            readText();
    }
    public static void readText()throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"gbk");
        char[] buf = new char[10];
        int len = isr.read(buf);
        String str = new String(buf,0,len);
        System.out.println(str);
        isr.close();
    }
    public static void writeText()throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");
        osw.write("你好");
        osw.close();
    }
}