• 2022年0704-Com.Java.Basis 第十四课 《File类 +IO流》简称字节的Ctrl+A Ctrl+C Ctrl+V

    2022年0704-Com.Java.Basis 第十四课 《File类 +IO流》简称字节的Ctrl+A Ctrl+C  Ctrl+V.这篇文章我无法创造出经典:但是我可以编写出自己经典的文章。十六个小案例带你走进Java的IO流

    第一部分:基础知识的积累:

    1 初识Java IO
    IO，即in和out，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。

    Java 中是通过流处理IO 的，那么什么是流？

    流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。

    当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

    一般来说关于流的特性有下面几点：

    先进先出：最先写入输出流的数据最先被输入流读取到。
    顺序存取：可以一个接一个地往流中写入一串字节，读出时也将按写入顺序读取一串字节，不能随机访问中间的数据。（RandomAccessFile除外）
    只读或只写：每个流只能是输入流或输出流的一种，不能同时具备两个功能，输入流只能进行读操作，对输出流只能进行写操作。在一个数据传输通道中，如果既要写入数据，又要读取数据，则要分别提供两个流。

    总结:以自己为中心看流是流入还是流出

    2  IO流分类
    IO流主要的分类方式有以下3种：
    按数据流的方向：输入流、输出流
    按处理数据单位：字节流、字符流
    按功能：节点流、处理流

    3 IO流方法
    3.1 字节流方法
    字节输入流InputStream主要方法：

    read() ：从此输入流中读取一个数据字节。
    read(byte[] b) ：从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
    read(byte[] b, int off, int len) ：从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
    close()：关闭此输入流并释放与该流关联的所有系统资源。
    字节输出流OutputStream主要方法：

    write(byte[] b) ：将 b.length 个字节从指定 byte 数组写入此文件输出流中。
    write(byte[] b, int off, int len) ：将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
    write(int b) ：将指定字节写入此文件输出流。
    close() ：关闭此输入流并释放与该流关联的所有系统资源。
    3.2 字符流方法
    字符输入流Reader主要方法：

    read()：读取单个字符。
    read(char[] cbuf) ：将字符读入数组。
    read(char[] cbuf, int off, int len) ： 将字符读入数组的某一部分。
    read(CharBuffer target) ：试图将字符读入指定的字符缓冲区。
    flush() ：刷新该流的缓冲。
    close() ：关闭此流，但要先刷新它。
    字符输出流Writer主要方法：

    write(char[] cbuf) ：写入字符数组。
    write(char[] cbuf, int off, int len) ：写入字符数组的某一部分。
    write(int c) ：写入单个字符。
    write(String str) ：写入字符串。
    write(String str, int off, int len) ：写入字符串的某一部分。
    flush() ：刷新该流的缓冲。
    close() ：关闭此流，但要先刷新它。
    另外，字符缓冲流还有两个独特的方法：

    BufferedWriter类newLine() ：写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。
    BufferedReader类readLine() ：读取一个文本行。
    4 加点扩展的内容
    4.1 位、字节、字符
    字节(Byte)是计量单位，表示数据量多少，是计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于八位。

    字符(Character)计算机中使用的字母、数字、字和符号，比如’A’、‘B’、’$’、’&'等。

    一般在英文状态下一个字母或字符占用一个字节，一个汉字用两个字节表示。

    字节与字符：

    ASCII 码中，一个英文字母（不分大小写）为一个字节，一个中文汉字为两个字节。
    UTF-8 编码中，一个英文字为一个字节，一个中文为三个字节。
    Unicode 编码中，一个英文为一个字节，一个中文为两个字节。
    符号：英文标点为一个字节，中文标点为两个字节。例如：英文句号 . 占1个字节的大小，中文句号 。占2个字节的大小。
    UTF-16 编码中，一个英文字母字符或一个汉字字符存储都需要 2 个字节（Unicode 扩展区的一些汉字存储需要 4 个字节）。
    UTF-32 编码中，世界上任何字符的存储都需要 4 个字节。

    第二部分:进入主题IO流:十六个小案例带你走进Java的IO流

     

     

     

    案例Demo展示的内容

     

    案例一

    1. 概述：文件和目录（文件夹）路径名的抽象表示形式
路径的分类：
绝对路径：带有盘符号的路径
相对路径：没有带盘符号的路径，默认在根目录下
构造方法
File（String pathname）：根据一个路径得到File对象
File（String parent, String child）：根据一个目录和一个子文件/目录得到File对象
File（File parent, String child）：根据一个父File对象和子文件/目录得到File对象
    2. 判断功能
public boolean isDirectory(): 判断是否是目录
public boolean isFile(): 判断是否是文件
public boolean exists(): 判断是否存在
public boolean canRead(): 判断是否可读
public boolean canWrite(): 判断是否可写
public boolean isHidden(): 判断是否隐藏
    3. 获取功能
public String getAbsolutePath()： 获取绝对路径
public String getPath(): 获取相对路径
public String getParent() 获取上一级路径，返回字符串，没有返回null
public File getParentFile() 获取上一级路径，返回File类型，没有返回nul
public long getTotalSpace() 返回总容量 单位字节
public long getFreeSpace() 返回剩余容量 单位字节
public String getName(): 获取名称
public long length(): 获取长度。字节数
public long lastModified(): 获取最后一次的修改时间，毫秒值
    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.File;
    4.  
    5. /**
    6.  * 概述：文件和目录（文件夹）路径名的抽象表示形式
    7.  * 路径的分类：
    8.  * 绝对路径：带有盘符号的路径
    9.  * 相对路径：没有带盘符号的路径，默认在根目录下
    10.  * 构造方法
    11.  * File（String pathname）：根据一个路径得到File对象
    12.  * File（String parent, String child）：根据一个目录和一个子文件/目录得到File对象
    13.  * File（File parent, String child）：根据一个父File对象和子文件/目录得到File对象
    14.  */
    15. public class Demo1Test {
    16.     public static void main(String[] args) throws Exception {
    17.         // 1  File(String pathname)
    18.         //创建的文件目录在的路径
    19.         File file = new File("E:\\demo\\nopainsnogains.ppt");
    20.         System.out.println(file);//打印文件路径
    21.         /**
    22.          * （4）判断功能
    23.          * public boolean isDirectory(): 判断是否是目录
    24.          * public boolean isFile(): 判断是否是文件
    25.          * public boolean exists(): 判断是否存在
    26.          * public boolean canRead(): 判断是否可读
    27.          * public boolean canWrite(): 判断是否可写
    28.          * public boolean isHidden(): 判断是否隐藏
    29.          */
    30.         //判断文件夹是否有目录
    31.         System.out.println(file.isDirectory());
    32.         //判断是否有文件
    33.         System.out.println(file.isFile());
    34.         //判断是否存在
    35.         System.out.println(file.exists());
    36.         //判断是否可读
    37.         System.out.println(file.canRead());
    38.         //判断是否可以写
    39.         System.out.println(file.canWrite());
    40.         //判断是否隐藏
    41.         System.out.println(file.isHidden());
    42. /**
    43.  * 5）获取功能
    44.  * public String getAbsolutePath()： 获取绝对路径
    45.  * public String getPath(): 获取相对路径
    46.  * public String getParent() 获取上一级路径，返回字符串，没有返回null
    47.  * public File getParentFile() 获取上一级路径，返回File类型，没有返回null
    48.  * public long getTotalSpace() 返回总容量 单位字节
    49.  * public long getFreeSpace() 返回剩余容量 单位字节
    50.  * public String getName(): 获取名称
    51.  * public long length(): 获取长度。字节数
    52.  * public long lastModified(): 获取最后一次的修改时间，毫秒值
    53.  */
    54.  
    55.         //获取绝对路径
    56.         System.out.println(file.getAbsolutePath());
    57.         //获取相对路径
    58.         System.out.println(file.getPath());
    59.         //获取上一级路径，返回字符串，没有返回null
    60.         System.out.println(file.getParent());
    61.         //获取上一级路径，返回File类型，没有返回null
    62.         System.out.println(file.getParentFile());
    63.         System.out.println(file.getCanonicalPath());
    64.         System.out.println("返回总容量 单位字节" + file.getTotalSpace());
    65.         System.out.println("返回剩余容量 单位字节" + file.getFreeSpace());
    66.         System.out.println(file.getName());
    67.         System.out.println(file.length());
    68.         System.out.println(file.lastModified());
    69.  
    70.  
    71.         //创建文件
    72.         file.createNewFile();
    73.         //创建目录文件夹
    74.         //File file1 =new File("E:\\demo\\hello");
    75.         //file1.mkdir();
    76.  
    77.         //创建文件多及目录
    78.         File file2 = new File("E:\\demo\\aa\\ba\\ca\\da\\ea\\fa\\ga");
    79.         file2.mkdirs();
    80.  
    81.         File f = new File("E:\\demo\\HelloWord.text");
    82.         System.out.println(f);
    83.         f.mkdir();
    84.         System.out.println(f.isDirectory());
    85.         System.out.println(f.isFile());
    86.  
    87.  
    88.     }
    89.  
    90. }

    案例二:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo1Test2 {
    7.  
    8.     public static void main(String[] args) {
    9.         // TODO Auto-generated method stub
    10.         FileOutputStream fos=null;
    11.         try {
    12.             //创建
    13.             fos =new  FileOutputStream("E:\\demo\\File.txt" ,true);
    14.             for (int i = 0; i <=5; i++) {
    15.                 System.out.println("ctrl+c ctrl+v");
    16.                 fos.write("窗前明月光意识地上床酒托人生能坎区因".getBytes());
    17.                 fos.write("\r\n".getBytes());
    18.  
    19.             }
    20.  
    21.         } catch (Exception e) {
    22.             e.printStackTrace();
    23.         }finally {
    24.             //释放资源
    25.             try {
    26.                 if(fos!=null) {
    27.                     fos.close();
    28.                 }
    29.  
    30.             } catch (IOException e) {
    31.                 e.printStackTrace();
    32.             }
    33.  
    34.         }
    35.     }
    36. }

     案例三:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6.  
    7. public class Demo1Test3 {
    8.     public static void main(String[] args) throws IOException {
    9.         //输入流中的ctrl+A  ctrl+C
    10.         FileInputStream fis=new   FileInputStream("E:\\demo\\File.txt");
    11.  
    12.         //输出
    13.         //Ctrl+v
    14.         FileOutputStream fos =new  FileOutputStream("E:\\demo\\ctrlV.txt",true);
    15.         int by;
    16.         while((by=fis.read())!=-1) {
    17.             fos.write(by);
    18.         }
    19.         fis.close();
    20.         fos.close();
    21.  
    22.     }
    23. }

     Java程序员的ctrl+A ctrl+c  ctrl+v

    案例四:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6.  
    7. public class Demo1Test4 {
    8.     public static void main(String[] args) throws IOException {
    9.         //输入
    10.  
    11.         FileInputStream fis=new   FileInputStream("E:\\demo\\AAA.txt");
    12.         //输出
    13.         FileOutputStream fos =new  FileOutputStream("E:\\demo\\BBB.txt",true);
    14.         int by;
    15.         while((by=fis.read())!=-1) {
    16.             fos.write(by);
    17.         }
    18.         fis.close();
    19.         fos.close();
    20.  
    21.     }
    22. }

    案例五:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.File;
    4.  
    5. public class Demo1Test5 {
    6.     public static void main(String[] args)  throws Exception{
    7.         // 1  File(String pathname)
    8.         File file =new File ("E:\\demo\\AAA.text");
    9.         System.out.println(file);
    10.  
    11.         //判断文件夹
    12.         System.out.println(file.isDirectory());
    13.         //判断文件
    14.         System.out.println(file.isFile());
    15.         //file文件路径
    16.         System.out.println(file.exists());
    17.  
    18.  
    19.  
    20.         System.out.println(file.getAbsolutePath());
    21.         System.out.println(file.getName());
    22.         System.out.println(file.getPath());
    23.         System.out.println(file.getCanonicalFile());
    24.  
    25.         //创建文件
    26.         file.createNewFile();
    27.  
    28.         //多及目录
    29.         File file2 =new File("E:\\demo\\aa\\ba\\ca\\da\\ea\\fa\\ga");
    30.         file2.mkdirs();
    31.  
    32.  
    33.         File f =new File ("E:\\demo\\hellow.text");
    34.         System.out.println(f);
    35.         f.mkdir();
    36.         System.out.println(f.isDirectory());
    37.         System.out.println(f.isFile());
    38.  
    39.  
    40.     }
    41. }

    File file =new File ("E:\\demo\\AAA.text"); 创建文件的方式

    案例六:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo1Test6 {
    7.     public static void main(String[] args) {
    8.         // TODO Auto-generated method stub
    9.         FileOutputStream fos=null;
    10.         try {
    11.             //创建
    12.             fos =new  FileOutputStream("E:\\demo\\AAA.txt" ,true);
    13.             for (int i = 0; i <=10; i++) {
    14. //                System.out.println("NO PAINS");
    15.                 fos.write("我是转入的数据ctrl ".getBytes());
    16.                 fos.write("\r\n".getBytes());
    17.  
    18.             }
    19.  
    20.         } catch (Exception e) {
    21.             e.printStackTrace();
    22.         }finally {
    23.             //释放资源
    24.             try {
    25.                 if(fos!=null) {
    26.                     fos.close();
    27.                 }
    28.  
    29.             } catch (IOException e) {
    30.                 e.printStackTrace();
    31.             }
    32.  
    33.         }
    34.     }
    35. }

    案例七: 

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.File;
    4.  
    5. public class Demo1Test7 {
    6.     public static void main(String[] args)  throws Exception{
    7.         // 1  File(String pathname)
    8.         //文件名
    9.         File file =new File ("E:\\demo\\heerllo.text");
    10.         System.out.println(file);
    11.  
    12.         //创建文件
    13.         file.createNewFile();
    14.         //创建目录文件夹
    15.         File file1 =new File("E:\\demo\\hello");
    16.         file1.mkdir();
    17.  
    18.         File file22 =new File("E:\\dem\\hert");
    19.  
    20.         //多及目录
    21.         File file2 =new File("E:\\demo\\a\\b\\c");
    22.         file2.mkdirs();
    23.  
    24.  
    25.         File f =new File ("E:\\demo\\heerllowert.text");
    26.         System.out.println(f);
    27.         f.mkdir();
    28.         System.out.println(f.isDirectory());
    29.         System.out.println(f.isFile());
    30.  
    31.  
    32.     }
    33. }

     案例八:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.File;
    4.  
    5. /**
    6.  * File的删除文件
    7.  */
    8. public class Demo1Test8 {
    9.     public static void main(String[] args) {
    10.         File file =new File ("E:\\demo\\hello");
    11.         //删除路径的文件夹
    12.         file.delete();
    13.  
    14.         //不能伤处多及目录
    15.         File file1 =new File ("E:\\demo\\hello");
    16.         //删除路径的文件夹
    17.         file.delete();
    18.         //
    19.         File file2 =new File ("E:\\demo\\a\\b\\c\\d\\e\\f");
    20.         //删除路径的文件夹
    21.         file2.delete();
    22.  
    23.     }
    24. }

    案例九:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo1Test9 {
    7.     public static void main(String[] args) throws IOException {
    8.         FileInputStream fis=new   FileInputStream("E:\\demo\\haha.txt");
    9.         //调用字节数人流对象数据方法;return
    10.         // int read(); 1
    11.         int num =fis.read();
    12.         System.out.println(num);
    13.         //2
    14.         int num1 =fis.read();
    15.         System.out.println(num1);
    16.         //3
    17.         int num2 =fis.read();
    18.         System.out.println(num2);
    19.         //4
    20.         int num3 =fis.read();
    21.         System.out.println(num3);
    22.  
    23.     }
    24. }

    案例十:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo1Test10 {
    7.     public static void main(String[] args) throws IOException {
    8.         FileInputStream fis=new   FileInputStream("E:\\demo\\haha.txt");
    9.         //调用字节数人流对象数据方法;return
    10.  
    11.         int by;
    12.         while((by=fis.read())!=-1) {
    13.             System.out.print((char)by);
    14.             //释放资源
    15.             //fis.close();
    16.         }
    17.     }
    18. }

    案例十一:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo1Test11 {
    7.  
    8.     public static void main(String[] args) throws IOException {
    9.         // FileOutputStream(String name)
    10.  
    11.         FileOutputStream fos =new  FileOutputStream("E:\\demo\\herrllo.text" ,true);
    12.         //  void write (int b) 写入数据
    13.         fos.write(121);
    14.         fos.write(11);
    15.         fos.write(111);
    16.         fos.write(101);
    17.         fos.write(111);
    18.         fos.close();
    19.         // 2数组  void write(byte[] by) 将byte数组写入数组中
    20.         byte[] by = {34,56,78};
    21.         fos.write(by);
    22.  
    23.         //写一句话
    24.         String str = "我爱你";
    25.         byte [] by1=str.getBytes();
    26.         fos.write(by1);
    27.         fos.close();
    28.  
    29.         //
    30.         byte[] by2 = {34,56,78};
    31.         fos.write(by2,2,1);
    32.  
    33.  
    34.  
    35.     }
    36. }

    案例十二:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo1Test12 {
    7.     public static void main(String[] args)  {
    8.         FileOutputStream fos=null;
    9.         try {
    10.             //创建
    11.             fos =new  FileOutputStream("E:\\demo\\haha.txt" ,true);
    12.             for (int i = 0; i <=10; i++) {
    13.                 fos.write("I love you in the end ".getBytes());
    14.                 fos.write("\r\n".getBytes());
    15.  
    16.             }
    17.  
    18.         } catch (Exception e) {
    19.             e.printStackTrace();
    20.         }finally {
    21.             //释放资源
    22.             try {
    23.                 if(fos!=null) {
    24.                     fos.close();
    25.                 }
    26.  
    27.             } catch (IOException e) {
    28.                 e.printStackTrace();
    29.             }
    30.  
    31.         }
    32.  
    33.  
    34.  
    35.     }
    36. }

    案例十三:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.*;
    4.  
    5. public class BufferStreamDemo1 {
    6.     /**
    7.      *第一种方式
    8.      FileInputStream fis= new   FileInputStream("C:\\Users\\MZFAITHDREAM\\Desktop\\1.jpg");
    9.      FileOutputStream fos =new  FileOutputStream("D:\\haha.jpg" ,true);
    10.      byte[] by =new byte[1024];
    11.      //int read(byte[]) by)
    12.      int num=0;
    13.      while((num=fis.read(by))!=-1) {
    14.      //reading
    15.      fos.write(by, 0, num);
    17.      }
    18.      //关闭流
    19.      fis.close();
    20.      fos.close();
    21.      //基本字节读一个 字节/数组/字节/一个字节数组
    22.      * @param args
    23.      */
    24.     public static void main(String[] args)throws IOException {
    25.         //获取时间
    26.         long startTime1 =System.currentTimeMillis();
    27.         //调用方法
    28.         method1();
    29.         long endTime1 =System.currentTimeMillis();
    30.         System.out.println("方法1:"+(endTime1-startTime1));
    31.  
    32.         long startTime2 =System.currentTimeMillis();
    33.         //调用方法
    34.         method1();
    35.         long endTime2 =System.currentTimeMillis();
    36.         System.out.println("方法2:"+(endTime2-startTime2));
    37.  
    38.         long startTime3 =System.currentTimeMillis();
    39.         //调用方法
    40.         method1();
    41.         long endTime3 =System.currentTimeMillis();
    42.         System.out.println("方法3:"+(endTime3-startTime3));
    43.  
    44.         long startTime4 =System.currentTimeMillis();
    45.         //调用方法
    46.         method1();
    47.         long endTime4 =System.currentTimeMillis();
    48.         System.out.println("方法4:"+(endTime4-startTime4));
    49.  
    50.  
    51.     }
    52.     public static void method1() throws IOException {
    53.         FileInputStream fis= new   FileInputStream("C:\\Users\\MZFAITHDREAM\\Pictures\\Saved Pictures\\A-1 (4)\\黑白上色\\01.jpg");
    54.         FileOutputStream fos =new  FileOutputStream("D:\\01.jpg" ,true);
    55.         byte[] by =new byte[1024];
    56.         //int read(byte[]) by)
    57.         int num=0;
    58.         while((num=fis.read(by))!=-1) {
    59.             //reading
    60.             fos.write(by, 0, num);
    61.  
    62.         }
    63.         //关闭流
    64.         fis.close();
    65.         fos.close();
    66.  
    67.     }
    68.     public static void method2() throws IOException {
    69.         FileInputStream fis= new   FileInputStream("C:\\Users\\MZFAITHDREAM\\Desktop\\1.jpg");
    70.         FileOutputStream fos =new  FileOutputStream("D:\\method2.jpg" ,true);
    71.         byte[] by =new byte[1024];
    72.         //int read(byte[]) by)
    73.         int num=0;
    74.         while((num=fis.read(by))!=-1) {
    75.             //reading
    76.             fos.write(by, 0, num);
    77.  
    78.         }
    79.         //关闭流
    80.         fis.close();
    81.         fos.close();
    82.  
    83.     }
    84.     public static void method3() throws IOException {
    85.         FileInputStream fis= new   FileInputStream("C:\\Users\\MZFAITHDREAM\\Desktop\\1.jpg");
    86.         //创建字节输入缓冲流
    87.         BufferedInputStream bis =new  BufferedInputStream(fis);
    88.         FileOutputStream fos =new  FileOutputStream("D:\\method3.jpg" ,true);
    89.         BufferedOutputStream bos =new  BufferedOutputStream(fos);
    90.  
    91.  
    92.         //int read(byte[]) by)
    93.         int num=0;
    94.         while((num=fis.read())!=-1) {
    95.             //reading
    96.             fos.write( num);
    97.  
    98.         }
    99.         //关闭流
    100.         fis.close();
    101.         fos.close();
    102.  
    103.     }
    104.     public static void method4() throws IOException {
    105.         FileInputStream fis= new   FileInputStream("C:\\Users\\MZFAITHDREAM\\Desktop\\1.jpg");
    106.         //创建字节输入缓冲流
    107.         BufferedInputStream bis =new  BufferedInputStream(fis);
    108.         FileOutputStream fos =new  FileOutputStream("D:\\method4.jpg" ,true);
    109.         BufferedOutputStream bos =new  BufferedOutputStream(fos);
    110.  
    111.         byte[] by=new byte [1024];
    112.         //int read(byte[]) by)
    113.         int num=0;
    114.         while((num=fis.read())!=-1) {
    115.             //reading
    116.             fos.write( by,0,num);
    117.  
    118.         }
    119.         //关闭流
    120.         fis.close();
    121.         fos.close();
    122.  
    123.     }
    124.  
    125. }

     案例十四:

    1. package com.JavaBasicsDemo9;
    2.  
    3. public class CodeDemo1 {
    4.     public static void main(String[] args) throws Exception {
    5.         // TODO Auto-generated method stub
    6.         String str="我爱距离100km江西南字符昌学lookforyou江西区的学院";
    7.         //将字符串转成编码
    8.         byte [] by =str.getBytes("utf-8");
    9.         //将数据给用户看
    10.         String str1 =new String(by,"utf-8");
    11.         System.out.println(str1);
    12.  
    13.         //网页定义utf-8
    14.         String str2="我爱距离100km江西南区的学院";
    15.         //将字符串转成编码
    16.         byte [] by1 =str1.getBytes("gbk");
    17.         //将数据给用户看
    18.         String str3 =new String(by,"gbk");
    19.         System.out.println(str2);
    20.  
    21.         System.out.println(str.getBytes());
    22.         System.out.println(str);
    23.         System.out.println(str2);
    24.  
    25.     }
    26.  
    27. }

     案例十五:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.*;
    4.  
    5. public class CopeFile {
    6.     public static void main(String[] args) throws IOException {
    7.         //创建字节输入
    8.         FileInputStream fis= new   FileInputStream("C:\\Users\\MZFAITHDREAM\\Desktop\\Javaday1_9.zip");
    9.         //创建字节输出
    10.         FileOutputStream fos =new  FileOutputStream("D:\\Day");
    11.  
    12.         //字符输入
    13.         InputStreamReader isr=new 	 InputStreamReader(fis,"utf-8");
    14.  
    15.         //字符输出
    16.         OutputStreamWriter osr=new 	 OutputStreamWriter(fos,"utf-8");
    17.  
    18.  
    19.         //创建一个数组去放入取到的数据
    20.         char[] cr=new char[1024];
    21.  
    22.         int num=0;
    23.  
    24.         //while
    25.         while((num=isr.read(cr))!=-1) {
    26.             //reading
    27.             osr.write( cr,0,num);
    28.  
    29.         }
    30.         isr.close();
    31.         osr.close();
    32.     }
    33.  
    34. }

    案例十六:

    1. package com.JavaBasicsDemo9;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6.  
    7. public class Copy1 {
    8.     public static void main(String[] args)  throws IOException {
    9.         // TODO Auto-generated method stub
    10.         FileInputStream fis= new   FileInputStream("C:\\Users\\MZFAITHDREAM\\Desktop\\1.jpg");
    11.         FileOutputStream fos =new FileOutputStream("D:\\胡滨.jpg" ,true);
    12.         byte[] by =new byte[1024];
    13.         //int read(byte[]) by)
    14.         int num=0;
    15.         while((num=fis.read(by))!=-1) {
    16.             //reading
    17.             fos.write(by, 0, num);
    18.  
    19.         }
    20.         //关闭流
    21.         fis.close();
    22.         fos.close();
    23.  
    24.     }
    25. }

    十六个小案例带你走进java的IO流

  • 相关阅读:
    金九银十求职季，美团高频面试题和答案都帮你准备好啦
    【Java基础】Java8新特性
    Day39 LeetCode
    RabbitMQ(控制台模拟收发消息与数据隔离)
    LeetCode——Weekly Contest 318
    Bert浅谈
    Git 基础使用
    正则表达式
    VUE + JS 生成指定区间随机数
    Shopee活动名称怎么填写好？Shopee活动名称设置注意事项——站斧浏览器
  • 原文地址：https://blog.csdn.net/qq_56248592/article/details/125606293