美文网首页
Java 3: IO Stream

Java 3: IO Stream

作者: 老柯南 | 来源:发表于2019-03-31 11:48 被阅读0次
    image.png

    IO Stream 核心方法

    InputStream类
    read():int
    read(byte[]) :int
    read(byte[],int,int):int
    
    OutputStream类
    write(int):void //写入int(32位 4个字节)的低8位,其他24个字节将被忽略
    write(byte[]):void
    write(byte[],int,int):void
    
    Reader类
    read(Charbuffer):int
    read():int
    read(char[]):int
    read(char[],int,int):int
    
    Writer类
    wirte(int):void //写入一个character( int 32位,但是char 16位 ,2个字节)的低16位,高16位将被忽略
    wirte(char[]):void
    wirte(char[],int ,int):void
    write(String):void
    write(String,int,int):void
    

    FileInputStream
    FileOutputStream

    DataInputStream
    DataOutputStream
    DataXXX 是InputStream,OutputStream的包装类,基于InputStream,OutputStream提供了很多操作数据的方法,比如操作int,string等;

    BufferedInputStream
    BufferedOutputStream

    字节流

    1: 单一字节读取 ;
    2:批量读取(自定义数组大小);
    3:使用Buffered,BufferedInputStream中。原理是:先单字节读取到buffer中,在从buffer中转移到目标位置;
    BufferedInputStream 中使用buffer减少访问磁盘的次数,达到提升性能;
    其中批量读取最高效;

     public synchronized int read() throws IOException {
            if (pos >= count) {
                fill();
                if (pos >= count)
                    return -1;
            }
            return getBufIfOpen()[pos++] & 0xff;
        }
    
     /**
         * Fills the buffer with more data, taking into account
         * shuffling and other tricks for dealing with marks.
         * Assumes that it is being called by a synchronized method.
         * This method also assumes that all data has already been read in,
         * hence pos > count.
         */
        private void fill() throws IOException {
            byte[] buffer = getBufIfOpen();
            if (markpos < 0)
                pos = 0;            /* no mark: throw away the buffer */
            else if (pos >= buffer.length)  /* no room left in buffer */
                if (markpos > 0) {  /* can throw away early part of the buffer */
                    int sz = pos - markpos;
                    System.arraycopy(buffer, markpos, buffer, 0, sz);
                    pos = sz;
                    markpos = 0;
                } else if (buffer.length >= marklimit) {
                    markpos = -1;   /* buffer got too big, invalidate mark */
                    pos = 0;        /* drop buffer contents */
                } else if (buffer.length >= MAX_BUFFER_SIZE) {
                    throw new OutOfMemoryError("Required array size too large");
                } else {            /* grow buffer */
                    int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
                            pos * 2 : MAX_BUFFER_SIZE;
                    if (nsz > marklimit)
                        nsz = marklimit;
                    byte nbuf[] = new byte[nsz];
                    System.arraycopy(buffer, 0, nbuf, 0, pos);
                    if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                        // Can't replace buf if there was an async close.
                        // Note: This would need to be changed if fill()
                        // is ever made accessible to multiple threads.
                        // But for now, the only way CAS can fail is via close.
                        // assert buf == null;
                        throw new IOException("Stream closed");
                    }
                    buffer = nbuf;
                }
            count = pos;
            int n = getInIfOpen().read(buffer, pos, buffer.length - pos); // 这里是真正读内容的地方
            if (n > 0)
                count = n + pos;
        }
    

    字符流

    1:编码问题
    2:文本,文本文件
    文本:Java的文本(char)是16位无符号整数,是字符的unicode编码(双字节编码 2字节 16位);
    文件: byte byte byte ... 的数据序列
    文本文件:文本文件是文本(char)按照某种编码方案(utf-8,utf-16be,gbk)序列号为byte的存储结果;
    3:字符流(Reader,Writer)
    字符的处理,一次处理一个字符
    字符的底层基本的字节序列;

    InputStreamReader / OutputStreamWriter

    InputStreamReader OutputStreamWriter是字符流和字节流的桥梁,提供需要解析编码时的转换;
    InputStreamReader:实现输入的字节流(byte)解析为字符流(char),按照编码解析; OutputStreamWriter:实现输出的字符流(char)解析为字节流(byte),按照编码解析;

    FileReader / FileWriter

    BufferedReader / BufferedWriter,PrinterWriter

    序列化

    1:对象序列化:是将Object 转换为byte序列,反之叫对象的反序列化;
    2:序列化流 ObjectOutputStream,ObjectInputStream. 关键反复writerObject,readObject;
    3:序列化需要实现序列化接口(Serializable)

    序列化 - transient 关键字

    加了transient 关键字 ,那么该元素不会进行jvm默认的序列化;

    ArrayList 中的 transient 序列化

    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
       
        /**
         * The array buffer into which the elements of the ArrayList are stored.
         * The capacity of the ArrayList is the length of this array buffer. Any
         * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
         * will be expanded to DEFAULT_CAPACITY when the first element is added.
         */
        transient Object[] elementData; // non-private to simplify nested class access
    }
    

    ArrayList 中的 对 标有transient关键字的元素进行序列化

     /**
         * Save the state of the <tt>ArrayList</tt> instance to a stream (that
         * is, serialize it).
         *
         * @serialData The length of the array backing the <tt>ArrayList</tt>
         *             instance is emitted (int), followed by all of its elements
         *             (each an <tt>Object</tt>) in the proper order.
         */
        private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{
            // Write out element count, and any hidden stuff
            int expectedModCount = modCount;
            s.defaultWriteObject(); //1: 第一步使用默认的序列化
    
            // Write out size as capacity for behavioural compatibility with clone()
            s.writeInt(size);
    
            // Write out all elements in the proper order.
            for (int i=0; i<size; i++) {
                s.writeObject(elementData[i]); //第二步 只序列化有用的元素
            }
    
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
        }
    
     /**
         * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
         * deserialize it).
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            elementData = EMPTY_ELEMENTDATA;
    
            // Read in size, and any hidden stuff
            s.defaultReadObject(); //1: 第一步 使用默认的序列化
    
            // Read in capacity
            s.readInt(); // ignored
    
            if (size > 0) {
                // be like clone(), allocate array based upon size not capacity
                ensureCapacityInternal(size);
    
                Object[] a = elementData;
                // Read in all elements in the proper order.
                for (int i=0; i<size; i++) {
                    a[i] = s.readObject();  //2:第二部 只序列化有用的元素
                } 
            }
        }
    

    序列化父子类

    1:父类实现了序列化接口,子类也能实现序列化;
    2:子类需要实现序列化,只需要子类实现序列化接口,父类不一定要实现序列化接口
    3:对子类对象进行反序列化操作时,如果父类没有实现序列化接口,那么其父类的构造函数会被显示的调用;如果父类实现了序列化接口,反序列化可以直接读取到构造中的内容,无需显示调用;

    相关文章

      网友评论

          本文标题:Java 3: IO Stream

          本文链接:https://www.haomeiwen.com/subject/qaprbqtx.html