OutputStreamWriter 和BufferedWriter都是继承的  java.io.Writer   都是代表一个字符流,前者是字节输出流转成字符输出 流，后者是一个字符输出流的增强装饰类

他们都有flush方法
OutputStreamWriter.flush()
          刷新该流的缓冲。
BufferedWriter.flush()
         刷新该流的缓冲。

那么为什么该例中使用
osw.flush();        //经过测试，是这句出了问题  和 bw.flush 产生了截然不同的运行结果

于是心生疑惑,他们的区别在哪儿啊,他们操作的流不是一个吗？

求来个形象的解释 {:soso_e101:}     希望得到同学们的指点   哥们儿先谢了

代码如下：

1. import java.io.*;
   
2. 
   
3. class Run
   
4. {
   
5.         public static void sop(Object obj)
   
6.         {
   
7.                 System.out.println(obj);   
   
8.         }           
   
9. 
   
10.         public static void main(String[] args) throws IOException
    
11.         {        
    
12.          /*
    
13.          //接收字节流        
    
14.          InputStream is = System.in;
    
15.          
    
16.          //转成字符流
    
17.          InputStreamReader isr = new InputStreamReader(is);
    
18.          
    
19.          //利用字符流的增强类
    
20.          BufferedReader br = new BufferedReader(isr);
    
21.          */
    
22.          
    
23.          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));         
    
24.          //--------------------------------------------------------
    
25.          
    
26.          
    
27.          BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    
28.          /*
    
29.          OutputStream os = System.out;
    
30.          
    
31.          OutputStreamWriter osw = new OutputStreamWriter(os);
    
32.          
    
33.          BufferedWriter bw = new BufferedWriter(osw);
    
34.          */
    
35.          String s = null;
    
36.          //调用行读取函数
    
37.          while((s=br.readLine())!=null)// 返回个字符串
    
38.          {
    
39.                         if("over".equals(s))
    
40.                          break;
    
41.                         
    
42.       bw.write(s.toUpperCase());//直接将字符写入硬盘
    
43.       bw.newLine();//跨平台的换行
    
44.       bw.flush();//注意，写操作必须刷新。刷新很重要
    
45.       
    
46.                         /*
    
47.                         为什么这样不行？
    
48.                         osw.write(s.toUpperCase());//这句写是可以的
    
49.                         bw.newLine();
    
50.                         osw.flush();        //经过测试，是这句出了问题
    
51.                         
    
52.                         分析：
    
53.                         osw是字节流->OutputStream
    
54.                         
    
55.                         我查了OutputStream的API：
    
56.                         void flush()
    
57.           刷新此输出流并强制写出所有缓冲的输出字节。
    
58.          
    
59.       这里bw.flush和osw.flush有什么不同之处么？   
    
60.                         */
    
61.          }
    
62.         }
    
63. }
    

复制代码

InputStreamReade 是一个读取字符的流他flush一个一个字符往程序上读的，读完后才刷新   BufferedReader 是一个缓冲区 是一批一批的读，读完才刷新

我这里运行时可以的。没有什么问题。

检查一下，是不是你的bw在使用的时候，将另一个流的bw当成这个bw了
package day1;

import java.io.*;

class ChatDemo
{
        public static void sop(Object obj)
        {
                System.out.println(obj);   
        }         

        public static void main(String[] args) throws IOException
        {      
        
         
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));         
         
         OutputStream os = System.out;
         
         OutputStreamWriter osw = new OutputStreamWriter(os);
         
         BufferedWriter bws = new BufferedWriter(osw);
         
         String s = null;
        
         while((s=br.readLine())!=null)// 返回个字符串
         {
                        if("over".equals(s))
                         break;
                        
                        
                        
                        osw.write(s.toUpperCase());//这句写是可以的
                        bws.newLine();
                        osw.flush();        //经过测试，是这句出了问题
         
         }
        }
}

我这里运行很好

谢谢同学指点

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢