java基础之IO

java基础之IO

1，字节流与字符流常用方法：
public class testIO {
    /**
     * 字符输入输出流实现文件的复制(类比字节操作)
     * @throws IOException 
     * 
     */
    @Test
    public void testWriterReaderFileCopy() throws IOException{
        
        Reader read = new FileReader("cyq1.txt");
        
        Writer write = new FileWriter("cyq3.txt");
        
        char [] c = new char[1024];
        int len = 0;
        
        while((len = read.read(c)) != -1){
             write.write(c, 0, len);
        }
        
        read.close();
        write.close();
    }
    
    /**
     * 字节输入输出流实现文件的复制：
     * @throws IOException 
     */
    
    @Test
    public void testFileCopy() throws IOException{
        //1,创建输入流对象,输出流对象
        InputStream in = new FileInputStream("cyq.txt");
        
        OutputStream out = new FileOutputStream("cyq2.txt");
        
        int len = 0;
        
        //字节数组用于读写文件
        byte [] buffer = new byte[1024];
        
        //读写操作
        while((len = in.read(buffer))!=-1){
            out.write(buffer,0,len);
            //write(b, off, len) 的常规协定是：将数组 b 中的某些字节按顺序写入输出流；元素 b[off] 
            //是此操作写入的第一个字节，b[off+len-1] 是此操作写入的最后一个字节
        }
        
        in.close();
        out.close();
    }
    
    /**
     * 测试字节输出流OutputStream(典型实现类FileOutputStream)
     * @throws IOException 
     */
    @Test
    public void testOutputStream() throws IOException{
        OutputStream out = new FileOutputStream("cyq1.txt");
        String content = "java study cyq\nwww.baidu.com";
        //getBytes()将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
        out.write(content.getBytes());
        out.close();
    }
    
    /**
     * 测试字节输入流InputStream
     */
    @Test
    public void testInputStream() throws IOException{
        
        //InputStream是一个抽象类，不能用它来创建对象，因此要借助FileInputStream类来实现。
        InputStream in = new FileInputStream("cyq.txt");
        //一次读一组：一组字符
        byte [] buffer = new byte[10];//创建一个字节数组，长度为10
        int len = 0;
        while((len = in.read(buffer))!=-1){//in.read(buffer))返回的是读取的字节数
            for(int i=0;i<len;i++){
                System.out.print((char)buffer[i]);
            }
        }
        in.close();
    }
    
    
    /**
     * 测试字符输入流Reader（也是一个抽象类,典型实现类是FileReader）
     * 可以类比字节输入流的使用
     * @throws IOException 
     */
    @Test
    public void testReader() throws IOException{
        
        Reader reader = new FileReader("cyq.txt");
        
        //创建一个字符数组
        char [] c = new char[10];
        int len = 0;
        while((len = reader.read(c))!=-1){
            
            for(int i = 0;i<len;i++){
                System.out.print(c[i]);
            }
        }
        
        reader.close();
    }
}
2，缓冲流
public class testBuffered {
    /**
     * 使用BufferedWriter和BufferedReader完成文件的复制
     * @throws IOException 
     */
    @Test
    public void testBufferedWriterAndBufferedReader() throws IOException{
        //1，创建BufferedWriter和BufferedReader对象是需要传一个字符流对象
        Reader in = new FileReader("cyq.txt");
        BufferedReader bufferedReader = new BufferedReader(in);
        
        Writer out = new FileWriter("cyq4.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(out);
        
        String str = null;
        int i = 0;
        
        //readLine()整行的读取
        while((str = bufferedReader.readLine()) != null){
            //字符缓冲流不会读取换行，所以当文件有换行时，需要加入换行
            if(i != 0)
                bufferedWriter.write("\n");
            //意思是：在除了第一行外的每一行前面都加入一个换行
            bufferedWriter.write(str);
            i++;
        }
        
        //只需关闭缓冲流，应为在关闭缓冲流的时候，内部已经关闭了字节流了。
        bufferedWriter.close();
        bufferedReader.close();
    }
    
}
（BufferedInputStream和BufferedOutputStream类比BufferedWriter和BufferedReader的使用）

总结：字符流只用于读写文本文件，当文件是音频或视频文件时，保存的时候是以二进制形式保存的，所以要用       字节流来读写，当读写文本文件时，字符流的效率要高于字节流。