IO流，字符流出现的原因，String中的编解码问题，转换流

最新推荐文章于 2021-01-28 02:16:27 发布

你的笑容灿烂了这个夏天

最新推荐文章于 2021-01-28 02:16:27 发布

阅读量232

点赞数

分类专栏： Java语言基础

本文链接：https://blog.csdn.net/weixin_44823472/article/details/90453331

版权

Java语言基础专栏收录该内容

21 篇文章 0 订阅

订阅专栏

字符流出现的原因及编码表概述和常见编码表

字符转换流
OutputStreamWriter 是字符流通向字节流的桥梁：
可使用指定的编码表将要写入流中的字符编码成字节。
它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
编码和解码
编码：把字符串转换成字节数组，把看的懂的转换成看不懂的
解码：把字节数组转换成字符串，把看不懂的，转换成看的懂
乱码：编解码采用的码表不一致，就会导致乱码
byte[] getBytes ()
使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] getBytes (Charset charset)
使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。
码表：

ASCII

GB2312

GBK

UNICODE(usc-2 , usc-4)

UTF-8

tring类中的编码和解码问题

编码: 就是把字符串转换成字节数组
public byte[] getBytes();使用平台的默认字符集将此 String编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
public byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
解码: 把字节数组转换成字符串
public String(byte[] bytes): 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
public String(byte[] bytes, String charsetName) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。

使用什么字符集进行编码,那么就是使用什么字符集进行解码

String str = "你好中国";
byte[] bytes = str.getBytes("UTF-8"); //编码

//String( byte[] bytes)
//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
//String( byte[] bytes, Charset charset)
//通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。

String s = new String(bytes, "UTF-8");//解码
System.out.println(s);

转换流OutputStreamWriter的使用

OutputStreamWriter的构造方法
OutputStreamWriter(OutputStream out):根据默认编码(GBK)把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流

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


        //OutputStreamWriter(OutputStream out, Charset cs)
        //创建使用给定字符集的 OutputStreamWriter。
        //OutputStreamWriter(OutputStream out, String charsetName)
        //创建使用指定字符集的 OutputStreamWriter。
        //参数2：可以指定码表
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("a.txt",true), "UTF-8");
        out.write("你好中国，跟我一起好吗");
        out.write("\r\n"); //写入换行符
        out.write("你好中国，跟我一起好吗",0,5);//写字符串的一部分，从 0开始，写5个字符
        out.flush();
        out.close();
    }
}

字符流的5种写数据的方式

方法概述
public void write(int c) 写一个字符
public void write(char[] cbuf) 写一个字符数组
public void write(char[] cbuf,int off,int len) 写一个字符数组的一部分
public void write(String str) 写一个字符串
public void write(String str,int off,int len) 写一个字符串的一部分

转换流InputStreamReader的使用

InputStreamReader的构造方法
InputStreamReader(InputStream is):用默认的编码(GBK)读取数据
InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据

public class MyTest {
    public static void main(String[] args) throws IOException {
        //InputStreamReader 是字节流通向字符流的桥梁：
        //它使用指定的 charset 读取字节并将其解码为字符。
        //它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
       // InputStreamReader
       // InputStreamReader(InputStream in)
       // 创建一个使用默认字符集的 InputStreamReader。
       // InputStreamReader(InputStream in, Charset cs)
       // 创建使用给定字符集的 InputStreamReader。
        //输入流，所关联的文件如果不存在就会报错
        InputStreamReader in = new InputStreamReader(new FileInputStream("c.txt"));
        int len = in.read(); //一次读取一个字符
        System.out.println(len);
        len = in.read(); //一次读取一个字符
        System.out.println(len);
        len = in.read(); //一次读取一个字符
        System.out.println(len);
        len = in.read(); //一次读取一个字符
        System.out.println(len);
        len = in.read(); //一次读取一个字符
        System.out.println(len);
        len = in.read(); //一次读取一个字符
        System.out.println(len);
        len = in.read(); //一次读取一个字符
        System.out.println(len); //如果读取不到有效字符，返回 -1 我们就会拿-1 判断这个文件是否读完
        in.close();
    }
}

字符流复制文本文件

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        InputStreamReader in = new InputStreamReader(new FileInputStream("d.txt"));
        //定义一个容器
        char[] chars = new char[100];
       // int len = in.read(chars); //一次读取一些字符，放到字符数组中，返回的是实际读取到的有效字符个数
        int len = in.read(chars, 0, 17);//从0开始读，读取17个字符放到容器中
        System.out.println(len);

        System.out.println("------------------");
        //for (char ch : chars) {
        //    System.out.println(ch);
        //}
        System.out.println(new String(chars,0,len));
        System.out.println(String.valueOf(chars,0,len));

        in.close();

    }
}

FileWriter和FileReader复制文本文件

FileReader和FileWriter的出现
转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，
所以，为了简化我们的书写，转换流提供了对应的子类。
FileWriter
FileReader

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

        // 父类                  子类 便捷类 不能指定码表，用的是默认码表
       // InputStreamReader---- FileReader
      //  OutputStreamWriter---- FileWriter

        FileReader reader = new FileReader("MyTest.java");
        FileWriter writer = new FileWriter("MyTest134.java");
        char[] chars = new char[1000];
        int len=0;
        while ((len=reader.read(chars))!=-1){
            writer.write(chars,0,len);
            writer.flush();
        }
        reader.close();
        writer.close();
    }
}

字符缓冲流的基本使用

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        //高效的字符流 里面有特有的方法比较好用
        // BufferedReader
        //  BufferedWriter

        BufferedReader bfr = new BufferedReader(new FileReader("MyTest134.java"));
        BufferedWriter bfw = new BufferedWriter(new FileWriter("MyTest1344444.java"));
        char[] chars = new char[1000];
        int len = 0;
        while ((len = bfr.read(chars)) != -1) {
            bfw.write(chars, 0, len);
            bfw.flush();
        }
        bfr.close();
        bfw.close();

    }
}

把集合中的数据存储到文本文件

public class MyTest {
    public static void main(String[] args) throws IOException {
        //需求：把ArrayList集合中的字符串数据存储到文本文件
        //分析:
        ArrayList<String> list = new ArrayList<>();
        list.add("冯小刚");
        list.add("张艺谋");
        list.add("宁浩");
        list.add("徐峥");
        list.add("小四");
        //把集合中的数据保存到文件文件中
        //思路，遍历集合，取出数据写入文本文件
        BufferedWriter writer = new BufferedWriter(new FileWriter("username.txt"));
        for (String s : list) {
            writer.write(s);
            writer.newLine();
            writer.flush();
        }
        writer.close();
    }
}

把文本文件中的数据存储到集合中

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        //需求是，把文本文件中的数据读取到集合中
        ArrayList<String> list = new ArrayList<>();
        BufferedReader reader = new BufferedReader(new FileReader("username.txt"));
        while (true){
            String s = reader.readLine();
            if(s!=null){
                list.add(s);
            }else{
                break;
            }

        }

        System.out.println(list);
    }
}

随机获取文本文件中的姓名

public class MyTest3 {
    public static void main(String[] args) throws IOException {
        //   需求：我有一个文本文件，每一行是一个学生的名字，请写一个程序，每次允许随机获取一个学生名称
        
        BufferedReader bfr = new BufferedReader(new FileReader("username.txt"));
        ArrayList<String> list = new ArrayList<>();
        while (true) {
            String s = bfr.readLine();
            if (s != null) {
                list.add(s);
            } else {
                break;
            }
        }
       // System.out.println(list);
        Random random = new Random();
        //生成一个随机索引
        int index = random.nextInt(list.size());
        String s = list.get(index);
        System.out.println(s);
        //程序跟数据进行解耦

    }
}

复制单级文件夹

public class MyTest {
    public static void main(String[] args) throws IOException {
        //复制单级文件夹

        //1.封装源文件夹
        File srcFolder = new File("E:\\test");
        //2.封装目标文件夹
        File targetFolder = new File("D:\\test");
        if (!targetFolder.exists()) {
            targetFolder.mkdirs();
        }
        //进行复制
        copyFolder(srcFolder, targetFolder);

        System.out.println("复制完成");

    }

    private static void copyFolder(File srcFolder, File targetFolder) throws IOException {
        //遍历源文件夹下，所有的文件，复制到目标文件夹下去
        File[] files = srcFolder.listFiles();
        for (File f : files) {
            if(f.isFile()){
                copyFiles(f, targetFolder);
            }else{
                //递归
            }
        }
    }


    //复制文件
    private static void copyFiles(File f, File targetFolder) throws IOException {
        //使用字节流来复制
        FileInputStream in = new FileInputStream(f);//封装源文件
        //封装目标文件
        //File file = new File(targetFolder, f.getName());
        //System.out.println(file);
        FileOutputStream out = new FileOutputStream(new File(targetFolder, f.getName()));
        int len = 0;
        byte[] bytes = new byte[1024 * 8];
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
            out.flush();
        }
        //是否资源
        in.close();
        out.close();

    }
}

你的笑容灿烂了这个夏天

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流，字符流出现的原因，String中的编解码问题，转换流

字符流出现的原因及编码表概述和常见编码表字符转换流OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的编码表将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。编码和解码编码：把字符串转换成字节数组，把看的懂的转换成看不懂的解码：把字节数组转换成字符串，把看不懂的，转换成看的懂乱码：编解码采用的码表不...
复制链接

扫一扫