IO流(中)

缓冲流（BufferedReader，BufferedWriter,BufferInputStream,BufferOutPutStrea,）

BufferedReader:获取字节输入流，提供一个缓冲区进行增强数据的读取

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
​
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建了缓冲流的对象
        //底层读取数据依然还是通过FileRead来读取数据的
        //缓冲流只是给字符输入流提供一个大大的缓冲区
        BufferedReader br = new BufferedReader(new FileReader("D:\\a.txt"));
        
        
        //读取数据
        //读取一行
        String str = br.readLine();
        System.out.println(str);            //读取一行  ABCABC
        System.out.println(br.readLine());  //读取一行  afasdfdsaf
        //读取数据的结束标志是返回null
        System.out.println(br.readLine());  //null  
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
​
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建了缓冲流的对象
        //底层读取数据依然还是通过FileRead来读取数据的
        //缓冲流只是给字符输入流提供一个大大的缓冲区
        BufferedReader br = new BufferedReader(new FileReader("D:\\a.txt"));
        
        
        //
        String str = null;
        while((str=br.readLine())!=null){
            System.out.println(str);
        }
    }
}

 

案例：统计工作空间中所有的.java文件有多少行

​import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
​
/*
 * 统计工作空间有多少行代码
 */
public class CountLineDemo {
    //初始化行数
    static int count = 0;
    public static void main(String[] args) throws IOException {
        //
        File file = new File("D:\\workspace");
    
        //
        countLine(file);
        System.out.println(count);
    }
​
    //查找工作目录中所有.java文件的行数
    //用与判断是否是.java文件
    public static void countLine(File file) throws IOException {
​
        //判断是否是目录
        if (file.isDirectory()) {
            //展示除目录下的所有信息
            File[] fs = file.listFiles();
            //进行遍历
            for (File f : fs) {
                //调用本方法
                countLine(f);
            }
        }else if(file.getName().endsWith(".java")){ //是个.java文件
            //读取.java文件
            //创建一个缓冲流对象 --- 字符输入流对象
            BufferedReader br = new BufferedReader(new FileReader("D:\\workspace"));
        
            //读取数据 --- 按行读取
            String str = null;
            count = 0;
            while((str=br.readLine())!=null){
                //计数
                count++;
            }
            
            //关流
            br.close();
        }
        
    }
}

 

 

模式：遇到统一的问题提供的方式

设计模式（24种）：在软件开发中，遇到的统一问题，提供的一类的解决方案

装饰者模式：利用同类（同一父类）对象，对本类的功能进行增强或者完善的过程

 

BufferedWriter:获取字符输出流（自带缓冲区），提供一个更大的缓冲区

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
​
public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException  {
        //创建一个缓冲流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\a.txt",true));
        
        //写数据
        bw.write("123");
        
        //换行
        //Window --- /r,/n
        //linux ---- /n
        bw.newLine();
        
        bw.write("123");
        
        //关流
        bw.close();
    }
}

 

内存（StringReader，StringWriter，charArrayReader，CharArrayWriter，ByteArrayInputStream，ByteArrayOutputStream）：

读取内存

import java.io.IOException;
import java.io.StringReader;
​
public class StringReaderDemo {
    public static void main(String[] args) throws IOException  {
        //这个字符串ABC在内存中
        String str = "ABC";
        
        //创建字符输入流
        //用于读取内存中的字符串
        StringReader sr = new StringReader(str);
        
        //读取数据
        char[] cs = new char[3];
​
        int len=-1;
        while((len=sr.read(cs))!=-1){
            System.out.println(new String(cs,0,len));
        }
        
        //关流
        sr.close();
    }
}

 

写入内存

import java.io.IOException;
import java.io.StringWriter;
​
public class StringWriterDemo {
    public static void main(String[] args) throws IOException  {
        //创建一个字符输出流对象
        StringWriter sw = new StringWriter();
        //往内存写入数据
        sw.write("ABC");
        //关流
        sw.close();
    }
}

 

转换流（OutPutStreamWriter）

字符流 ---- 字节流

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
​
public class OutPutStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    
        //创建转换流的对象
        //先写的数据先放到字符输出流
        //底层是通过字节流输出流往外写
        //字符流 ---- 字节流
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\a.txt"));
        
        //写出数据,同过字符流
        osw.write("acnn");
        
        //关流
        osw.close();
    }
}

 

字节流----字符流

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
​
public class InPutStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //字节流----字符流
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\a.txt"));
        
        //读取数据
        char[] cs = new char[3];
        int len = -1;
        while((len=isr.read(cs))!=-1){
            System.out.println(new String(cs,0,len));
        }
    }
}

 

 

系统流（都是字节流）

import java.io.File;
​
/*
 * 系统流
 */
public class SystemDemo {
    public static void main(String[] args){
        //会出现多线程问题
        for(int i=0;i<100;i++){
            //字节输出流  ----- 黑色
            System.out.println(1);  
            //字节输出流  ----- 红色
            System.err.println(1);  
        }
    }
}

import java.io.File;
import java.util.Scanner;
​
/*
 * 系统流
 */
public class SystemDemo {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);    //字节输入流
        
        String s = sc.nextLine();
        System.out.println(s);
        
        //关流
        sc.close();
        
        //出现异常
        //因为系统流都是静态，全局唯一，不能关闭系统流
        Scanner sc1 = new Scanner(System.in);   
        String s1 = sc.nextLine();
        System.out.println(s1);
    }
}