文档章节

Java基础:IO 流中的 flush

Airship
 Airship
发布于 2014/12/11 22:44
字数 3250
阅读 11
收藏 0

Java设计Io流可谓是煞费苦心,如果你是初学者我敢保证第一次接触Java的IO类,一定会“狂晕!!”,晕,倒不是因为它有多么难学,而是太多,而且及其让人容易迷惑。在编程日子中,尤其是在网络编程中,几乎离不开Java的IO,关于Java的IO流的分类,可以到网上soso,今天跟大家分享一下flush方法。

1.  OutputStream类的flush方法

该类实现了Flushable接口,所以重写了flush方法,看看flush()源码,会更加的让你明白:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_1 height=14 name=ZeroClipboardMovie_1 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=1&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. public void flush() throws IOException {  
  2. }  

 

sorry,该实现为空。就是一个空方法,什么也不做。看清楚啊,该方法不是抽象方法,是一个实实在在的方法。除了方法体中一无所有,其它还好!!!汗!!!看JDK的api如何解释!

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_2 height=14 name=ZeroClipboardMovie_2 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=2&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. flush  
  2. public void flush()  
  3.            throws IOException  
  4. 刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是:如果此输出流的实现已经缓冲了以前写入的任何字节,则调用此方法指示应将这些字节立即写入它们预期的目标。  
  5. 如果此流的预期目标是由基础操作系统提供的一个抽象(如一个文件),则刷新此流只能保证将以前写入到流的字节传递给操作系统进行写入,但不保证能将这些字节实际写入到物理设备(如磁盘驱动器)。  
  6. OutputStream 的 flush 方法不执行任何操作。  
  7. 指定者:  
  8. 接口 Flushable 中的 flush  
  9. 抛出:  
  10. IOException - 如果发生 I/O 错误。  

 

开始,我安慰自己,该类是一个抽象类,它的子类肯定重写了该方法。好吧,OutputStream的直接子类有:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_3 height=14 name=ZeroClipboardMovie_3 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=3&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. ByteArrayOutputStream  
  2. FileOutputStream   
  3. FilterOutputStream  
  4. ObjectOutputStream  
  5. OutputStream  
  6. PipedOutputStream  

 

注意:这里的子类OutputStream是包 org.omg.CORBA.portable 的。

对于FileOutputStream、ByteArrayOutputStream、org.omg.CORBA.portable.OutputStream类它们的flush()方法均是从父类继承的flush方法。

FilterOutputStream类重写了flush()方法,但是实质还是调用父类的flush方法。

ObjectOutputStream、PipedOutputStream类重写了flush()方法。

好吧,来两个个小例子,很简单,第一个例子主要是向文本中写入字符串,第二个例子向文本中写入一定字节的数据,如下代码:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_4 height=14 name=ZeroClipboardMovie_4 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=4&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. package mark.zhang;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.DataOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileOutputStream;  
  6. public class Test {  
  7.     public static void main(String[] args) throws Exception {  
  8.         File file = new File("text.txt");  
  9.         if(!file.exists()) {  
  10.             file.createNewFile();  
  11.         }  
  12.         FileOutputStream fos = new FileOutputStream(file);  
  13.         BufferedOutputStream bos = new BufferedOutputStream(fos);  
  14.         DataOutputStream dos = new DataOutputStream(fos);  
  15.         dos.writeBytes("java io");  
  16.     }  
  17. }  

 

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_5 height=14 name=ZeroClipboardMovie_5 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=5&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. package mark.zhang;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.File;  
  4. import java.io.FileOutputStream;  
  5. public class Test {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("text.txt");  
  8.         if(!file.exists()) {  
  9.             file.createNewFile();  
  10.         }  
  11.         FileOutputStream fos = new FileOutputStream(file);  
  12.         BufferedOutputStream bos = new BufferedOutputStream(fos);  
  13.         byte[] b = new byte[1024*8];  
  14.         bos.write(b);  
  15.         bos.flush();  
  16.     }  
  17. }  

 

这两段代执行后,分别会在当前目录下产生7字节的文件(内容为java io)和1KB字节的文件。说到这里,有些人会说,这有什么稀奇,至于吗???呵呵,别急,淡定!!现在修改第二个代码,主要是注释掉调用flush()方法,如下:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_6 height=14 name=ZeroClipboardMovie_6 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=6&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. package mark.zhang;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.File;  
  4. import java.io.FileOutputStream;  
  5. public class Test {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("text.txt");  
  8.         if(!file.exists()) {  
  9.             file.createNewFile();  
  10.         }  
  11.         FileOutputStream fos = new FileOutputStream(file);  
  12.         BufferedOutputStream bos = new BufferedOutputStream(fos);  
  13.         byte[] b = new byte[1024];  
  14.         bos.write(b);  
  15.         //bos.flush();  
  16.     }  
  17. }  

 

ok,再次运行代码,额的神啊???文件大小居然是o字节。why????flush()方法有那么神奇,汗??!!!

仔细的你会发现,第一个代码并没有调用flush()方法,居然可以。为什么第二个就不可以呢?还是看源码,有说服力。

DataOutputStream继承FilterOutputStream,实现了DataOutput接口。我们知道FilterOutputStream类重写了flush()方法,但是实质还是调用父类的flush方法。DataOutputStream类的flush()方法效仿其父类FilterOutputStream的做法,如下:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_7 height=14 name=ZeroClipboardMovie_7 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=7&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. public void flush() throws IOException {  
  2.     out.flush();  
  3. }  

 

那么,即使你在代码后面加上dos.flush();与不加是一样的效果,因为它们的父类flush()方法均为空,这就是为什么第一个代码的神奇所在。再看看第二个代码的病因在哪里?先看看BufferedOutputStream类的结构:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_8 height=14 name=ZeroClipboardMovie_8 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=8&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. public class BufferedOutputStream extends FilterOutputStream   

 

再看看,它的flush()方法:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_9 height=14 name=ZeroClipboardMovie_9 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=9&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. public synchronized void flush() throws IOException {  
  2.         flushBuffer();  
  3.     out.flush();  
  4. }  

 

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_10 height=14 name=ZeroClipboardMovie_10 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=10&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. /** Flush the internal buffer */  
  2. private void flushBuffer() throws IOException {  
  3.     if (count > 0) {  
  4.  out.write(buf, 0, count);  
  5.  count = 0;  
  6.     }  
  7. }  

 

不错,该类重写了flush()方法,不像前面几个那样不是继承就是山寨父类的flush()方法。BufferedOutputStream 类是一个使用了缓冲技术的类。这种类一把都会自己实现flush()方法。

那么,有人会问使用这种类的时候,难道必须使用flush()方法吗,当然不是喽??!!不过有个前提,你的字节数据必须不能小于8KB。实例代码,注意没有flush()方法。

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_11 height=14 name=ZeroClipboardMovie_11 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=11&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. package mark.zhang;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.File;  
  4. import java.io.FileOutputStream;  
  5. public class Test {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("text.txt");  
  8.         if(!file.exists()) {  
  9.             file.createNewFile();  
  10.         }  
  11.         FileOutputStream fos = new FileOutputStream(file);  
  12.         BufferedOutputStream bos = new BufferedOutputStream(fos);  
  13.         byte[] b = new byte[1024*8];  
  14.         bos.write(b);  
  15.         //bos.flush();  
  16.     }  
  17. }  

 

执行代码,会产生8KB的文本文件。当然,怎么可能你每时每刻都知道你的数据一定会不小于8KB呢,所以还是调用flush()方法比较安全。不过,话又说回来,一般用完IO流之后(如果你有一个好的习惯)我们都会去调用close()方法,看源码可以知道该方法也是调用相对应的flush()方法。所以,大多数情况下你不必要担心。这里提醒一下,如果你的文件读写没有达到预期目的,十之八九是因为你没有调用flush()或者close()方法。

另外,字符流类大多数都实现了flush()或者close()方法,只不过,它们调用的是StreamEncoder类的该方法。该类位于sun.nio.cs包下面,其源码在我们jdk中是没有的。源码地址:http://www.docjar.com/html/api/sun/nio/cs/StreamEncoder.java.html。在此,ctrl+v其源码,如下:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_12 height=14 name=ZeroClipboardMovie_12 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=12&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. /* 
  2.  * Copyright 2001-2005 Sun Microsystems, Inc.  All Rights Reserved. 
  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 
  4.  * 
  5.  * This code is free software; you can redistribute it and/or modify it 
  6.  * under the terms of the GNU General Public License version 2 only, as 
  7.  * published by the Free Software Foundation.  Sun designates this 
  8.  * particular file as subject to the "Classpath" exception as provided 
  9.  * by Sun in the LICENSE file that accompanied this code. 
  10.  * 
  11.  * This code is distributed in the hope that it will be useful, but WITHOUT 
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License 
  14.  * version 2 for more details (a copy is included in the LICENSE file that 
  15.  * accompanied this code). 
  16.  * 
  17.  * You should have received a copy of the GNU General Public License version 
  18.  * 2 along with this work; if not, write to the Free Software Foundation, 
  19.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 
  20.  * 
  21.  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 
  22.  * CA 95054 USA or visit www.sun.com if you need additional information or 
  23.  * have any questions. 
  24.  */  
  25.   
  26.   
  27.   
  28. package sun.nio.cs;  
  29.   
  30. import java.io;  
  31. import java.nio;  
  32. import java.nio.channels;  
  33. import java.nio.charset;  
  34.   
  35. public class StreamEncoder extends Writer  
  36. {  
  37.   
  38.     private static final int DEFAULT_BYTE_BUFFER_SIZE = 8192;  
  39.   
  40.     private volatile boolean isOpen = true;  
  41.   
  42.     private void ensureOpen() throws IOException {  
  43.         if (!isOpen)  
  44.             throw new IOException("Stream closed");  
  45.     }  
  46.   
  47.     // Factories for java.io.OutputStreamWriter  
  48.     public static StreamEncoder forOutputStreamWriter(OutputStream out,  
  49.                                                       Object lock,  
  50.                                                       String charsetName)  
  51.         throws UnsupportedEncodingException  
  52.     {  
  53.         String csn = charsetName;  
  54.         if (csn == null)  
  55.             csn = Charset.defaultCharset().name();  
  56.         try {  
  57.             if (Charset.isSupported(csn))  
  58.                 return new StreamEncoder(out, lock, Charset.forName(csn));  
  59.         } catch (IllegalCharsetNameException x) { }  
  60.         throw new UnsupportedEncodingException (csn);  
  61.     }  
  62.   
  63.     public static StreamEncoder forOutputStreamWriter(OutputStream out,  
  64.                                                       Object lock,  
  65.                                                       Charset cs)  
  66.     {  
  67.         return new StreamEncoder(out, lock, cs);  
  68.     }  
  69.   
  70.     public static StreamEncoder forOutputStreamWriter(OutputStream out,  
  71.                                                       Object lock,  
  72.                                                       CharsetEncoder enc)  
  73.     {  
  74.         return new StreamEncoder(out, lock, enc);  
  75.     }  
  76.   
  77.   
  78.     // Factory for java.nio.channels.Channels.newWriter  
  79.   
  80.     public static StreamEncoder forEncoder(WritableByteChannel ch,  
  81.                                            CharsetEncoder enc,  
  82.                                            int minBufferCap)  
  83.     {  
  84.         return new StreamEncoder(ch, enc, minBufferCap);  
  85.     }  
  86.   
  87.   
  88.     // -- Public methods corresponding to those in OutputStreamWriter --  
  89.   
  90.     // All synchronization and state/argument checking is done in these public  
  91.     // methods; the concrete stream-encoder subclasses defined below need not  
  92.     // do any such checking.  
  93.   
  94.     public String getEncoding() {  
  95.         if (isOpen())  
  96.             return encodingName();  
  97.         return null;  
  98.     }  
  99.   
  100.    public void flushBuffer() throws IOException {  
  101.        synchronized (lock) {  
  102.            if (isOpen())  
  103.                implFlushBuffer();  
  104.            else  
  105.                throw new IOException("Stream closed");  
  106.        }  
  107.    }  
  108.   
  109.    public void write(int c) throws IOException {  
  110.        char cbuf[] = new char[1];  
  111.        cbuf[0] = (char) c;  
  112.        write(cbuf, 01);  
  113.    }  
  114.   
  115.    public void write(char cbuf[], int off, int len) throws IOException {  
  116.        synchronized (lock) {  
  117.            ensureOpen();  
  118.            if ((off < 0) || (off > cbuf.length) || (len < 0) ||  
  119.                ((off + len) > cbuf.length) || ((off + len) < 0)) {  
  120.                throw new IndexOutOfBoundsException();  
  121.            } else if (len == 0) {  
  122.                return;  
  123.            }  
  124.            implWrite(cbuf, off, len);  
  125.        }  
  126.    }  
  127.   
  128.    public void write(String str, int off, int len) throws IOException {  
  129.        /* Check the len before creating a char buffer */  
  130.        if (len < 0)  
  131.            throw new IndexOutOfBoundsException();  
  132.        char cbuf[] = new char[len];  
  133.        str.getChars(off, off + len, cbuf, 0);  
  134.        write(cbuf, 0, len);  
  135.    }  
  136.   
  137.    public void flush() throws IOException {  
  138.        synchronized (lock) {  
  139.            ensureOpen();  
  140.            implFlush();  
  141.        }  
  142.    }  
  143.   
  144.    public void close() throws IOException {  
  145.        synchronized (lock) {  
  146.            if (!isOpen)  
  147.                return;  
  148.            implClose();  
  149.            isOpen = false;  
  150.        }  
  151.    }  
  152.   
  153.    private boolean isOpen() {  
  154.        return isOpen;  
  155.    }  
  156.   
  157.   
  158.    // -- Charset-based stream encoder impl --  
  159.   
  160.    private Charset cs;  
  161.    private CharsetEncoder encoder;  
  162.    private ByteBuffer bb;  
  163.   
  164.    // Exactly one of these is non-null  
  165.    private final OutputStream out;  
  166.    private WritableByteChannel ch;  
  167.   
  168.    // Leftover first char in a surrogate pair  
  169.    private boolean haveLeftoverChar = false;  
  170.    private char leftoverChar;  
  171.    private CharBuffer lcb = null;  
  172.   
  173.    private StreamEncoder(OutputStream out, Object lock, Charset cs) {  
  174.        this(out, lock,  
  175.         cs.newEncoder()  
  176.         .onMalformedInput(CodingErrorAction.REPLACE)  
  177.         .onUnmappableCharacter(CodingErrorAction.REPLACE));  
  178.    }  
  179.   
  180.    private StreamEncoder(OutputStream out, Object lock, CharsetEncoder enc) {  
  181.        super(lock);  
  182.        this.out = out;  
  183.        this.ch = null;  
  184.        this.cs = enc.charset();  
  185.        this.encoder = enc;  
  186.   
  187.        // This path disabled until direct buffers are faster  
  188.        if (false && out instanceof FileOutputStream) {  
  189.                ch = ((FileOutputStream)out).getChannel();  
  190.        if (ch != null)  
  191.                    bb = ByteBuffer.allocateDirect(DEFAULT_BYTE_BUFFER_SIZE);  
  192.        }  
  193.            if (ch == null) {  
  194.        bb = ByteBuffer.allocate(DEFAULT_BYTE_BUFFER_SIZE);  
  195.        }  
  196.    }  
  197.   
  198.    private StreamEncoder(WritableByteChannel ch, CharsetEncoder enc, int mbc) {  
  199.        this.out = null;  
  200.        this.ch = ch;  
  201.        this.cs = enc.charset();  
  202.        this.encoder = enc;  
  203.        this.bb = ByteBuffer.allocate(mbc < 0  
  204.                                  ? DEFAULT_BYTE_BUFFER_SIZE  
  205.                                  : mbc);  
  206.    }  
  207.   
  208.    private void writeBytes() throws IOException {  
  209.        bb.flip();  
  210.        int lim = bb.limit();  
  211.        int pos = bb.position();  
  212.        assert (pos <= lim);  
  213.        int rem = (pos <= lim ? lim - pos : 0);  
  214.   
  215.            if (rem > 0) {  
  216.        if (ch != null) {  
  217.            if (ch.write(bb) != rem)  
  218.                assert false : rem;  
  219.        } else {  
  220.            out.write(bb.array(), bb.arrayOffset() + pos, rem);  
  221.        }  
  222.        }  
  223.        bb.clear();  
  224.        }  
  225.   
  226.    private void flushLeftoverChar(CharBuffer cb, boolean endOfInput)  
  227.        throws IOException  
  228.    {  
  229.        if (!haveLeftoverChar && !endOfInput)  
  230.            return;  
  231.        if (lcb == null)  
  232.            lcb = CharBuffer.allocate(2);  
  233.        else  
  234.            lcb.clear();  
  235.        if (haveLeftoverChar)  
  236.            lcb.put(leftoverChar);  
  237.        if ((cb != null) && cb.hasRemaining())  
  238.            lcb.put(cb.get());  
  239.        lcb.flip();  
  240.        while (lcb.hasRemaining() || endOfInput) {  
  241.            CoderResult cr = encoder.encode(lcb, bb, endOfInput);  
  242.            if (cr.isUnderflow()) {  
  243.                if (lcb.hasRemaining()) {  
  244.                    leftoverChar = lcb.get();  
  245.                    if (cb != null && cb.hasRemaining())  
  246.                        flushLeftoverChar(cb, endOfInput);  
  247.                    return;  
  248.                }  
  249.                break;  
  250.            }  
  251.            if (cr.isOverflow()) {  
  252.                assert bb.position() > 0;  
  253.                writeBytes();  
  254.                continue;  
  255.            }  
  256.            cr.throwException();  
  257.        }  
  258.        haveLeftoverChar = false;  
  259.    }  
  260.   
  261.    void implWrite(char cbuf[], int off, int len)  
  262.        throws IOException  
  263.    {  
  264.        CharBuffer cb = CharBuffer.wrap(cbuf, off, len);  
  265.   
  266.        if (haveLeftoverChar)  
  267.        flushLeftoverChar(cb, false);  
  268.   
  269.        while (cb.hasRemaining()) {  
  270.        CoderResult cr = encoder.encode(cb, bb, false);  
  271.        if (cr.isUnderflow()) {  
  272.           assert (cb.remaining() <= 1) : cb.remaining();  
  273.           if (cb.remaining() == 1) {  
  274.                haveLeftoverChar = true;  
  275.                leftoverChar = cb.get();  
  276.            }  
  277.            break;  
  278.        }  
  279.        if (cr.isOverflow()) {  
  280.            assert bb.position() > 0;  
  281.            writeBytes();  
  282.            continue;  
  283.        }  
  284.        cr.throwException();  
  285.        }  
  286.    }  
  287.   
  288.    void implFlushBuffer() throws IOException {  
  289.        if (bb.position() > 0)  
  290.        writeBytes();  
  291.    }  
  292.   
  293.    void implFlush() throws IOException {  
  294.        implFlushBuffer();  
  295.        if (out != null)  
  296.        out.flush();  
  297.    }  
  298.   
  299.    void implClose() throws IOException {  
  300.        flushLeftoverChar(nulltrue);  
  301.        try {  
  302.            for (;;) {  
  303.                CoderResult cr = encoder.flush(bb);  
  304.                if (cr.isUnderflow())  
  305.                    break;  
  306.                if (cr.isOverflow()) {  
  307.                    assert bb.position() > 0;  
  308.                    writeBytes();  
  309.                    continue;  
  310.                }  
  311.                cr.throwException();  
  312.            }  
  313.   
  314.            if (bb.position() > 0)  
  315.                writeBytes();  
  316.            if (ch != null)  
  317.                ch.close();  
  318.            else  
  319.                out.close();  
  320.        } catch (IOException x) {  
  321.            encoder.reset();  
  322.            throw x;  
  323.        }  
  324.    }  
  325.   
  326.    String encodingName() {  
  327.        return ((cs instanceof HistoricallyNamedCharset)  
  328.            ? ((HistoricallyNamedCharset)cs).historicalName()  
  329.            : cs.name());  
  330.    }  

 

更多源码查看http://www.docjar.com/projects/Open-JDK-6.b17-src-code.htm

2. Writer类的flush方法

该类是一个抽象类,声明如下:

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_13 height=14 name=ZeroClipboardMovie_13 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=13&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. public abstract class Writer implements Appendable, Closeable, Flushable   

 

Writer类的flush()方法是一个抽象方法,其子类一般都实现了该方法。所以,一般使用字符流之后,调用一下flush()或者close()方法。

[java]   view plain copy print ?
<EMBED id=ZeroClipboardMovie_14 height=14 name=ZeroClipboardMovie_14 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=29 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=14&width=29&height=14" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. abstract public void flush() throws IOException;  

 

细节请看jdk的api,或者Java的源码以及上面的StreamEncoder类源码。

ok,说到这里吧,这里主要借助Java的IO中字节流与字符流的flush()方法,来说明学Java看源码和思考是很重要的。

总之,不管你使用哪种流(字符、字节、具有缓冲的流)技术,不妨调用一下flush()/close()方法,防止数据无法写到输出流中。

本文转载自:http://blog.csdn.net/veryitman/article/details/6460726

共有 人打赏支持
上一篇: 详解URL的组成
下一篇: String数组初始化
Airship
粉丝 41
博文 967
码字总数 20029
作品 0
南京
高级程序员
私信 提问
java基础io流——配角也风流(不求甚解)

本章简单介绍几个常见的io流派生。 1:数据操作流(操作基本类型数据的流)(理解) 代码示例: 2:内存操作流(理解) 用于处理临时存储信息的,程序结束,数据就从内存中消失。 代码示例: 注:查看...

潇潇漓燃
2018/05/30
0
0
(代码篇)从基础文件IO说起虚拟内存,内存文件映射,零拷贝

上一篇讲解了基础文件IO的理论发展,这里结合java看看各项理论的具体实现。 传统IO-intsmaze 传统文件IO操作的基础代码如下: FileInputStream in = new FileInputStream("D:\java.txt");in....

intsmaze(刘洋)
2018/08/01
0
0
java中io流的flush方法作用?

java中io字符流操作时候的flush()方法有什么作用? 我的理解:(有错误的地方还请大家指正) 是在缓冲区数据没满之前强制把数据写入.且流对象还可使用 那在我不用这个流对象的时候,有必要flush()...

HaleyZhang
2018/07/05
245
2
Java FileInputStream

一、序言 IO操作,才程序中比较普遍,JAVA 中提出了IO/NIO 的概念,也一直在说NIO 比IO快,一直不知道原因,就想memcache 和ehcache 比较优劣一样,这些东西得自己看看如何实现的,才 知道区...

pczhangtl
2014/08/03
0
0
JAVA基础再回首(三十)——JAVA基础再回首完美结束,感概万千!

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/m366917/article/details/52724939 JAVA基础再回首(三十)——JAVA基础再回首完美结束,感概万千! 经过了几...

Aduroidpc
2016/10/02
0
0

没有更多内容

加载失败,请刷新页面

加载更多

SpringBoot引入第三方jar包或本地jar包的处理方式

在开发过程中有时会用到maven仓库里没有的jar包或者本地的jar包,这时没办法通过pom直接引入,那么该怎么解决呢 一般有两种方法 - 第一种是将本地jar包安装在本地maven库 - 第二种是将本地j...

独钓渔
47分钟前
2
0
五、MyBatis缓存

一、MyBatis缓存介绍 缓存的使用可以明显的加快访问数据速度,提升程序处理性能,生活和工作中,使用缓存的地方很多。在开发过程中,从前端-->后端-->数据库等都涉及到缓存。MyBatis作为数据...

yangjianzhou
今天
2
0
最近研究如何加速UI界面开发,有点感觉了

最近在开发JFinal学院的JBolt开发平台,后端没啥说的,做各种极简使用的封装,开发者上手直接使用。 JBolt开发平台包含常用的用户、角色、权限、字典、全局配置、缓存、增删改查完整模块、电...

山东-小木
今天
3
0
《月亮与六便士》的读后感作文3000字

《月亮与六便士》的读后感作文3000字: 看完英国作家威廉.萨默塞特.毛姆所著《月亮与六便士》(李继宏译),第一疑问就是全书即没提到“月亮”,也没提到“六便士”。那这书名又与内容有什么...

原创小博客
昨天
2
0
微信网页授权获取用户信息(ThinkPHP5)+ 微信发送客服消息(一)

以thinkphp5为实例,创建控制器 class Kf extends Controller { /** * [protected description]微信公众号appid * @var [type] */ protected $appid = "xxxxxxxxxxxxxxx"; /** * [protected......

半缘修道半缘君丶
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部