• 【Day27】输入输出流一

    目录

    一、缓冲流的使用

    二、File类的使用

    三、其它流的使用

    一、缓冲流的使用

    /**
 * 处理流之一：缓冲流的使用
 * BufferedInputStream
 * BufferedOutputStream
 * BufferedReader
 * BufferedWriter
 * 2、作用：提供流的读取，写入速度
 *      提高读写速度的原因，内部提供了一个缓冲区
 *
 * 3、处理流，就是套在已有的流的基础上
 *
 */
    1. public class Bufferedtest {
    2.  
    3.     @Test
    4.     public void BufferedInputStreamTest(){
    5.         long stast=System.currentTimeMillis();
    6.  
    7.         //1、造文件
    8.         File file = new File("花花.png");
    9.         File file1 = new File("花花2.png");
    10.  
    11.         //2、造流
    12.         //2.1造节点流
    13.         FileInputStream fi=null;
    14.         FileOutputStream fo=null;
    15.         BufferedInputStream bd=null;
    16.         BufferedOutputStream bo=null;
    17.         try {
    18.             fi=new FileInputStream(file);
    19.             fo=new FileOutputStream(file1);
    20.             //2.2造缓冲流
    21.             bd=new BufferedInputStream(fi);
    22.             bo=new BufferedOutputStream(fo);
    23.  
    24.             //3、赋值的细节：读取与写入
    25.             byte[] bytes=new byte[5];
    26.             int len;
    27.             while ((len=bd.read(bytes))!=-1){
    28.                 bo.write(bytes,0,len);
    29.             }
    30.             System.out.println("完成");
    31.         } catch (FileNotFoundException e) {
    32.             e.printStackTrace();
    33.         } catch (IOException e) {
    34.             e.printStackTrace();
    35.         }finally {
    36.             /*
    37.             内层流可以省略，因为关闭外层流的同时，内层流也会关闭
    38.              */
    39.             if(bo!=null){
    40.                 try {
    41.                     bo.close();
    42.                 } catch (IOException e) {
    43.                     e.printStackTrace();
    44.                 }
    45.             }if(bd!=null){
    46.                 try {
    47.                     bd.close();
    48.                 } catch (IOException e) {
    49.                     e.printStackTrace();
    50.                 }
    51.             }if(fo!=null){
    52.                 try {
    53.                     fo.close();
    54.                 } catch (IOException e) {
    55.                     e.printStackTrace();
    56.                 }
    57.             }if(fi!=null){
    58.                 try {
    59.                     fi.close();
    60.                 } catch (IOException e) {
    61.                     e.printStackTrace();
    62.                 }
    63.             }
    64.         }
    65.         long end=System.currentTimeMillis();
    66.         System.out.println("方式一所用时间为："+(end-stast));//42
    67.     }
    68.  
    69.     public void copyFile(String str1,String str2){
    70.         //1、造文件
    71.         File file = new File(str1);
    72.         File file1 = new File(str2);
    73.  
    74.         //2、造流
    75.         //2.1造节点流
    76.         FileInputStream fi=null;
    77.         FileOutputStream fo=null;
    78.         BufferedInputStream bd=null;
    79.         BufferedOutputStream bo=null;
    80.         try {
    81.             fi=new FileInputStream(file);
    82.             fo=new FileOutputStream(file1);
    83.             //2.2造缓冲流
    84.             bd=new BufferedInputStream(fi);
    85.             bo=new BufferedOutputStream(fo);
    86.  
    87.             //3、赋值的细节：读取与写入
    88.             byte[] bytes=new byte[5];
    89.             int len;
    90.             while ((len=bd.read(bytes))!=-1){
    91.                 bo.write(bytes,0,len);
    92.             }
    93.             System.out.println("完成");
    94.         } catch (FileNotFoundException e) {
    95.             e.printStackTrace();
    96.         } catch (IOException e) {
    97.             e.printStackTrace();
    98.         }finally {
    99.             /*
    100.             内层流可以省略，因为关闭外层流的同时，内层流也会关闭
    101.              */
    102.             if(bo!=null){
    103.                 try {
    104.                     bo.close();
    105.                 } catch (IOException e) {
    106.                     e.printStackTrace();
    107.                 }
    108.             }if(bd!=null){
    109.                 try {
    110.                     bd.close();
    111.                 } catch (IOException e) {
    112.                     e.printStackTrace();
    113.                 }
    114.             }if(fo!=null){
    115.                 try {
    116.                     fo.close();
    117.                 } catch (IOException e) {
    118.                     e.printStackTrace();
    119.                 }
    120.             }if(fi!=null){
    121.                 try {
    122.                     fi.close();
    123.                 } catch (IOException e) {
    124.                     e.printStackTrace();
    125.                 }
    126.             }
    127.         }
    128.     }
    129.  
    130.     @Test
    131.     public void runFile(){
    132.         long staet=System.currentTimeMillis();
    133.         String str1="花花.png";
    134.         String str2="花花3.png";
    135.         copyFile(str1,str2);
    136.         long end =System.currentTimeMillis();
    137.         System.out.println("方式二所有时间为："+(end-staet));//37
    138.     }
    139.  
    140.  
    141.     @Test
    142.     public void BufferedReaderWriter(){
    143.         BufferedReader bufferedReader =null;
    144.         BufferedWriter bufferedWriter =null;
    145.         try {
    146.             bufferedReader = new BufferedReader(new FileReader(new File("hello.txt")));
    147.             bufferedWriter = new BufferedWriter(new FileWriter(new File("hello3.txt")));
    148.  
    149.             //方式一
    150.             char[] chars=new char[5];
    151.             int len;
    152.             while ((len=bufferedReader.read(chars))!=-1){
    153.                 bufferedWriter.write(chars,0,len);
    154.                 bufferedWriter.flush();
    155.             }
    156.  
    157.             //方式二：
    158. //            String str;
    159. //            while ((str=bufferedReader.readLine())!=null){
    160. //                bufferedWriter.write(str);
    161. //                bufferedWriter.newLine();
    162. //            }
    163.         } catch (FileNotFoundException e) {
    164.             e.printStackTrace();
    165.         } catch (IOException e) {
    166.             e.printStackTrace();
    167.         }finally {
    168.             if (bufferedReader!=null){
    169.                 try {
    170.                     bufferedReader.close();
    171.                 } catch (IOException e) {
    172.                     e.printStackTrace();
    173.                 }
    174.             }
    175.             if (bufferedWriter!=null){
    176.                 try {
    177.                     bufferedWriter.close();
    178.                 } catch (IOException e) {
    179.                     e.printStackTrace();
    180.                 }
    181.             }
    182.         }
    183.     }
    184. }

    二、File类的使用

    /**
 * File类的使用：
 *
 * 1、File类的一个对象，代表一个文件或一个文件目录（俗称：文件夹）
 * 2、File类声明在Java.io包下
 * 3、File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法
 *      并未涉及到写入或读取文件内容的操作，如果需要读取或写入文件内容，必须使用IO流来完成
 * 4、后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终点”
 *
 */
    1. public class FileTest1 {
    2.  
    3.     //1、创建File类的实例
    4.     //File(String filepath)
    5.     //File(String parentPath,String childPath)
    6.     //File(File parentFile,String childPath)
    7.  
    8.     //2、相对路径：
    9.     //  绝对路径：包含目录
    10.  
    11.     @Test
    12.     public void test(){
    13.         //构造器1
    14.         File file=new File("hello.txt");//相对路径
    15.         File file1=new File("D:\\WenJian\\IDEA\\Java高级基础部分\\Day08输入输出流\\src\\File\\hello.txt");//绝对路径
    16.  
    17.  
    18.         System.out.println(file);
    19.         System.out.println(file1);
    20.         //构造方法
    21.  
    22.         //构造器2
    23.         File file2=new File("D:\\WenJian\\IDEA\\Java高级基础部分","Day08输入输出流");
    24.         System.out.println(file2);
    25.  
    26.         //构造器3
    27.         File file3 = new File(file2, "hello.txt");
    28.         System.out.println(file3);
    29.     }
    30.  
    31.     @Test
    32.     public void test1(){
    33.         /*
    34.          public String getAbsolutePath()：获取绝对路径
    35.          public String getPath() ：获取路径
    36.          public String getName() ：获取名称
    37.          public String getParent()：获取上层文件目录路径。若无，返回null
    38.          public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
    39.          public long lastModified() ：获取最后一次的修改时间，毫秒值
    40.          public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
    41.          public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
    42.          */
    43.  
    44.  
    45.         File file=new File("hello.txt");
    46.         File file1 = new File("D:\\WenJian\\IDEA\\Java高级基础部分\\Day08输入输出流\\hello.txt");
    47.  
    48.         System.out.println(file.getAbsolutePath());
    49.         System.out.println(file.getPath());
    50.         System.out.println(file.getName());
    51.         System.out.println(file.getParent());
    52.         System.out.println(file.length());
    53.         System.out.println(file.lastModified());
    54.         System.out.println(file.list());
    55.         System.out.println(file.listFiles());
    56.  
    57.         System.out.println();
    58.         //file1
    59.         System.out.println(file1.getAbsolutePath());
    60.         System.out.println(file1.getPath());
    61.         System.out.println(file1.getName());
    62.         System.out.println(file1.getParent());
    63.         System.out.println(file1.length());
    64.         System.out.println(file1.lastModified());
    65.         System.out.println(file1.list());
    66.         System.out.println(file1.listFiles());
    67.     }
    68.     @Test
    69.     public void test2(){
    70.         File file = new File("D:\\WenJian\\IDEA\\Java高级基础部分");
    71.         String[] lists=file.list();
    72.         for (String s:  lists) {
    73.             System.out.println(s);
    74.         }
    75.  
    76.         //含有绝对路径的输出
    77.         File[] fileps=file.listFiles();
    78.         for (File file1:fileps
    79.              ) {
    80.             System.out.println(file1);
    81.  
    82.         }
    83.     }
    84.     /*
    85.      public boolean renameTo(File dest):把文件重命名为指定的文件路径
    86.      比如：file1.renameTo(file2):
    87.             要想保证返回true，需要file1在硬盘中是存在的，且file2不能再硬盘中存在
    88.      */
    89.     @Test
    90.     public void test3(){
    91.         File file1 = new File("D:\\WenJian\\IDEA\\Java高级基础部分\\Day08输入输出流\\src\\File\\hello.txt");
    92.         File file2=new File("D:\\WenJian\\IDEA\\fghj\\aa.txt");
    93.  
    94.         boolean b = file2.renameTo(file1);
    95.         System.out.println(b);
    96.     }
    97.  
    98.  
    99.     /*
    100.  public boolean isDirectory()：判断是否是文件目录
    101.  public boolean isFile() ：判断是否是文件
    102.  public boolean exists() ：判断是否存在
    103.  public boolean canRead() ：判断是否可读
    104.  public boolean canWrite() ：判断是否可写
    105.  public boolean isHidden() ：判断是否隐藏
    106.      */
    107.     @Test
    108.     public void test4(){
    109.         File file = new File("D:\\WenJian\\IDEA\\Java高级基础部分\\Day08输入输出流\\src\\File\\hello.txt");
    110.         System.out.println(file.isDirectory());
    111.         System.out.println(file.isFile());
    112.         System.out.println(file.exists());
    113.         System.out.println(file.canRead());
    114.         System.out.println(file.canWrite());
    115.         System.out.println(file.isHidden());
    116.  
    117.         System.out.println();
    118.         File file1 = new File("D:\\WenJian\\IDEA");
    119.         System.out.println(file1.isDirectory());
    120.         System.out.println(file1.isFile());
    121.         System.out.println(file1.exists());
    122.         System.out.println(file1.canRead());
    123.     }
    124.  
    125.  
    126.     /*
    127.  public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
    128.  public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。
    129. 如果此文件目录的上层目录不存在，也不创建。
    130.  public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建
    131. 注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目
    132. 路径下。
    134.  public boolean delete()：删除文件或者文件夹
    135. 删除注意事项：
    136. Java中的删除不走回收站。
    137. 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录
    139.      */
    140.     @Test
    141.     public void test5() throws IOException {
    142.  
    143.         File file = new File("D:\\WenJian\\IDEA\\Java高级基础部分\\Day08输入输出流\\src\\File\\hello1.txt");
    144.         if(!file.exists()){
    145.             file.createNewFile();
    146.             System.out.println("创建成功");
    147.         }else {
    148.             file.delete();
    149.             System.out.println("删除成功");
    150.         }
    151.  
    152.  
    153.  
    154.     }
    155.  
    156.     //        D:\WenJian\IDEA\fghj
    157.     // public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。
    158.     //如果此文件目录的上层目录不存在，也不创建。
    159.     @Test
    160.     public void test6(){
    161.  
    162.         File file1 = new File("D:\\WenJian\\IDEA\\fghj");
    163.         File file = new File("D:\\WenJian\\IDEA\\Java高级基础部分\\Day08输入输出流\\src\\File\\hello.txt");
    164.         if (!file1.exists()) {
    165.             file1.mkdir();
    166.             System.out.println("创建成功");
    167.         }else {
    168.             file1.delete();
    169.             System.out.println("删除成功");
    170.         }
    171.         file.delete();
    172.     }
    173.     /**
    174.      *
    175.      * @description:
    176.      * @author ----千里之行，始于足下----
    177.      * @date 2022/8/22 18:59
    178.      */
    179.     @Test
    180.     public void test7() throws IOException {
    181.         File file = new File("D:\\hello.txt");
    182.         if (!file.exists()) {
    183.             file.createNewFile();
    184.         }
    185.         File file1 = new File(file.getParent(), "hello.txt");
    186.         System.out.println(file);
    187.         file.delete();
    188.     }
    189.  
    190.     @Test
    191.     public void test8(){
    192.         File file = new File("D:\\WenJian\\IDEA\\Java高级基础部分");
    193.         String[] files=file.list();
    194.         for (String fle :
    195.                 files) {
    196.             int length = fle.length();
    197. //            if(fle.substring(length-3).equals("jpg")){
    198.                 if(fle.endsWith("jpg")){
    199.             System.out.println(fle);
    200.         }
    201.     }
    202.     }
    203. }

    三、其它流的使用

    /**
 * 1.1、标准的输入输出流
 *     System.in:标准的输入流，默认从键盘输入
 *     System.out:标准的输出流，默认从控制台输出
 *     1.2
 *     System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入输出的流
 *
 *     练习：
 *         从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续
 *         进行输入操作，直至当输入“e”或者“exit”时，退出程序。
 *         
 * @description:  
 * @author ----千里之行，始于足下----
 * @date 2022/9/16 20:25
 */
    1. public class FileTest2 {
    2.  
    3.     public static void main(String[] args) {
    4.         BufferedReader br = null;
    5.  
    6.  
    7.         try {
    8.             InputStreamReader isr = new InputStreamReader(System.in);
    9.             br = new BufferedReader(isr);
    10.             while (true) {
    11.                 System.out.println("请输入字字符串");
    12.                 String data = null;
    13.                 data = br.readLine();
    14.                 if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
    15.                     System.out.println("程序结束");
    16.                     break;
    17.                 }
    18.                 String upperCase = data.toUpperCase();
    19.                 System.out.println(upperCase);
    20.             }
    21.         }catch(IOException e){
    22.                 e.printStackTrace();
    23.             }finally{
    24.                 if (br != null) {
    25.                     try {
    26.                         br.close();
    27.                     } catch (IOException e) {
    28.                         e.printStackTrace();
    29.                     }
    30.                 }
    31.             }
    32.         }
    33.     }
    34.

  • 相关阅读:
    最大路径和
    C语言-入门-const关键字(十九)
    尚医通 (十七) --------- 数据字典开发
    人工智能——大白话熟悉目标检测基本流程
    程序调试技巧
    保证接口数据安全的10种方案
    内存卡剪切后怎么恢复
    Perl 脚本运行时提示：Can‘t locate Win32/OLE.pm in @INC
    Linux基本权限管理
    【LTTng】核心概念精读
  • 原文地址：https://blog.csdn.net/fool_Java/article/details/126897134