字节流输出不是不用刷新吗，读一个写一个，为什么OutputStream里面有flush()方法，请问什么时候用到字节流的刷新？？？能否举个简单的例子

刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。
如果此流的预期目标是由基础操作系统提供的一个抽象（如一个文件），则刷新此流只能保证将以前写入到流的字节传递给操作系统进行写入，但不保证能将这些字节实际写入到物理设备（如磁盘驱动器）。

OutputStream 的 flush 方法不执行任何操作。

这是jdk1.6的api中写到的，刷新本身是为了达到你预期的目的，因为缓存在流中的东西如果在缓存没有装满的情况下他可能不会执行传递的动作，但是调用flush方法就会将
缓存强制的输出。但是api中写着outputstream的flush方法不执行任何操作，可能是字节流的原因？

flush();方法是把内存中的数据冲出来适用于bufferedoutputstream如果没有这个方法就不能读出数据
package io;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class BufferedOutputStreamtest {
       
        public static void main(String[] args) throws IOException {
               
                OutputStream os = new FileOutputStream("f:/test.txt");
               
                String str = new String("wo yao  cheng  wei yige hao erzi hao zhangfu haofuqin");
              BufferedOutputStream  bs = new BufferedOutputStream(os);
              bs.write(str.getBytes());
              //bs.flush();
                //bs.close();
                os.close();
        }

}
如果注释掉  //bs.flush();就会只创建文件不会写入内容如果有bs.close();也会起到同样的效果

  字节输出流不需要刷新，字符流刷新是因为在底层调用了字节流，然后将其存入一个数组，因为内部封装了缓冲，所以字符流需要刷新。
  OutputStream中flush()存在的意义就是：刷新此输出流并强制写出所有缓存的输出字节。这里所说的缓存是指应用程序与IO设备之间的内存缓存区，这样做的是因为CPU读写内存的速度比读写IO设备要快得多，设置一个内存缓冲区可以提高CPU利用率。
flush() 是把缓冲区的数据强行输出
        主要用在IO中，即清空缓冲区数据，
    例如：在读写流(stream)的时候，数据是先被读到了内存中，再把数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先flush()。

import java.io.*;

class FileChar{

       private String str;
       private char arrayList[];
       private BufferedReader br;//字符
       private File f; //文件
      
       FileChar(String s) {
              f=new File(s);
       }
       public void start(){
              if( inputData()==-1 ){
                     return;
              }           
              sortChar();
              //把排序的字符数组编程字符串，写入b.txt.            
              outputString();
       }
      
       //字符数组冒泡排序
       private void sortChar(){
           char temp=0;
           for( int i=0; i<arrayList.length-1; i++ ){
                  for( int j=0; j<arrayList.length-i-1; j++ ){
                         if( arrayList[j]>arrayList[j+1] ){
                                temp=arrayList[j];
                                arrayList[j]=arrayList[j+1];
                                arrayList[j+1]=temp;            
                         }
                  }
           }
    }
      
       private int  inputData(){
              try{
                     br=new BufferedReader( new FileReader(f));
                     while( (str=br.readLine())!=null ){                     
                            str.toLowerCase();//所有大写字母转换小写
                            arrayList=str.toCharArray();  
                     }
              }
              catch(IOException e){
                     System.out.println( "读取文件出错!" );
                     e.printStackTrace();
                     return -1;               
              }
              finally{
                     if(br!=null) {
                            try{
                                   br.close();
                            }
                            catch(IOException e){
                                   e.printStackTrace();
                            }
                     }
              }
              return 1;
       }
           
       private void outputString(){
              BufferedWriter bw=null;
              try{
                     FileWriter fw = new FileWriter("b.txt");
                     bw = new BufferedWriter(fw);                    
                     bw.write( new String( arrayList,0,arrayList.length ));
                     bw.flush();//flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。

              }
              catch(IOException e){
                     e.printStackTrace();
              }
              finally{
                     if(bw!=null){
                            try{
                                   bw.close();
                            }
                            catch(IOException e){
                                   e.printStackTrace();
                            }
                     }
              }
      }
}

public class Demo{
       public static void main(String arsg[]){
              new FileChar( "a.txt" ).start();
              System.out.println("排序已完成，请看b.txt文件");
       }
}