IO流之流

　　流的分类

　　按照流向分为：输入流和输出流。

　　按照处理单位分为：字节流和字符流

　　按照功能为：节点流和转换流。

 

　　　InputStream（字节输入流） / OutputStream（字节输出流）

　　InputStream是所有字节输入流的抽象父类，提供了

　　read（）：从数据源中读取一个字节  （返回值为读取的字节，输出需要转换为字符型。若读取超过字节的长度返回-1）

　　read（byte [ ] buf）：读取一定数量的字节到缓冲数组buf中

 

　　OutputStream是所有字节输出流的抽象父类，提供了

　　write（）：写入一个字节到数据源

　　write（byte [] buf）：写入一定量的字节到缓冲数组buf中

 

　　FileInputStream 文件字节输入流：专门用于从文件中读取字节到程序内存中。即为流通道

　　FileOutputStream 文件字节输出流：专门用于从程序内存写入字节到文件中。即为流通道

　　

　　读取一个字节：

public static void main(String[] args) {

        // 需求:读取一个文件中的一个字节
        File file = new File("d:\\sxt2019\\a.txt");
        
        try {
            //1.创建通道
            FileInputStream in=new FileInputStream(file);
            
            int t;
            StringBuilder sb=new StringBuilder();
            try {
                //2.读取单个字节，输出时要转换为char类型
                t=in.read();
                t=in.read();
                t=in.read();
                t=in.read();
                System.out.println((char)t);
                
                
                //3.关闭通道
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
}

 

　　　　　　读取多个字节：

ublic static void main(String[] args) throws FileNotFoundException {
        File file = new File("d:\\sxt2019\\a.txt");
        
        //1.创建通道
        FileInputStream fileInputStream=new FileInputStream(file);
        
        //2.创建字节数组
        byte[] buf=new byte[5];
        
        int len;
        
        StringBuilder sb=new StringBuilder();
        //3.循环读取字节到字节数组中
        try {
            while((len=fileInputStream.read(buf))!=-1){
                
                //4.字节转换为字符串
                String string=new String(buf, 0, len);
                sb.append(string);
                                    
                
            }
            System.out.println(sb);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

 

　　　　　　　　按照指定编码写入文件中：　

public static void main(String[] args) throws IOException {
        File file = new File("d:\\sxt2019\\b.txt");
        
        //1.创建流通道（文件字节输出流）
        FileOutputStream fileOutputStream=new FileOutputStream(file);
        
        //2.要写入的字符串
        String str="i love you";
        //3.字符串按规定编码转换为字节数组
        byte[] b=str.getBytes("UTF-8");
        //4.通过通道写入文件
        fileOutputStream.write(b);
        //5.关闭通道
        fileOutputStream.close();
    }

 

　　　　　　从指定路径复制图片到工程目录中：

public static void main(String[] args) throws IOException {
        File orFile=new File("d:\\sxt2019\\hzu.jpg");
        File toFile=new File("hzu.jpg");
        
        long fileSize=orFile.length();
        long cpysize=0;
        float progress=0.0f;
        
        FileInputStream fileInputStream=new FileInputStream(orFile);
        FileOutputStream fileOutputStream=new FileOutputStream(toFile);
        
        byte[] buf=new byte[512];
        
        int len;
        while((len=fileInputStream.read(buf))!=-1){
            fileOutputStream.write(buf, 0, len);
            
            cpysize+=len;
            progress=cpysize*1.0f/fileSize;
            System.out.println(progress);
        }
        fileInputStream.close();
        fileOutputStream.close();
        System.out.println("复制完成！");
        
    }

 

　　　　

　　　　Reader（字符输入流） / Writer（字符输出流）

　　　　Reader是字符输入流的抽象父类，提供了

　　read（）：一次读取一个字符

　　read（char[] cbuf）：一次读取多个字符到字符缓冲区cbuf中，返回的值为读取的字符个数。

　　
　　Writer是字符输出流的抽象父类，提供了

　　write（）：一次写入一个字符

　　write（char[] cbuf）：一次写入多个字符到字符缓冲区cbuf中，返回的值为写入的字符个数。

　　write（String）：写入字符串

 

　　FileReader 文件字符输入流 ，专门用于读取默认字符编码（GBK）文本文件。

　　FileWriter 文件字符输出流 ，专门用于写入默认字符编码（GBK）文本文件。注意：为了提高效率，FileWriter内部存在一个字节缓冲区，用于对待写入的字符进行统一编码到字节缓冲区，一定要在关闭流之前，调用flush方法刷新缓冲区。

　　　　

　　　　读取一个或多个字符到字符缓冲区cbuf：

　　　　

public static void main(String[] args) throws IOException {

            File file = new File("d:\\sxt2019\\a.txt");
        
        FileReader reader = new FileReader(file);
        
        // 【1】一次读取一个字符
        
        /*int c;
        c = reader.read();
        c = reader.read();
        c = reader.read();
        c = reader.read();
        c = reader.read();
        System.out.println((char)c);
*/
        char[] cbuf=new char[2];
        int len;
        StringBuilder sb=new StringBuilder();
        while ((len=reader.read(cbuf))!=-1){
            sb.append(cbuf, 0, len);
            
        }
        System.out.println(sb);
        
        reader.close();
    }

　　　　　　

　　　　写入字符到文件中：

public static void main(String[] args) throws IOException {
        File file = new File("d:\\sxt2019\\b.txt");
        
        FileWriter writer=new FileWriter(file);
        
        //写入一个字符
        /*writer.write('9');*/
        
        
        //写入多个字符
        /*char[] cbuf={'i','l','o','v','e',' ','y'};
        writer.write(cbuf);*/
        
        //写入一个字符串
        String string="i like you";
        writer.write(string);
        
        
        writer.flush();
        writer.close();

    }