IO流2

//读取一个键盘录入，并打印在控制台上
/*
键盘本身就是一个标准的输入设备
对于java而言，对这种输入设备都有对应的对象 */
public static void demo_1() throws IOException{
    InputStream in = System.in;
    int ch = in.read();//阻塞式方法
    System.out.println(ch);
    //回车符两个字节
    // in.close();不用关，随系统消失而消失
}
//获取用户键盘录入的数据，并将数据转为大写，显示在控制台上，若输入over，结束键盘录入。
public static void demo_2() throws IOException{
    StringBuilder sb = new StringBuilder();
    InputStream in = System.in;
    //定义变量记录读取到的字节，并循环获取
    int ch = 0;
    while((ch=in.read())!=-1){
        //在存储之前需要判断是否是换行标记，因为换行标记不存
        if(ch=='\r')
            continue;
        if(ch=='\n')
        {
            String temp = sb.toString();
            if("over".equals(temp))
                break;
            System.out.println(temp.toUpperCase());
            sb.delete(0, sb.length());
        }
        else{
            sb.append((char)ch);
        }
    }
}

字节流和字符流之间的转换

//转换流
public static void demo_2() throws IOException{
    //字节流
    InputStream in = System.in;
    //字节流转成字符流 将字节转换成字符的桥梁：InputStreamReader
    InputStreamReader isr = new InputStreamReader(in);
    //字符流
    BufferedReader bufr = new BufferedReader(isr);
    String line = null;
    while((line=bufr.readLine())!=null){
        if("over".equals(line))
            break;
        System.out.println(line.toUpperCase());
    }
    // bufr.readLine();
}
//字符流和字节流的区别
public static void demo_3() throws IOException{
    InputStream in = System.in;
    //InputStreamReader isr = new InputStreamReader(in);
    // int ch1 = in.read();
    // System.out.println((char)ch1);
    // int ch2 = in.read();
    // System.out.println((char)ch2);
    InputStreamReader isr = new InputStreamReader(in);
    int ch = isr.read();
    System.out.println((char)ch);
}
//字符流转字节流 OutputStreamWriter
public static void demo_4() throws IOException{
    //字节流
    InputStream in = System.in;
    //字节流转成字符流 将字节转换成字符的桥梁：InputStreamReader
    InputStreamReader isr = new InputStreamReader(in);
    //字符流
    BufferedReader bufr = new BufferedReader(isr);
    OutputStream out = System.out;
    OutputStreamWriter osw = new OutputStreamWriter(out);
    BufferedWriter bw = new BufferedWriter(osw);
    String line = null;
    while((line=bufr.readLine())!=null){
        if("over".equals(line))
            break;
        // osw.write(line.toUpperCase()+"\r\n");
        // osw.flush();
        bw.write(line.toUpperCase());
        bw.newLine();
        bw.flush();
    }
}

键盘输入输出

public static void demo_5() throws IOException{
    //键盘录入
    BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    //键盘输出
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    String line = null;
    while((line=bufr.readLine())!=null){
        if("over".equals(line))
            break;
        // osw.write(line.toUpperCase()+"\r\n");
        // osw.flush();
        bw.write(line.toUpperCase());
        bw.newLine();
        bw.flush();
    }
}

需求演示

//需求演示
//将键盘录入的数据写入到文件中
public static void demo_1() throws FileNotFoundException,IOException{
    //键盘录入
    BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    //键盘输出
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:/buf.txt")));
    String line = null;
    while((line=bufr.readLine())!=null){
        if("over".equals(line))
            break;
        // osw.write(line.toUpperCase()+"\r\n");
        // osw.flush();
        bw.write(line.toUpperCase());
        bw.newLine();
        bw.flush();
    }
}
//将文本文件内容显示在控制台上
public static void demo_2() throws FileNotFoundException,IOException{
    //键盘录入
    BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("F:/buf.txt")));
    //键盘输出
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    String line = null;
    while((line=bufr.readLine())!=null){
        if("over".equals(line))
            break;
        // osw.write(line.toUpperCase()+"\r\n");
        // osw.flush();
        bw.write(line.toUpperCase());
        bw.newLine();
        bw.flush();
    }
}
//将一个文本文件中的内容复制到另一个文件中
public static void demo_3() throws FileNotFoundException,IOException{
    //键盘录入
    BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("F:/buf.txt")));
    //键盘输出
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:/buf_copy.txt")));
    String line = null;
    while((line=bufr.readLine())!=null){
        if("over".equals(line))
            break;
        // osw.write(line.toUpperCase()+"\r\n");
        // osw.flush();
        bw.write(line.toUpperCase());
        bw.newLine();
        bw.flush();
    }
}

流的基本操作规律

 转换流：
     * InputStreamReader:字节到字符的桥梁，解码
     * OutputStreamWriter:字符到字节的桥梁，编码
     * 流的操作规律：
     * 之所以要清楚这些规律是因为流对象太多，开发时不知道用哪个对象合适。
     * 想要知道开发时用到哪些对象，有四个明确：
     * 1.明确源和目的(汇)
     *   源：InputStream  Reader
     *   目的：OutputStream  Writer
     * 2.明确数据是否是纯文本数据
     *   源：是纯文本：Reader
     *       否：InputStream
     *   目的：是纯文本：Writer
     *         否：OutputStream
     *   到这里就可以明确需求中具体要使用哪个体系。
     * 3.明确具体的设备
     *   源设备：
     *       硬盘：File
     *       键盘：System.in
     *       内存：数组
     *       网路：socket流
     *   目的设备：
     *     硬盘：File
     *     控制台：System.out
     *     内存:数组
     *     网络:socket流
     * 4.是否需要其他额外功能
     *   1.是否需要高效(缓冲区)
     *     是就加Buffer

//需求1：复制一个文本文件
/*
1.明确源和目的，源：InputStream Reader  目的：OutputStream Writer
2.是否是纯文本？是：源：Reader 目的：Writer
3.明确具体设备，源：硬盘：File  目的：硬盘：File
FileReader fr = new FileReader()
FileWriter fw = new FileWriter()
4.需要额外功能吗？需要：
BufferReader br = new BufferReader(new FileReader("--"))
BufferWriter bw = new BufferWriter(new FileWriter("--"))
*/
//需求2：读取键盘录入信息并写入文件中
/*
1.明确源和目的，源：InputStream Reader  目的：OutputStream Writer
2.是否是纯文本？是：源：Reader 目的：Writer
3.明确具体设备，源：键盘：System.in  目的：硬盘：File
InputStream in = new System.in;
FileWriter fw = new FileWriter("--");
这样做可以完成，但很麻烦，将读取到的字节转换成字符串。再由字符流操作
4.需要额外功能吗？
将字节流转成字符流：
InputStreamReader insr = new InputStreamReader(System.in);
FileWriter fw = new FileWriter("--");
高效：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new FileWriter("--"));
 */
//需求3：将文本文件数据显示在控制台上
/*
 1.明确源和目的，源：InputStream Reader  目的：OutputStream Writer
 2.是否是纯文本？是：源：Reader 目的：Writer
 3.明确具体设备，源：硬盘：File  目的：System.out
 FileReader fr = new FileReader("--");
 （OutputStream out = System.out;）
 4.需要额外功能吗？
 使用字符流：
 FileReader fr = new FileReader("--");
 OutputStreamWriter ousw = new OutputStreamWriter(System.out);
 高效：
 BufferedReader br = new BufferedReader(new FileReader("--"));
 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 */
//需求4：读取键盘录入数据，显示在控制台上
/*
1.明确源和目的，源：InputStream Reader  目的：OutputStream Writer
2.是否是纯文本？是：源：Reader 目的：Writer
3.明确具体设备，源：键盘：System.in  目的：System.out
InputStream in = System.in;
OutputStream out = System.out;
4.需要额外功能吗？
使用字符流：
InputStreamReader insr = new InputStreamReader(System.in);
OutputStreamWriter ousr = new OutputStreamWriter(System.out);
高效：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 */
 public static void demo_5() throws IOException{
 //键盘录入
 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
 //键盘输出
 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 String line = null;
 while((line=bufr.readLine())!=null){
     if("over".equals(line))
         break;
     // osw.write(line.toUpperCase()+"\r\n");
     // osw.flush();
     bw.write(line.toUpperCase());
     bw.newLine();
     bw.flush();
 }
}

将一个中文字符串数据按照指定的编码表写入到文本文件中

//需求5：将一个中文字符串数据按照指定的编码表写入到文本文件中
/*
1.目的：OutputStream Writer
2.是纯文本：Writer
3.设备，硬盘：File
FileWriter fw = new FileWriter("--");
fw.write("你好");

注意：既然需求中明确指定了编码表，那就不能使用FileWriter,因为FileWriter默认使用本地指定的编码表
    只能使用其父类：OutputStreamWriter
    OutputStreamWriter接收一个字节输出流对象，既然是操作文件，那么该对象应该是FileOutputStream
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("--"),"UTF-8");

需要高效吗？
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("--"),"UTF-8"));

什么时候用转换流？
    1.源或者目的对应的设备是字节流，但操作的是文本数据，可以使用转换流作为桥梁。
    提高对文本操作的便捷。
    2.一旦操作文本涉及到具体的指定编码表时，必须使用转换流。
 */
public static void demo_1() throws IOException{
    FileWriter fw = new FileWriter("F:/buf.txt");
    fw.write("你好");
    fw.close();
}
public static void demo_2() throws IOException{
    OutputStreamWriter opsw = new OutputStreamWriter(new FileOutputStream("F:/buf.txt"),"GBK");
    FileWriter fw = new FileWriter("F:/buf.txt");
    /**
     * 这两句代码的功能是相同的
     * FileWriter:其实就是转换流指定了本机默认码表的体现。而且这个转换流的子类对象，可以方便操作文本文件。
     *          简单说：操作文件的字节流+本机默认的编码表。
     *          这是按照默认码表来操作文件的便捷类。
     * 如果操作文本文件需要明确具体的编码，FileWriter就不行了，必须用转换流。
     */
    opsw.write("平安");
    opsw.close();
}
public static void demo_3() throws IOException{
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("F:/buf.txt"),"UTF-8");//"UTF-8"
    osw.write("你好");
    osw.close();
}
public static void read_demo1() throws IOException{
    FileReader fr = new FileReader("F:/buf.txt");
    char[] buf = new char[10];
    int len = fr.read(buf);
    String str = new String(buf,0,len);
    System.out.println(str);
    fr.close();
}
public static void read_demo2() throws IOException{
    InputStreamReader isr = new InputStreamReader(new FileInputStream("F:/buf.txt"),"GBK");//UTF-8
    char[] buf = new char[10];
    int len = isr.read(buf);
    String str = new String(buf,0,len);
    System.out.println(str);
    isr.close();
}