Java笔记(二十八)……IO流下 IO包中其他常用类以及编码表问题

PrintWriter打印流

Writer的子类，既可以接收字符流，也可以接收字节流，还可以接收文件名或者文件对象，非常方便

同时，还可以设置自动刷新以及保持原有格式写入各种文本类型的print方法

PrintWriter的小例子：打印字符录入的大写

//读取键盘录入，打印大写
private static void printWriterMethod() throws IOException
{
    BufferedReader bufr =
        new BufferedReader(new InputStreamReader(System.in));

    PrintWriter out = new PrintWriter(System.out,true);

    String line = null;

    while( (line = bufr.readLine()) != null)
    {
        if("over".equals(line))
            break;
        //只需一条语句，便可打印一行数据，非常方便
        out.println(line.toUpperCase());
    }

    out.close();
    bufr.close();
}

SequenceInputStream合并流

序列流，可将多个流合并成一个流，按序列进行读取

可手动指定各个流创建对象，也可将多个流存入集合，利用枚举Enumeration来创建对象

合并和分割流的小例子：

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

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

        int num = splitFile(new File("pic.jpg"));

        /*
        合并分割后的流
        */

        //定义Vector集合存储所有part文件的字节输入流
        Vector<FileInputStream> v = new Vector<FileInputStream>();

        for(int i = 1 ; i <= num ; i ++ )
        {
            v.add(new FileInputStream(i+".part"));
        }

        Enumeration<FileInputStream> en = v.elements();

        FileOutputStream fos = new FileOutputStream("pic1.jpg");

        //定义序列流，通过枚举合并所有的输入流
        SequenceInputStream sis = new SequenceInputStream(en);

        byte[] buf = new byte[1024];

        int len = -1;

        while( (len = sis.read(buf)) != -1)
        {
            //将合并后的流写入一个文件
            fos.write(buf,0,len);
        }

        fos.close();
        sis.close();
    }

    //分割流
    private static int splitFile(File f) throws IOException
    {
        FileInputStream fis = new FileInputStream(f);

        long size = f.length();

        byte[] buf = null;

        //选择缓冲区大小
        if(size > 1024*1024*5)
            buf = new byte[1024*1024];
        else
            buf = new byte[(int)size/5];

        int len = -1;
        int count = 1;

        while( (len = fis.read(buf)) != -1)
        {
            //每个缓冲区的内容分别写入不同的part文件
            FileOutputStream fos = new FileOutputStream((count++)+".part");
            fos.write(buf,0,len);
            fos.close();
        }

        fis.close();

        return count-1;
    }
}

对象的序列化

ObjectInputStream，ObjectOutputStream

将对象存取在硬盘上，叫做对象的持久化存储（存储的是对象的属性值，而不是方法）

想要对对象进行序列化，该对象必须实现Serializable接口，Serializable接口没有方法，称为标记接口，实现过程只是给实现者加入一个序列化的ID：ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L; 其实就是序列号，这个序列号是由变量的声明语句自动生成的，我们也可以自己定义类的序列号

对象序列化的小例子

import java.io.*;

class Person implements Serializable
{
    //序列号，保证类型一致
    static final long serialVersionUID = 42L;

    //静态变量以及transient修饰的变量不会被序列化
    static String country = "cn";
    transient int grade;
    private String name;
    private int age;

    Person(String name,int age,int grade,String country)
    {
        this.name = name;
        this.age = age;
        this.grade = grade;
        this.country = country;
    }

    public String toString()
    {
        return name+"::"+age+"::"+grade+"::"+country;
    }
}

class ObjectStreamDemo
{
    public static void main(String[] args) throws Exception
    {

        //writeObj();
        readObj();
    }

    //将对象写入流中
    private static void writeObj() throws IOException
    {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

        oos.writeObject(new Person("Shawn",30,3,"en"));
        oos.writeObject(new Person("feng",23,6,"usa"));

        oos.close();
    }

    //将对象从流中读出并打印
    private static void readObj() throws Exception
    {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

        Person p1 = (Person)ois.readObject();
        Person p2 = (Person)ois.readObject();

        System.out.println("p1 --- "+p1);
        System.out.println("p2 --- "+p2);

        ois.close();
    }
}

我们可以看到，静态变量和transient修饰的变量是不会被序列化到硬盘上的

管道流

PipedInputStream，PipedOutputStream

管道Demo，一个线程写，一个线程读

import java.io.*;

//读管道流线程
class Read implements Runnable
{
    private PipedInputStream pis;

    Read(PipedInputStream pis)
    {
        this.pis = pis;
    }

    public void run()
    {
        try
        {
            byte[] buf = new byte[1024];

            int len = -1;

            //阻塞方法，读不到数据会等待
            len = pis.read(buf);

            System.out.println(new String(buf,0,len));

            pis.close();
        }
        catch (IOException e)
        {
            System.out.println("pipe read error!");
        }

    }
}

//写管道流线程
class Write implements Runnable
{
    private PipedOutputStream pos;

    Write(PipedOutputStream pos)
    {
        this.pos = pos;
    }

    public void run()
    {
        try
        {
            pos.write("pipe is coming!".getBytes());

            pos.close();
        }
        catch (IOException e)
        {
            System.out.println("pipe write error!");
        }

    }
}

class PipedStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream();

        //链接读写管道
        pis.connect(pos);

        new Thread(new Read(pis)).start();

        new Thread(new Write(pos)).start();
    }
}

随机访问文件流

RandomAccessFile

直接继承Object类，内部封装了字节输入输出流，同时封装了文件的指针，可对基本数据类型进行直接读写，最大的好处是可以实现数据的分段写入，通过seek方法。

用随机访问实现的多线程复制文件(后期会改进代码，完成多线程下载)

import java.io.*;

//下载线程
class DownLoadThread implements Runnable
{
    private RandomAccessFile in;
    private RandomAccessFile out;
    private int offset;//偏移量
    private int buf_size;//分配数据量
    private int block_size;//缓冲区大小

    //初始化
    DownLoadThread(RandomAccessFile in,RandomAccessFile out,int offset,int buf_size)
    {
        this.in = in;
        this.out = out;
        this.offset = offset;
        this.buf_size = buf_size;

        block_size = 1024*512;
        if(buf_size < block_size)
            block_size = buf_size;

    }

    public void run()
    {
        try
        {
            System.out.println(Thread.currentThread().getName()+"开始下载...");

            //读写流都偏移到指定位置
            in.seek(offset);
            out.seek(offset);

            byte[] buf = new byte[block_size];

            int len = -1;

            int lastSize = buf_size;

            //读取信息并写入到目的地
            while( (len = in.read(buf)) != -1)
            {
                out.write(buf,0,len);

                lastSize -= len;

                //分配数据量完成，结束线程
                if(lastSize == 0)
                    break;
                if(lastSize < block_size)
                {
                    block_size = lastSize;
                    buf = new byte[block_size];
                }
            }

            System.out.println(Thread.currentThread().getName()+"下载完成！");

            in.close();
            out.close();

        }
        catch (IOException e)
        {
            throw new RuntimeException(e);
        }

    }
}

class MutiDownLoadDemo
{
    public static void main(String[] args) throws Exception
    {
        //确定源文件和目的文件
        File fin = new File("1.avi");
        File fout = new File("5.avi");


        multiDownload(fin,fout,12);


    }

    //多线程下载 thread_num为线程数
    private static void multiDownload(File fin,File fout,int thread_num) throws Exception
    {
        RandomAccessFile in = new RandomAccessFile(fin,"r");

        RandomAccessFile out = new RandomAccessFile(fout,"rwd");

        int len = (int)fin.length();

        //确定目的文件大小
        out.setLength(len);

        in.close();
        out.close();

        System.out.println("-----------File size : "+(len>>20)+" MB--------------");
        System.out.println("-----------Thread num: "+thread_num+"---------");

        //确定每个线程分配的数据量
        int buf_size = len/thread_num;

        System.out.println("-----------buffer size: "+(buf_size>>20)+" MB-----------");

        //开启每个线程
        for(int i = 0 ; i < thread_num ; i ++)
        {
            //"rwd"模式代表可读可写并且线程安全
            new Thread(
                new DownLoadThread(new RandomAccessFile(fin,"r"),new RandomAccessFile(fout,"rwd"),i*buf_size,buf_size)
                ).start();
        }
    }
}

基本数据类型流对象

DataInputStream，DataOutputStream

public static void main(String[] args) throws IOException
{
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

    dos.writeInt(123);

    dos.writeDouble(123.45);

    dos.writeBoolean(true);

    DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

    System.out.println(dis.readInt());
    System.out.println(dis.readDouble());
    System.out.println(dis.readBoolean());
}

内存作为源和目的的流对象

操作字节数组

ByteArrayInputStream与ByteArrayOutputStream

操作字符数组

CharArrayReader与CharArrayWrite

操作字符串

StringReader 与 StringWriter

字符编码

字符流出现是为了更方便的操作字符，通过InputStreamReader和OutputStreamWriter可以任意指定编码表进行解码转换

编码表

计算机开始只能识别二进制数据，为了更方便的表示各个国家的文字，就将各个国家的文字与二进制数据进行一一对应，形成了一张表，即为编码表

常见的编码表

ASCII：美国标准信息交换码。

用一个字节的7位可以表示。

ISO8859-1：拉丁码表。欧洲码表

用一个字节的8位表示。

GB2312：中国的中文编码表。

GBK：中国的中文编码表升级，融合了更多的中文文字符号。

Unicode：国际标准码，融合了多种文字。

所有文字都用两个字节来表示,Java语言使用的就是unicode

UTF-8：最多用三个字节来表示一个字符

......

编码规则

只有GBK和UTF-8识别中文，GBK向下兼容GB2312

GBK两个字节表示一个字符，UTF-8是1-3个字节表示一个字符，每个字节前面1-3位作为标识头

GBK和UTF-8都兼容ASCII码表

模拟编解码过程代码

public static void main(String[] args) throws Exception
{
    //字符串
    String s = "你好";

    //用UTF-8编码表编码s字符串
    byte[] b = s.getBytes("UTF-8");


    System.out.println(Arrays.toString(b));

    //用GBK编码表解码
    String s1 = new String(b,"GBK");

    //获取之后发现不是原来的字符串
    System.out.println(s1);

    //用GBK重新编码回去
    byte[] b1 = s1.getBytes("GBK");

    //再用UTF-8解码
    String s2 = new String(b1,"UTF-8");

    System.out.println(s2);


}

这样做存在一个问题，由于GBK与UTF-8都支持中文，所以UTF-8编解码时有可能会去内部的相似码表去查找，这样编码出来的字符就会与原字符不符，所以一般使用ISO8859-1与中文码表互相编解码转换

一个有趣的小例子

新建一个文本文档，写入“联通”两个字，保存，关闭，再打开，发现变成了一个奇怪的字符，这是为什么呢？

首先windows默认的是ANSI编码，而UTF-8编码的标识头规则如下图

由于记事本是由编码本身的规律判断选取哪个编码表的

所以答案是，“联通”这两个字由ANSI编码之后的码流符合UTF-8的规则，则记事本自动识别是UTF-8的字符，而去查了UTF-8的码表

解决方法，我们只要在联通前面加上任意字符，记事本就不会误判为UTF-8解码了