A股上市公司传智教育（股票代码 003032）旗下技术交流社区北京昌平校区

传智教育官网黑马程序员官网

 找回密码
 加入黑马

QQ登录

只需一步，快速开始

论坛首页 › 隐藏归类 › 黑马那些年 › 第40,41,42,43届Android交流区 › 正文

IO流小问题

© 郑飞 高级黑马   /  2014-8-18 10:27  /  2879 人查看  /  24 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 郑飞 于 2014-8-18 14:54 编辑

FielWriter 中的write（buf，0，len） 老毕视频中没用flush（）刷新 这个write方法中封装了flush（）吗？

评分

参与人数 1技术分 +1 收起 理由
格子、 + 1 神马都是浮云

查看全部评分

24 个回复

正序浏览
郑飞 高级黑马 2014-10-7 10:47:45
| 只看该作者
25#
kid1943 发表于 2014-10-7 09:42
其实查看FileWriter类的所有方法（即包括write方法）都继承自父类OutputStreamWriter。
而查看父类OutputSt ...

后来是看了源码 确实是封装了flush对象 谢谢...
回复 使用道具 举报
kid1943 中级黑马 2014-10-7 09:49:59
| 只看该作者
24#
kid1943 发表于 2014-10-7 09:42
其实查看FileWriter类的所有方法（即包括write方法）都继承自父类OutputStreamWriter。
而查看父类OutputSt ...

  2.       public class StreamEncoder extends Writer
  3.       {
  4.       
  5.           private static final int DEFAULT_BYTE_BUFFER_SIZE = 8192;
  6.       
  7.           private volatile boolean isOpen = true;
  8.       
  9.           private void ensureOpen() throws IOException {
  10.               if (!isOpen)
  11.                   throw new IOException("Stream closed");
  12.           }
  13.       
  14.       
  15.           public static StreamEncoder forOutputStreamWriter(OutputStream out,
  16.                                                               Object lock,
  17.                                                             String charsetName)
  18.               throws UnsupportedEncodingException
  19.           {
  20.              String csn = charsetName;
  21.               if (csn == null)
  22.                   csn = Charset.defaultCharset().name();
  23.               try {
  24.                   if (Charset.isSupported(csn))
  25.                       return new StreamEncoder(out, lock, Charset.forName(csn));
  26.               } catch (IllegalCharsetNameException x) { }
  27.               throw new UnsupportedEncodingException (csn);
  28.           }
  29.       
  30.           public static StreamEncoder forOutputStreamWriter(OutputStream out,
  31.                                                             Object lock,
  32.                                                             Charset cs)
  33.           {
  34.               return new StreamEncoder(out, lock, cs);
  35.           }
  36.       
  37.           public static StreamEncoder forOutputStreamWriter(OutputStream out,
  38.                                                             Object lock,
  39.                                                             CharsetEncoder enc)
  40.           {
  41.               return new StreamEncoder(out, lock, enc);
  42.           }
  43.       
  44.       
  45.          
  46.           public static StreamEncoder forEncoder(WritableByteChannel ch,
  47.                                                  CharsetEncoder enc,
  48.                                                  int minBufferCap)
  49.           {
  50.               return new StreamEncoder(ch, enc, minBufferCap);
  51.           }
  52.       
  53.      
  54.          public String getEncoding() {
  55.               if (isOpen())
  56.                   return encodingName();
  57.               return null;
  58.           }
  59.      
  60.          public void flushBuffer() throws IOException {
  61.              synchronized (lock) {
  62.                  if (isOpen())
  63.                     implFlushBuffer();
  64.                  else
  65.                      throw new IOException("Stream closed");
  66.              }
  67.         }
  68.      
  69.        public void write(int c) throws IOException {
  70.              char cbuf[] = new char[1];
  71.            cbuf[0] = (char) c;
  72.              write(cbuf, 0, 1);
  73.        }
  74.    
  75.        public void write(char cbuf[], int off, int len) throws IOException {
  76.             synchronized (lock) {
  77.                  ensureOpen();
  78.                if ((off < 0) || (off > cbuf.length) || (len < 0) ||
  79.                    ((off + len) > cbuf.length) || ((off + len) < 0)) {
  80.                     throw new IndexOutOfBoundsException();
  81.                 } else if (len == 0) {
  82.                   return;
  83.                }
  84.                implWrite(cbuf, off, len);
  85.             }
  86.        }
  87.    
  88.        public void write(String str, int off, int len) throws IOException {
  89.            /* Check the len before creating a char buffer */
  90.            if (len < 0)
  91.                throw new IndexOutOfBoundsException();
  92.            char cbuf[] = new char[len];
  93.           str.getChars(off, off + len, cbuf, 0);
  94.              write(cbuf, 0, len);
  95.          }
  96.    
  97.          public void flush() throws IOException {
  98.            synchronized (lock) {
  99.                 ensureOpen();
  100.                 implFlush();
  101.            }
  102.         }
  103.    
  104.         public void close() throws IOException {
  105.             synchronized (lock) {
  106.                  if (!isOpen)
  107.                      return;
  108.                  implClose();
  109.                isOpen = false;
  110.              }
  111.          }
  112.      
  113.          private boolean isOpen() {
  114.              return isOpen;
  115.          }
  116.      
  117.      
  118.      
  119.          private Charset cs;
  120.         private CharsetEncoder encoder;
  121.          private ByteBuffer bb;
  122.    
  123.         
  124.         private final OutputStream out;
  125.          private WritableByteChannel ch;
  126.      
  127.          private boolean haveLeftoverChar = false;
  128.          private char leftoverChar;
  129.          private CharBuffer lcb = null;
  130.    
  131.         private StreamEncoder(OutputStream out, Object lock, Charset cs) {
  132.             this(out, lock,
  133.               cs.newEncoder()
  134.               .onMalformedInput(CodingErrorAction.REPLACE)
  135.              .onUnmappableCharacter(CodingErrorAction.REPLACE));
  136.         }
  137.      
  138.          private StreamEncoder(OutputStream out, Object lock, CharsetEncoder enc) {
  139.                 
  140.                 
  141.              super(lock);
  142.              this.out = out;
  143.             this.ch = null;
  144.            this.cs = enc.charset();
  145.             this.encoder = enc;
  146.    
  147.              // This path disabled until direct buffers are faster
  148.           if (false && out instanceof FileOutputStream) {
  149.                    ch = ((FileOutputStream)out).getChannel();
  150.              if (ch != null)
  151.                        bb = ByteBuffer.allocateDirect(DEFAULT_BYTE_BUFFER_SIZE);
  152.             }
  153.                if (ch == null) {
  154.              bb = ByteBuffer.allocate(DEFAULT_BYTE_BUFFER_SIZE);
  155.            }
  156.          }
  157.    
  158.         private StreamEncoder(WritableByteChannel ch, CharsetEncoder enc, int mbc) {
  159.             this.out = null;
  160.            this.ch = ch;
  161.            this.cs = enc.charset();
  162.             this.encoder = enc;
  163.            this.bb = ByteBuffer.allocate(mbc < 0
  164.                                      ? DEFAULT_BYTE_BUFFER_SIZE
  165.                                      : mbc);
  166.        }
  167.    
  168.         private void writeBytes() throws IOException {
  169.             bb.flip();

  171.            int lim = bb.limit();
  172.            int pos = bb.position();
  173.             assert (pos <= lim);
  174.             int rem = (pos <= lim ? lim - pos : 0);
  175.    
  176.                if (rem > 0) {
  177.            if (ch != null) {
  178.                  if (ch.write(bb) != rem)
  179.                      assert false : rem;
  180.             } else {
  181.                out.write(bb.array(), bb.arrayOffset() + pos, rem);
  182.             }
  183.              }
  184.             bb.clear();
  185.           }
  186.    
  187.         private void flushLeftoverChar(CharBuffer cb, boolean endOfInput)
  188.            throws IOException
  189.         {
  190.             if (!haveLeftoverChar && !endOfInput)
  191.                 return;
  192.            if (lcb == null)
  193.                lcb = CharBuffer.allocate(2);
  194.            else
  195.               lcb.clear();
  196.            if (haveLeftoverChar)
  197.                lcb.put(leftoverChar);
  198.           if ((cb != null) && cb.hasRemaining())
  199.                lcb.put(cb.get());
  200.           lcb.flip();
  201.            while (lcb.hasRemaining() || endOfInput) {
  202.                CoderResult cr = encoder.encode(lcb, bb, endOfInput);
  203.                if (cr.isUnderflow()) {
  204.                    if (lcb.hasRemaining()) {
  205.                        leftoverChar = lcb.get();
  206.                       if (cb != null && cb.hasRemaining())
  207.                            flushLeftoverChar(cb, endOfInput);
  208.                       return;
  209.                    }
  210.                    break;
  211.                }
  212.              if (cr.isOverflow()) {
  213.                      assert bb.position() > 0;
  214.                     writeBytes();
  215.                     continue;
  216.                }
  217.                 cr.throwException();
  218.           }
  219.            haveLeftoverChar = false;
  220.       }
  221.    
  222.                        void implWrite(char cbuf[], int off, int len)
  223.                           throws IOException
  224.                         {
  225.                             CharBuffer cb = CharBuffer.wrap(cbuf, off, len);

  227.                            if (haveLeftoverChar)
  228.                            flushLeftoverChar(cb, false);
  229.                              while (cb.hasRemaining()) {  
  230.                           CoderResult cr = encoder.encode(cb, bb, false);/
  231.                            if (cr.isUnderflow()) {

  233.                               assert (cb.remaining() <= 1) : cb.remaining();、
  234.                               if (cb.remaining() == 1) {
  235.                                    haveLeftoverChar = true;
  236.                                     leftoverChar = cb.get();
  237.                                }
  238.                                break;
  239.                            }
  240.                             if (cr.isOverflow()) {
  241.                                assert bb.position() > 0;
  242.                               writeBytes();
  243.                                continue;
  244.                            }
  245.                            cr.throwException();
  246.                         }
  247.                        
  248.      
  249.          void implFlushBuffer() throws IOException {
  250.              if (bb.position() > 0)
  251.              writeBytes();
  252.          }
  253.    
  254.          void implFlush() throws IOException {
  255.             implFlushBuffer();
  256.             if (out != null)
  257.              out.flush();}
  258.      
  259.         void implClose() throws IOException {
  260.             flushLeftoverChar(null, true);
  261.              try {
  262.                  for (;;) {
  263.                     CoderResult cr = encoder.flush(bb);
  264.                     if (cr.isUnderflow())
  265.                          break;
  266.                     if (cr.isOverflow()) {
  267.                          assert bb.position() > 0;
  268.                         writeBytes();
  269.                          continue;
  270.                      }
  271.                      cr.throwException();
  272.                  }
  273.      
  274.                  if (bb.position() > 0)
  275.                     writeBytes();
  276.                  if (ch != null)
  277.                      ch.close();
  278.                 else
  279.                      out.close();
  280.             } catch (IOException x) {
  281.                encoder.reset();
  282.                throw x;
  283.            }
  284.         }
  285.    
  286.         String encodingName() {
  287.             return ((cs instanceof HistoricallyNamedCharset)
  288.                 ? ((HistoricallyNamedCharset)cs).historicalName()
  289.                 : cs.name());
  290.          }
  291.      }
  292. 这是StreamEncoder源码      
复制代码
回复 使用道具 举报
kid1943 中级黑马 2014-10-7 09:48:26
| 只看该作者
23#
kid1943 发表于 2014-10-7 09:42
其实查看FileWriter类的所有方法（即包括write方法）都继承自父类OutputStreamWriter。
而查看父类OutputSt ...


      public class StreamEncoder extends Writer
      {
      
          private static final int DEFAULT_BYTE_BUFFER_SIZE = 8192;
      
          private volatile boolean isOpen = true;
      
          private void ensureOpen() throws IOException {
              if (!isOpen)
                  throw new IOException("Stream closed");
          }
      
      
          public static StreamEncoder forOutputStreamWriter(OutputStream out,
                                                              Object lock,
                                                            String charsetName)
              throws UnsupportedEncodingException
          {
             String csn = charsetName;
              if (csn == null)
                  csn = Charset.defaultCharset().name();
              try {
                  if (Charset.isSupported(csn))
                      return new StreamEncoder(out, lock, Charset.forName(csn));
              } catch (IllegalCharsetNameException x) { }
              throw new UnsupportedEncodingException (csn);
          }
      
          public static StreamEncoder forOutputStreamWriter(OutputStream out,
                                                            Object lock,
                                                            Charset cs)
          {
              return new StreamEncoder(out, lock, cs);
          }
      
          public static StreamEncoder forOutputStreamWriter(OutputStream out,
                                                            Object lock,
                                                            CharsetEncoder enc)
          {
              return new StreamEncoder(out, lock, enc);
          }
      
      
         
          public static StreamEncoder forEncoder(WritableByteChannel ch,
                                                 CharsetEncoder enc,
                                                 int minBufferCap)
          {
              return new StreamEncoder(ch, enc, minBufferCap);
          }
      
     
         public String getEncoding() {
              if (isOpen())
                  return encodingName();
              return null;
          }
     
         public void flushBuffer() throws IOException {
             synchronized (lock) {
                 if (isOpen())
                    implFlushBuffer();
                 else
                     throw new IOException("Stream closed");
             }
        }
     
       public void write(int c) throws IOException {
             char cbuf[] = new char[1];
           cbuf[0] = (char) c;
             write(cbuf, 0, 1);
       }
   
       public void write(char cbuf[], int off, int len) throws IOException {
            synchronized (lock) {
                 ensureOpen();
               if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                   ((off + len) > cbuf.length) || ((off + len) < 0)) {
                    throw new IndexOutOfBoundsException();
                } else if (len == 0) {
                  return;
               }
               implWrite(cbuf, off, len);
            }
       }
   
       public void write(String str, int off, int len) throws IOException {
           /* Check the len before creating a char buffer */
           if (len < 0)
               throw new IndexOutOfBoundsException();
           char cbuf[] = new char[len];
          str.getChars(off, off + len, cbuf, 0);
             write(cbuf, 0, len);
         }
   
         public void flush() throws IOException {
           synchronized (lock) {
                ensureOpen();
                implFlush();
           }
        }
   
        public void close() throws IOException {
            synchronized (lock) {
                 if (!isOpen)
                     return;
                 implClose();
               isOpen = false;
             }
         }
     
         private boolean isOpen() {
             return isOpen;
         }
     
     
     
         private Charset cs;
        private CharsetEncoder encoder;
         private ByteBuffer bb;
   
        
        private final OutputStream out;
         private WritableByteChannel ch;
     
         private boolean haveLeftoverChar = false;
         private char leftoverChar;
         private CharBuffer lcb = null;
   
        private StreamEncoder(OutputStream out, Object lock, Charset cs) {
            this(out, lock,
              cs.newEncoder()
              .onMalformedInput(CodingErrorAction.REPLACE)
             .onUnmappableCharacter(CodingErrorAction.REPLACE));
        }
     
         private StreamEncoder(OutputStream out, Object lock, CharsetEncoder enc) {
                
                
             super(lock);
             this.out = out;
            this.ch = null;
           this.cs = enc.charset();
            this.encoder = enc;
   
             // This path disabled until direct buffers are faster
          if (false && out instanceof FileOutputStream) {
                   ch = ((FileOutputStream)out).getChannel();
             if (ch != null)
                       bb = ByteBuffer.allocateDirect(DEFAULT_BYTE_BUFFER_SIZE);
            }
               if (ch == null) {
             bb = ByteBuffer.allocate(DEFAULT_BYTE_BUFFER_SIZE);
           }
         }
   
        private StreamEncoder(WritableByteChannel ch, CharsetEncoder enc, int mbc) {
            this.out = null;
           this.ch = ch;
           this.cs = enc.charset();
            this.encoder = enc;
           this.bb = ByteBuffer.allocate(mbc < 0
                                     ? DEFAULT_BYTE_BUFFER_SIZE
                                     : mbc);
       }
   
        private void writeBytes() throws IOException {
            bb.flip();

           int lim = bb.limit();
           int pos = bb.position();
            assert (pos <= lim);
            int rem = (pos <= lim ? lim - pos : 0);
   
               if (rem > 0) {
           if (ch != null) {
                 if (ch.write(bb) != rem)
                     assert false : rem;
            } else {
               out.write(bb.array(), bb.arrayOffset() + pos, rem);
            }
             }
            bb.clear();
          }
   
        private void flushLeftoverChar(CharBuffer cb, boolean endOfInput)
           throws IOException
        {
            if (!haveLeftoverChar && !endOfInput)
                return;
           if (lcb == null)
               lcb = CharBuffer.allocate(2);
           else
              lcb.clear();
           if (haveLeftoverChar)
               lcb.put(leftoverChar);
          if ((cb != null) && cb.hasRemaining())
               lcb.put(cb.get());
          lcb.flip();
           while (lcb.hasRemaining() || endOfInput) {
               CoderResult cr = encoder.encode(lcb, bb, endOfInput);
               if (cr.isUnderflow()) {
                   if (lcb.hasRemaining()) {
                       leftoverChar = lcb.get();
                      if (cb != null && cb.hasRemaining())
                           flushLeftoverChar(cb, endOfInput);
                      return;
                   }
                   break;
               }
             if (cr.isOverflow()) {
                     assert bb.position() > 0;
                    writeBytes();
                    continue;
               }
                cr.throwException();
          }
           haveLeftoverChar = false;
      }
   
                       void implWrite(char cbuf[], int off, int len)
                          throws IOException
                        {
                            CharBuffer cb = CharBuffer.wrap(cbuf, off, len);

                           if (haveLeftoverChar)
                           flushLeftoverChar(cb, false);
                             while (cb.hasRemaining()) {  
                          CoderResult cr = encoder.encode(cb, bb, false);/
                           if (cr.isUnderflow()) {

                              assert (cb.remaining() <= 1) : cb.remaining();、
                              if (cb.remaining() == 1) {
                                   haveLeftoverChar = true;
                                    leftoverChar = cb.get();
                               }
                               break;
                           }
                            if (cr.isOverflow()) {
                               assert bb.position() > 0;
                              writeBytes();
                               continue;
                           }
                           cr.throwException();
                        }
                       
     
         void implFlushBuffer() throws IOException {
             if (bb.position() > 0)
             writeBytes();
         }
   
         void implFlush() throws IOException {
            implFlushBuffer();
            if (out != null)
             out.flush();}
     
        void implClose() throws IOException {
            flushLeftoverChar(null, true);
             try {
                 for (;;) {
                    CoderResult cr = encoder.flush(bb);
                    if (cr.isUnderflow())
                         break;
                    if (cr.isOverflow()) {
                         assert bb.position() > 0;
                        writeBytes();
                         continue;
                     }
                     cr.throwException();
                 }
     
                 if (bb.position() > 0)
                    writeBytes();
                 if (ch != null)
                     ch.close();
                else
                     out.close();
            } catch (IOException x) {
               encoder.reset();
               throw x;
           }
        }
   
        String encodingName() {
            return ((cs instanceof HistoricallyNamedCharset)
                ? ((HistoricallyNamedCharset)cs).historicalName()
                : cs.name());
         }
     }
           
回复 使用道具 举报
kid1943 中级黑马 2014-10-7 09:42:15
| 只看该作者
22#
其实查看FileWriter类的所有方法（即包括write方法）都继承自父类OutputStreamWriter。
而查看父类OutputStream的write方法可知无论调用到哪个write方法最终还是调用到，一个叫StreamEncoder类对象se的write方法。

你找到对应的write方法，都可以发现，其会定义一个数组作为缓冲区，当缓冲区写满的时候，就会调用OutputStream（即FileWriter 在构造函数里创建的FileOutputStream对象）的write方法将数据写出。最后不难的出结论，其实FileWriter在将对应的StreamEcoder对象里的缓冲区写满的时候，数据会自动写出去即可以理解为调用了flush（这个可以看下StreamEncoder源码）。
以上是我理解的，楼主还是自己认真看一下StreamEncoder类的源码吧。
回复 使用道具 举报
嘻嘻哈哈嘻嘻 中级黑马 2014-9-16 16:54:35
| 只看该作者
21#
嘻嘻哈哈嘻嘻 发表于 2014-9-16 16:51
这个只是从文件中读出的buf,然后写到内存中,flush()是内存中写到硬盘中

你还可以试下 把读一个超过你内存的文,不去flush()看看内存会不会爆掉
回复 使用道具 举报
嘻嘻哈哈嘻嘻 中级黑马 2014-9-16 16:51:59
| 只看该作者
20#
郑飞 发表于 2014-8-18 12:56
while ((len = fr.read(buf))!=-1)
                {
                        fw.write(buf,0,len);

这个只是从文件中读出的buf,然后写到内存中,flush()是内存中写到硬盘中
回复 使用道具 举报
黄宝宝 高级黑马 2014-9-2 12:12:58
| 只看该作者
19#
字都打错了
回复 使用道具 举报
郑飞 高级黑马 2014-9-1 02:14:20
| 只看该作者
18#
本帖最后由 郑飞 于 2014-9-1 02:17 编辑
冷锋也温柔 发表于 2014-8-31 23:25
没有封装   后面没使用flush（）     是因为结尾用close（）了   它的作用是刷新内存 后释放资源   它包含 ...

之前看了下BufferedOutputStream中write方法 发现确实是自动刷新的 字符流的还没看 估计也是的 因为缓冲流要用两个数组传递数据的话 肯定不止只传第一次 所以最后的close是不够用的
回复 使用道具 举报
冷锋也温柔 中级黑马 2014-8-31 23:25:47
| 只看该作者
17#
没有封装   后面没使用flush（）     是因为结尾用close（）了   它的作用是刷新内存 后释放资源   它包含了flush的作用
回复 使用道具 举报
郑飞 高级黑马 2014-8-27 12:40:46
| 只看该作者
16#
希冀 发表于 2014-8-27 12:21
楼主程序后面是不是用了close方法

这个搞明白了 是存到缓冲区了
回复 使用道具 举报
希冀 中级黑马 2014-8-27 12:21:36
| 只看该作者
15#
楼主程序后面是不是用了close方法
回复 使用道具 举报
liqi 中级黑马 2014-8-19 11:37:58
| 只看该作者
14#
学习了     
回复 使用道具 举报
郑飞 高级黑马 2014-8-18 23:01:35
| 只看该作者
13#
烟海 发表于 2014-8-18 22:50
前面循环的。。先相当于临时存到内存一样的容器里面。。。
close之前，全部写入硬盘。。。。 ...

谢谢 我按这个思路再看看去
回复 使用道具 举报
烟海 中级黑马 2014-8-18 22:50:40
| 只看该作者
12#
郑飞 发表于 2014-8-18 13:53
好吧 看来我是没弄清楚怎么存进去了 回头我再看看 谢了

前面循环的。。先相当于临时存到内存一样的容器里面。。。
close之前，全部写入硬盘。。。。
回复 使用道具 举报
郑飞 高级黑马 2014-8-18 13:53:13
| 只看该作者
11#
pengyu1801 发表于 2014-8-18 13:29
前面循环的都缓存起来了

好吧 看来我是没弄清楚怎么存进去了 回头我再看看 谢了
回复 使用道具 举报
Caincxy 中级黑马 2014-8-18 13:34:34
| 只看该作者
10#
学习了啊........
回复 使用道具 举报
pengyu1801 中级黑马 2014-8-18 13:29:27
| 只看该作者
9#
郑飞 发表于 2014-8-18 12:56
while ((len = fr.read(buf))!=-1)
                {
                        fw.write(buf,0,len);

前面循环的都缓存起来了

评分

参与人数 1黑马币 +5 收起 理由
郑飞 + 5 谢谢

查看全部评分

回复 使用道具 举报
郑飞 高级黑马 2014-8-18 13:06:03
| 只看该作者
8#
思如涌泉 发表于 2014-8-18 12:58
close关闭的时候就附带刷新动作了,将数组刷新到文件中

每读写一次 不是buf就更新一次吗 读写那么多次 为什么只要最后一次刷新啊
回复 使用道具 举报
思如涌泉 中级黑马 2014-8-18 12:58:08
| 只看该作者
7#
close关闭的时候就附带刷新动作了,将数组刷新到文件中
回复 使用道具 举报
下一页 »
12下一页
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 加入黑马