Java入门需要了解（转换流-三十七）

最新推荐文章于 2023-08-10 08:30:00 发布

末贵

最新推荐文章于 2023-08-10 08:30:00 发布

阅读量101

点赞数

分类专栏： java学习分享记录文章标签： java 编程语言字符串流处理 javase

本文链接：https://blog.csdn.net/moguicy123/article/details/112857460

版权

java学习分享记录专栏收录该内容

43 篇文章 0 订阅

订阅专栏

流转换目录

InputStream 读取键盘录入
InputStream 读取键盘录入（over结束）
转换流 InputStreamReader （字节流-字符流）
字节与字符读取的区别
- 读取字节流
- 通过转换流读取字符
OutputStreamWriter
转换流的概念和使用规律
按照指定编码存储文本文件

InputStream 读取键盘录入

System.in 这个流对象只有一个，不需要关闭，他随系统的启动而启动，随系统的关闭而关闭。默认输入输出设备不需要关闭

class OutInTest {
    public static void main(String[] args) throws IOException {
        inTest();
    }

    public static void inTest() throws IOException {
        InputStream in = System.in;
        int ch = in.read();//阻塞式方法
        System.out.println("ch = " + (char)ch);
    }
}

InputStream 读取键盘录入（over结束）

键盘输入的内容转为大写打印在控制台上，如果输入over则结束运行。但是输入中文则会出现问题


import java.io.IOException;
import java.io.InputStream;

class OutInTest {
    public static void main(String[] args) throws IOException {
        inTest2();
    }

    public static void inTest2() throws IOException {
        //创建零时存储输入内容的容器
        StringBuilder stringBuilder = new StringBuilder();
        //获取键盘输入流
        InputStream in = System.in;
        //定义每次存储读取内容的变量
        int ch = 0;
        while ((ch = in.read()) != -1) {
            if (ch == '\r') {
                continue;
            }
            if (ch == '\n') {
                String temp = stringBuilder.toString();
                if ("over".equals(temp)) {
                    break;
                } else {
                    System.out.println(temp.toUpperCase());
                    stringBuilder.delete(0,stringBuilder.length());
                }
            } else {
                stringBuilder.append((char)ch);
            }
        }
    }
}

转换流 InputStreamReader （字节流-字符流）

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
字节流+编码表组成了转换流

读取一行内容并打印出来，输入over结束读取，同时这样的方式也解决了中文输入的问题。


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

class OutInTest2 {
    public static void main(String[] args) throws IOException {
        readLineTest();
    }

    public static void readLineTest() throws IOException {
        //获取键盘输入字节流
        InputStream inputStream = System.in;
        //创建字节流和字符流的桥梁-转换流
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        //创建字符流
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            }
            System.out.println("line = " + line);
        }
    }

}

字节与字符读取的区别

读取字节流


import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

class OutInTest3 {
    public static void main(String[] args) throws IOException {
        readByte();
    }
	/**
     * 通过标准输入流读取内容
     */
    public static void readByte() throws IOException {
        //获取键盘输入字节流,中文是两个字节
        InputStream inputStream = System.in;
        int ch = inputStream.read();
        System.out.println((char)ch);
        int ch1 = inputStream.read();
        System.out.println((char)ch1);
    }
}

通过转换流读取字符


import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

class OutInTest3 {
    public static void main(String[] args) throws IOException {
        readChar();
    }
    /**
     * 通过转换流读取
     */
    public static void readChar() throws IOException {
        //获取键盘输入字节流
        InputStream inputStream = System.in;
        //创建字节流和字符流的桥梁-转换流
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        //创建字符流
        int chReader  =inputStreamReader.read();
        System.out.println((char)chReader);

    }

}

OutputStreamWriter

OutputStreamWriter 是字符流通向字节流的桥梁

键盘输入输出eg

读取：通过System.in获取标准输入流，再通过转换流InputStreamRead和BufferedReader 每次读取一行内容并将其转换为字符串。
输出：通过System.out获取标准输出流，再通过转换流OutputSreamWriter和BufferWriter每次输出一行内容到控制台上。


import java.io.*;

class OutputStreamWriterTest {
    public static void main(String[] args) throws IOException {
        outTest();
    }

    public static void outTest() throws IOException {
        //定义输入
        InputStream inputStream = System.in;//获取到的是字节
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);//把字节转换为字符
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);//把字符读取到缓冲区中

		//输出的时候跟读取的时候的理解顺序相反
        //定义输出
        OutputStream out = System.out;//接收到转换流写入的字节，转换流是字节流和字符流的桥梁。
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(out);
        BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);//接收到缓冲区的字符串数据，bufferedWriter.write(line);，其目的地是OutputStream out = System.out;
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            }
            bufferedWriter.write(line);//把字符串写入缓冲区，这个字符串的接收地是bufferedWriter 
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }

    }

}

键盘输入输出eg代码简化

经过简化版的代码从逻辑上更容易理解内容的流向。
inputStream->InputStreamReader->BufferedReader->bufferedReader.readLine()
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));


import java.io.*;

class OutputStreamWriterTest2 {
    public static void main(String[] args) throws IOException {
        outTest();
    }

    public static void outTest() throws IOException {
        //定义输入，这就像是套了好几个管子一样把输入的内容从一个地方引流到另外一个地方inputStream->InputStreamReader->BufferedReader->bufferedReader.readLine()
        //这里的内容是从左到右的inputStream->InputStreamReader->BufferedReader->bufferedReader.readLine()
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        //定义输出这就像是套了好几个管子一样把输入的内容从一个地方引流到另外一个地方
        //接管子的方式跟输入一样：OutputStream->OutputStreamWriter->BufferedWriter-> bufferedWriter.write(line).
        //但是这里的内容流动顺序是这样的：bufferedWriter.write(line)->BufferedWriter->OutputStreamWriter->OutputStream
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            }
            bufferedWriter.write(line);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
    }

}

将键盘输入写入到文件中

这个例子就是在上个例子中修改了输入流之后，其他的几乎没有动过

import java.io.*;

class Output2FileTest {
    public static void main(String[] args) throws IOException {
        outTest();
    }

    public static void outTest() throws IOException {
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		//这里把System.out换成了new FileOutputStream("Output2FileTest.txt")
         BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("Output2FileTest.txt")));
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            }
            bufferedWriter.write(line);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
    }
}

将一个文本文件的内容打印在控制台上

这是在上一个基础上进行稍微改进的例子，输出地为控制台，所以输出就直接使用System.out.println(“xxx”)的方式，所以只要修改输入流的地方即可完成。


import java.io.*;

class ShowTxtFile2ConsoleTest {
    public static void main(String[] args) throws IOException {
        outTest();
    }

    public static void outTest() throws IOException {
    	//因为需要读取一个文件，所以把System.in修改为new FileInputStream("Output2FileTest.txt")
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("Output2FileTest.txt")));
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            }
            System.out.println(line);
        }
    }
}

复制一个文件

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(“Output2FileTest.txt”)));
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“Output2FileTest_copy.txt”)));


import java.io.*;

class CopyTxtTest {
    public static void main(String[] args) throws IOException {
        copyTest();
    }

    public static void copyTest() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("Output2FileTest.txt")));

        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("Output2FileTest_copy.txt")));
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            if ("over".equals(line)) {
                break;
            }
            bufferedWriter.write(line);
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedReader.close();
        bufferedWriter.close();
    }

}

转换流的概念和使用规律

InputStreamReader :输入流，从字节到字符的桥梁，解码的过程。
OutputStreamWriter:输出流，从字符到字节的桥梁，编码的过程
操作规律：
1. 先确定确定流的源头和目的地。
  针对源头的体系中只有 InputStream 和 Reader
  对于目的地的体系中只有 OutputSream 和 Writer
2. 明确数据是文本数据
  源头是纯文本，使用reader，不使用InputStream
  目的地是纯文本：使用Writer ，不使用OutputStream
3. 明确具体的设备。
  源头设备：硬盘（File），键盘（System.in），内存（数组），网络（Socket流）
  目的设备：硬盘（File），控制台（System.out），内存（数组），网络（Socket流）
4. 是否需要其他功能（增强功能）
  是否需要缓冲区等

按照指定编码存储文本文件

使用指定编码表存储内容到一个指定的文件

要指定编码表，就必须要使用转换流


import java.io.*;

class SetCharCodeTest {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter outputStreamWriter= new OutputStreamWriter(new FileOutputStream("set_code.txt"),"utf-8");
        outputStreamWriter.write("你好");
        outputStreamWriter.close();
    }
}

使用默认编码表存储内容到一个文件

import java.io.FileWriter;
import java.io.IOException;

class DefaultCharCodeTest {
    public static void main(String[] args) throws IOException {
        FileWriter fileWriter = new FileWriter("default_char_set.txt");
        fileWriter.write("你好");
        fileWriter.close();
    }
}

使用默认编码读取文本文件

import java.io.FileReader;
import java.io.IOException;

class DeFaultCharsetReadTest {
    public static void main(String[] args) throws IOException {
        FileReader fileReader = new FileReader("default_char_set.txt");
        char[] chars = new char[1024];
        int len = 0;
        while ((len = fileReader.read(chars)) != -1) {
            String str = new String(chars);
            System.out.println("str = " + str);
        }
        fileReader.close();
    }
}

使用指定编码读取文件

使用指定的编码读取文件时，必须使用转换流 InputStreamReader


import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

class SetCharsetReadTest {
    public static void main(String[] args) throws IOException {
        //这个文件是我们之前使用utf-8编码存储的文件
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("set_code.txt"),"utf-8");
        //InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("set_code.txt"),"gbk");
        //InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("default_char_set.txt"),"utf-8");

        char[] chars = new char[1024];
        int len = 0;
        while ((len = inputStreamReader.read(chars)) != -1) {
            String str = new String(chars);
            System.out.println("str = " + str);
        }
        inputStreamReader.close();
    }
}

末贵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java入门需要了解（转换流-三十七）

“标准”输出流out(PrintStream),"标准"输入流（InputStream），这两个流在控制台中比较常用，System.out,以及System.in,转换流InputStreamRead和OutputStreamWriter的使用
复制链接

扫一扫

专栏目录