• java----IO流：字符流

    字节和字符的桥梁
    1. package IO流.字符流;
    2. /*
    3.     InputStreamReader是从字节流到字符流的桥梁：
    4.         它读取字节，并使用指定的charset将其解码为字符。
    5.         它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
    7.     OutputStreamWriter是从字符流到字节流的桥梁：
    8.         使用指定的charset将写入的字符编码为字节。
    9.         它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。
    10.  */
    11.  
    12. import java.io.*;
    13.  
    14. public class 字节和字符的桥梁 {
    15.     public static void main(String[] args) throws IOException {
    16.         //OutputStreamWriter​(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
    17.         //OutputStreamWriter​(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。
    18.         OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("idea_text\\osw.txt"));
    19.         osw.write("中国");
    20.         osw.close();
    21.  
    22.  
    23.         //InputStreamReader​(InputStream in) 创建一个使用默认字符集的InputStreamReader。
    24.         //InputStreamReader​(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。
    25.         InputStreamReader isr = new InputStreamReader(new FileInputStream("idea_text\\osw.txt"));
    26.         //一次读取一个字符数据
    27.         int ch;
    28.         while ((ch = isr.read()) != -1) {
    29.             System.out.println((char)ch);
    30.         }
    31.  
    32.         isr.close();
    33.  
    34.     }
    35. }
    字符串中的编码解码问题
    1. package IO流.字符流;
    2. /*
    3. 字符串中的编码解码问题
    5.     编码:
    6.         byte[]getBytes():
    7.         使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
    8.         byte[]getBytes(String charsetName):
    9.         使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
    11.     解码:
    12.         String(byte[]bytes):
    13.         通过使用平台的默认字符集解码指定的字节数组来构造新的String
    14.         String(byte[]bytes,String charsetName):
    15.         通过指定的字符集解码指定的字节数组来构造新的String
    16.  */
    17.  
    18.  
    19. import java.io.UnsupportedEncodingException;
    20. import java.util.Arrays;
    21.  
    22. public class 字符串中的编码解码问题 {
    23.     public static void main(String[] args) throws UnsupportedEncodingException {
    24.         //定义一个字符串
    25.         String s="中国";
    26.  
    27.         //编码：
    28.         //byte[]getBytes():
    29.         byte[] bys=s.getBytes();//[-28, -72, -83, -27, -101, -67]
    30.         //byte[]getBytes(String charsetName):
    31.         byte[] bytes=s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
    32.         byte[] bytess=s.getBytes("GBK");//[-42, -48, -71, -6]
    33.  
    34. //        System.out.println(Arrays.toString(bytess));
    35.  
    36.  
    37.         //解码：
    38.         //String(byte[]bytes):
    39.         String ss=new String(bys);//中国
    40.         //String(byte[]bytes,String charsetName):
    41.         String sss=new String(bys,"UTF-8");//中国
    42.         String ssss=new String(bys,"GBK");//涓浗
    43.  
    44.  
    45. //        System.out.println(ssss);
    46.  
    47.     }
    48. }
    
字符流写数据的5种方式
    1. package IO流.字符流.字符流写数据的5种方式;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6. import java.io.OutputStreamWriter;
    7.  
    8. /*
    9.         构造方法：
    10.             OutputStreamWriter​(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
    12.         写数据的5种方式
    13.             void write​(int c) 写一个字符
    14.             void write​(char[] cbuf) 写一个字符数组。
    15.             void write​(char[] cbuf, int off, int len) 写入字符数组的一部分。
    16.             void write​(String str) 写一个字符串。
    17.             void write​(String str, int off, int len) 写一个字符串的一部分。
    19.             void close​() 关闭流，先刷新。
    20.             void flush​() 刷新流。
    22.  */
    23. public class Demo {
    24.     public static void main(String[] args) throws IOException {
    25.         //OutputStreamWriter​(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。
    26.         OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("idea_text\\osw.txt"));
    27. /*
    28.         //void write​(int c) 写一个字符
    29.         osw.write("97");//无显示
    31.         //void flush​() 刷新流。
    32.         osw.flush();//有显示97
    33.         osw.write("98");
    34.         osw.flush();
    35.         osw.write("99");
    37.         //释放资源
    38.         osw.close();//直接释放，不用刷新了，99也会显示
    39. //        osw.write("100");//IOException: Stream closed
    41.         */
    42.  
    43.         //void write​(char[] cbuf) 写一个字符数组。
    44.         char[] chs = {'a', 'b', 'c', 'd', 'e'};
    45. //        osw.write(chs);
    46.         // void write​(char[] cbuf, int off, int len) 写入字符数组的一部分。
    47. //        osw.write(chs,0,chs.length);
    48. //        osw.write(chs,1,3);
    49.  
    50.         //void write​(String str) 写一个字符串。
    51.         osw.write("abcde");
    52.         //void write​(String str, int off, int len) 写一个字符串的一部分。
    53.         osw.write("abcde",0,"abcde".length());
    54.         osw.write("abcde",1,3);
    55.  
    56.         //释放资源
    57.         osw.close();
    58.  
    59.  
    60.     }
    61. }
    字符流读数据的2种方式
    1. package IO流.字符流.字符流读数据的2种方式;
    2. /*
    3.         构造方法
    4.             InputStreamReader​(InputStream in) 创建一个使用默认字符集的InputStreamReader。
    6.         2种方式
    7.             int read​() 一次读一个字符数据
    8.             int read​(char[] cbuf) 一次读一个字符数组数据
    10.  */
    11.  
    12. import java.io.FileInputStream;
    13. import java.io.FileNotFoundException;
    14. import java.io.IOException;
    15. import java.io.InputStreamReader;
    16.  
    17. public class Demo {
    18.     public static void main(String[] args) throws IOException {
    19.         //InputStreamReader​(InputStream in) 创建一个使用默认字符集的InputStreamReader。
    20.         InputStreamReader isr = new InputStreamReader(new FileInputStream("idea_text\\osw.txt"));
    21. /*
    23.         //int read​() :一次读一个字符数据
    24.         int ch;
    25.         while ((ch = isr.read()) != -1){
    26.             System.out.println((char) ch);
    27.         }
    28. */
    29.  
    30.  
    31.         //int read​(char[] cbuf) 一次读一个字符数组数据
    32.         char[] chs=new char[1024];
    33.         int len;
    34.         while ((len = isr.read()) != -1){
    35.             System.out.println(new String(chs, 0, len));
    36.         }
    37.  
    38.         //释放资源
    39.         isr.close();
    40.  
    41.     }
    42. }
    字符缓冲流
    1. package IO流.字符流.字符缓冲流;
    2. /*
    3.     字符缓冲流：
    4.         BufferedWriter:
    5.             将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
    6.             可以指定缓冲区大小，或者可以接受默认大小。 默认值足够大，可用于大多数用途。
    7.         BufferedReader:
    8.             从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
    9.             可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途。
    11.         构造方法：
    12.             BufferedWriter​(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
    13.             BufferedReader​(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
    14.  */
    15.  
    16. import java.io.*;
    17.  
    18. public class Demo {
    19.     public static void main(String[] args) throws IOException {
    20. /*
    21.         //BufferedWriter​(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
    22.         BufferedWriter bw=new BufferedWriter(new FileWriter("idea_text\\bw.txt"));
    23.         bw.write("hello\r\n");
    24.         bw.write("world\r\n");
    25.         bw.close();
    26. */
    27.  
    28.         //BufferedReader​(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
    29.         BufferedReader br=new BufferedReader(new FileReader("idea_text\\bw.txt"));
    30.         int ch;
    31.         while ((ch = br.read()) != -1){
    32.             System.out.println((char)ch);
    33.         }
    34.  
    35.         char[] chs=new char[1024];
    36.         int len;
    37.         while ((len = br.read()) != -1){
    38.             System.out.println(new String(chs,0,len));
    39.         }
    40.  
    41.         //释放资源
    42. //        bw.close();
    43.         br.close();
    44.     }
    45. }
    特有功能
    1. package IO流.字符流.字符缓冲流;
    2. /*
    3.         BufferedWriter:
    4.             void newLine(): 写一行行分隔符，行分隔符字符串由系统属性定义
    5.         BufferedReader：
    6.             void String readLine(): 读一行文字，结果包含行的内容的字符串，不包括任何行终止字符
    7.             如果过流的结尾已经到达，则为null
    8.  */
    9.  
    10. import java.io.*;
    11.  
    12. public class 特有功能 {
    13.     public static void main(String[] args) throws IOException {
    14.         //创建字符缓冲流
    15. /*
    16.         BufferedWriter bw=new BufferedWriter(new FileWriter("idea_text\\bw.txt"));
    18.         //写数据
    19.         for (int i=0; i<10;i++){
    20.             bw.write("hello"+i);
    21.             bw.newLine();
    22.             bw.flush();
    23.         }
    24. */
    25.  
    26.         BufferedReader br = new BufferedReader(new FileReader("idea_text\\\\bw.txt"));
    27.  
    28.         //读数据
    29.         String line;
    30.         while ((line = br.readLine()) != null){
    31.             System.out.println(line);
    32.         }
    33.  
    34.  
    35.         br.close();
    36.     }
    37. }
    复制java文件改进版
    1. package IO流.字符流;
    2. /*
    3.     需求:
    4.         把模块目录下的“ConversionStreamDemo.java”复制到模块目录下的“Copyjava
    5.     分析:
    6.         1,转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类
    7.         2,FileReader:用于读取字符文件的便捷类
    8.             FileReader(String fileName)
    9.         3,FileWriter:用于写入字符文件的便捷类
    10.             FileWriter(String fileName)
    11.         4,数据源和目的地的分析
    12.           数据源:
    13.               myCharStream\\ConversionStreamDemo.java---读数据---Reader---InputStreamReader---FileReader
    14.          目的地:
    15.               myCharStream\\Copy.java---写数据---Writer---OutputStreamWriter-FileWriter
    17.         思路
    18.             1，根据数据源创建字符输入流对象
    19.             2，根据目的地创建字符输出流对象
    20.             3，读写数据，复制文件
    21.             4，释放资源
    23.  */
    24.  
    25. import java.io.FileNotFoundException;
    26. import java.io.FileReader;
    27. import java.io.FileWriter;
    28. import java.io.IOException;
    29.  
    30. public class 复制java文件改进版 {
    31.     public static void main(String[] args) throws IOException {
    32.         //根据数据源创建字符输入流对象
    33.         FileReader fr=new FileReader("myCharStream\\\\ConversionStreamDemo.java");
    34.         //根据目的地创建字符输出流对象
    35.         FileWriter fw=new FileWriter("myCharStream\\\\Copy.java");
    36.  
    37.         //读写数据，复制文件
    38.         int ch;
    39.         while ((ch = fr.read())!=-1){
    40.             fw.write(ch);
    41.         }
    42.  
    43.         char[] chs=new char[1024];
    44.         int len;
    45.         while ((len = fr.read(chs))!=-1){
    46.             fw.write(chs,0,len);
    47.         }
    48.  
    49.  
    50.  
    51.         //释放资源
    52.         fr.close();
    53.         fw.close();
    54.  
    55.     }
    56. }
    复制java文件字符缓冲流改进版
    1. package IO流.字符流;
    2. /*
    3.     需求:
    4.         把模块目录下的“ConversionStreamDemojava”复制到模块目录下的“Copyjava
    6.     思路:
    7.         1，根据数据源创建字符缓冲输入流对象
    8.         2，根据目的地创建字符缓冲输出流对象
    9.         3，读写数据，复制文件
    10.         4，释放资源
    13.  */
    14.  
    15. import java.io.*;
    16.  
    17. public class 复制java文件字符缓冲流改进版 {
    18.     public static void main(String[] args) throws IOException {
    19.         //根据数据源创建字符缓冲输入流对象
    20.         BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
    21.         //根据目的地创建字符缓冲输出流对象
    22.         BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));
    23.         //读写数据，复制文件
    24.         // 一次读写一个字符数据
    25.         int ch;
    26.         while ((ch = br.read()) != -1) {
    27.             bw.write(ch);
    28.         }
    29.         //一次读写一个字符数组数据
    30.         char[] chs = new char[1024];
    31.         int len;
    32.         while ((len = br.read(chs)) != -1) {
    33.             bw.write(chs, 0,len);
    34.         }
    35.         //释放资源
    36.         bw.close();
    37.         br.close();
    38.     }
    39. }
    复制java文件字符缓冲流特有功能改进版
    1. package IO流.字符流;
    2. /*
    3.     需求:
    4.         把模块目录下的“ConversionStreamDemojava”复制到模块目录下的“Copyjava
    6.     思路:
    7.         1，根据数据源创建字符缓冲输入流对象
    8.         2，根据目的地创建字符缓冲输出流对象
    9.         3，读写数据，复制文件
    10.                 使用字符缓冲流特有功能实现
    11.         4，释放资源
    14.  */
    15.  
    16. import java.io.*;
    17.  
    18. public class 复制java文件字符缓冲流特有功能改进版 {
    19.     public static void main(String[] args) throws IOException {
    20.         //根据数据源创建字符缓冲输入流对象
    21.         BufferedReader br =new BufferedReader(new FileReader("myCharStreamlConversionStreamDemo.java"));
    22.         //根据目的地创建字符缓冲输出流对象
    23.         BufferedWriter bw=new BufferedWriter(new FileWriter("myCharStreamCopy.java"));
    24.         //读写数据，复制文件
    25.         //使用字符缓冲流特有功能实现
    26.         String line;
    27.         while((line=br.readLine())!=null){
    28.             bw.write(line);
    29.             bw.newLine();
    30.             bw.flush();
    31.         }
    32.         //释放资源
    33.         bw.close();
    34.         br.close();
    35.     }
    36. }
    复制单级文件夹
    1. package IO流.字符流;
    2.  
    3. import java.io.*;
    4.  
    5. public class 复制单级文件夹 {
    6.     public static void main(String[] args) throws IOException {
    7.         //创建数据源目录File对象，路径是D:\\AAA
    8.         File srcFolder=new File("D:\\AAA");
    9.         //获取数据源目录File对象的名称  AAA
    10.         String srcFolderName= srcFolder.getName();
    11.         //创建目的地目录File对象，路径名是模块名+AAA组成
    12.         File destFolder =new File("idea_text",srcFolderName);
    13.         //判断目的地目录对应的File是否存在，如果不存在，就创建
    14.         if (!destFolder.exists()){
    15.             destFolder.mkdir();
    16.         }
    17.         //获取数据源目录下的所有文件的File数组
    18.         File[] listFiles=srcFolder.listFiles();
    19.         //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
    20.         for (File srcFile:listFiles){
    21.             //获取数据源文件对象的名称
    22.             String srcFileName = srcFile.getName();
    23.             //创建目的地文件File对象
    24.             File destFile=new File(destFolder,srcFileName);
    25.             //复制文件
    26.             copyFile(srcFile,destFile);
    27.         }
    28.     }
    29.  
    30.     private static void copyFile(File srcFile, File destFile) throws IOException {
    31.         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
    32.         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
    33.  
    34.         byte[] bys = new byte[1024];
    35.         int len;
    36.         while ((len = bis.read(bys)) != -1) {
    37.             bos.write(bys, 0, len);
    38.         }
    39.         bos.close();
    40.         bis.close();
    41.     }
    42. }
    点名器
    1. package IO流.字符流;
    2. /*
    3.         需求:
    4.             我有一个文件里面存储了班级同学的姓名，每个姓名占一行，通过程序实现随机点名器具
    5.         思路：
    6.             1，创建字符缓冲输入流对象
    7.             2，创建ArrayList集合对象
    8.             3，调用字符缓冲输入流对象的方法读数据
    9.             4，把读取到的字符串数据存储到集合中
    10.             5，释放资源
    11.             6，使用Random产生一个随机数，范围在【0，集合长度）
    12.             7，把第6步产生的随机数作为索引到ArrayList集合中获取值
    13.             8，把第7步得到的数据输出在控制台
    14.  */
    15.  
    16. import java.io.*;
    17. import java.util.ArrayList;
    18. import java.util.Random;
    19.  
    20. public class 点名器 {
    21.     public static void main(String[] args) throws IOException {
    22.         //创建字符缓冲输入流对象
    23.         BufferedReader br = new BufferedReader(new FileReader("idea_text\\osw.txt"));
    24.         //创建ArrayList集合对象
    25.         ArrayList<String> array = new ArrayList<String>();
    26.         //调用字符缓冲输入流对象的方法读数据
    27.         String line;
    28.         while ((line = br.readLine()) != null) {
    29.             array.add(line);
    30.         }
    31.         //释放资源
    32.         br.close();
    33.         //使用Random产生一个随机数，范围在【0，集合长度）
    34.         Random r = new Random();
    35.         int index = r.nextInt(array.size());
    36.         //把第6步产生的随机数作为索引到ArrayList集合中获取值
    37.         String name = array.get(index);
    38.         //把第7步得到的数据输出在控制台
    39.         System.out.println("幸运者是：" + name);
    40.  
    41.     }
    42. }

  • 相关阅读:
    不要在问了！工作六年总结的Java面试题与经验
    核爆，字节跳动算法工程师，手写1000页数据算法笔记:Github已标星79k
    数据库的事务
    Spring底层核心原理解析
    Yolov5 batch 推理
    边缘计算（Edge Computing）
    12 个优化 Docker 镜像安全性的技巧
    【强化学习】深度Q网络(DQN)求解倒立摆问题 + Python代码实战
    【附源码】Python计算机毕业设计天气预报APP
    Ubuntu18.04安装MySQL及Demos
  • 原文地址：https://blog.csdn.net/z2021_000000/article/details/125525412