黑马程序员-IO流 02

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

字节流：可以操作任意文件
 * 字节输出流抽象基类 OutputStream
 * 字节输入流的抽象基类 InputStream
 
FileInputStream类，读取文件
import java.io.*;
public class FileInputStreamDemo {
   public static void main(String[] args)throws IOException {	
      //FileInputStream(String name) 
      FileInputStream fis = new FileInputStream("c:\\stream.txt");
      int length = 0 ;
      //定义字节数组进行缓冲
      byte[] buf = new byte[30];
      while((length = fis.read(buf))!=-1){
    	System.out.println(new String(buf,0,length));
      }
      fis.close();
   }
}

1.字节流File读写操作
练习：标准的复制一个图片，带有异常处理
/* 
复制一个图片 
思路： 
1，用字节读取流对象和图片关联。 
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。 
3，通过循环读写，完成数据的存储。 
4，关闭资源。 
*/  
import java.io.*;  
class CopyPic  {  
         public static void main(String[] args)  {  
                   FileOutputStream fos = null;  
                   FileInputStream fis = null;  
                   try  {  
                            fos= new FileOutputStream("c:\\2.bmp");  
                            fis= new FileInputStream("c:\\1.bmp");  
   
                            byte[] buf = new byte[1024];  
   
                            int len = 0;  
                            while((len=fis.read(buf))!=-1) {  
                                     fos.write(buf,0,len);  
                            }  
                   }  
                   catch(IOException e)  {  
                           throw new RuntimeException("复制文件失败");  
                   }  
                   finally {  
                            try {  
                                     if(fis!=null)  
                                               fis.close();  
                            }  
                            catch(IOException e) {  
                                     throw new RuntimeException("读取关闭失败");  
                            }  
                            try  {  
                                     if(fos!=null)  
                                               fos.close();  
                            }  
                            catch(IOException e)  {  
                                     throw new RuntimeException("写入关闭失败");  
                            }  
                   }  
         }  
}  


练习：自定义一个字节流缓冲区BufferedInputStream
class import java.io.*;   
class MyBufferedInputStream  {
         private InputStream in;  
   
         private byte[] buf = new byte[1024*4];  
                    
         private int pos = 0,count = 0;  
          
         MyBufferedInputStream(InputStream in){  //将in传入 装饰一下
                   this.in= in;  
         }  
   
         //一次读一个字节，从缓冲区(字节数组)获取。  
         publicint myRead()throws IOException   {                    
                   if(count==0)  {  
                            count= in.read(buf);  //通过in读取硬盘上数据 存储buf中。
                            if(count<0)  
                                     return -1;  
                            pos= 0;  
                            byte b = buf[pos];  
   
                            count--;  
                            pos++;  
                            return b&255;  
                   }  
                  else if(count>0)  {  
                            byte b = buf[pos];  
   
                            count--;  
                            pos++;  
                            return b&0xff;  
                   }  
                   return -1;  
         }  
         publicvoid myClose()throws IOException  {  
                   in.close();  
         }  
}  
/* 
结论： 
字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。 
    因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1. 那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。 
    所以，为了避免这种情况将读到的字节进行int类型的提升。 
    并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。 
 
而在写入数据时，只写该int类型数据的最低8位。
 */

2.键盘录入及转换流
System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备：键盘。
 
字符流：
FileReader
FileWriter。
 
BufferedReader
BufferedWriter
 
字节流：
FileInputStream
FileOutputStream
 
BufferedInputStream
BufferedOutputStream
 
字节转成字符的转换流
InputStreamReader
OutputStreamWriter
练习：利用转换流，及BufferedReader中readLine方法读取键盘操作
 
/* 
readLine方法是字符流BufferedReader类中的方法。  
而键盘录入的read方法是字节流InputStream的方法。 
  
那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢？ 
*/  
import java.io.*;  
class TransStreamDemo  {  
         public static void main(String[] args) throws IOException  {  
                   //获取键盘录入对象。  
                   //InputStream in = System.in;  
   
                   //将字节流对象转成字符流对象，使用转换流。InputStreamReader  
                   //InputStreamReader isr = new InputStreamReader(in);  
   
                   //为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader  
                   //BufferedReader bufr = new BufferedReader(isr);  
                   //键盘的最常见写法。  上面三句话变一句*************
       BufferedReader bufr = newBufferedReader(new InputStreamReader(System.in));  
 
     BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));  
   
                   String line = null;  
                   while((line=bufr.readLine())!=null) {  
                            if("over".equals(line))  
                                     break;  
                            bufw.write(line.toUpperCase());  
                            bufw.newLine();  
                            bufw.flush();  
                   }  
                   bufr.close();    
         }  
}  

IO流操作规律
当我们确定要使用IO流对象的时候，什么时候选择哪一个流对象呢
    Writer Reader InputStream OutputStream
    FileWriter FileReader
    FileInputStream  FileOutputStream
    BufferedWriter BufferedReader
    BufferedInputStream BufferedOutputStream
    InputStreamReader OutputStreamWriter 
      FileWriter写出操作       
      FileOutputStream写出操作
   
 *  选择流对象的时候，首先确定操作数据源是什么
        1. 文本
          FileReader读取操作
          需要高效吗？ 需要的话 BufferedReader 读一行
        2. 非文本
          FileInputStream  读取操作
          需要高效吗？需要的话BufferedInputStream  最好自己写数组
          
      3. 是控制台或者是另一个主机
         字节流  InputStream
         如果确定是文本信息，转换流InputStreamReader，转成字符流，方便操作
         
         如果不能确定是不是文本信息  决对不可以使用转换流,只能用字节流名，读取操作
        
 *  再次确定操作的数据目的是什么
      1. 文本
        FileWriter写出操作     
        需要高效吗？ 需要的话 BufferedWriter 写一行
      2. 非文本
        FileOutputStream写出操作
        需要高效吗？需要的话BufferedOutputStream  最好自己写数组
        
      3. 控制台或者是另一个主机
        字节流 OutputStream
        如果确定是文本信息，转换流OutputStreamWriter，字符转成字节，方便操作
        如果不确定是不是文本信息 只能字节流输出
       
 *  使用规律：
        当我们无法确定数据源和数据目的，只能字节流
        例如:点对点通信，服务器和客户端的通信

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------