• IO应知应会

    目录

    硬件体系：处理器CPU，存储器（内存），输入设备，输出设备

    各个硬件读写速度的比较

    文件路径：从文件系统这个树上，找到唯一确定得位置，这个节点可以不存在。

    绝对路径：从文件树得根节点出发，找到某一个文件得节点位置，就为绝对路径

    相对路径：从当前文件节点出发，另一个节点相对于当前节点得位置

    File类：

    构造方法

     普通方法：

    删除文件delete()

     文件的读写

    文件的读数据：FileInputStream

     写OutputStream:

    文件的复制

    文件夹的复制

    模拟OJ测试文档的编写

    硬件体系：处理器CPU，存储器（内存），输入设备，输出设备

    硬盘——存储：

    各个硬件读写速度的比较

    文件路径：从文件系统这个树上，找到唯一确定得位置，这个节点可以不存在。

    绝对路径：从文件树得根节点出发，找到某一个文件得节点位置，就为绝对路径

    相对路径：从当前文件节点出发，另一个节点相对于当前节点得位置

    . . ：表示回到上一级目录

    . ：表示当前目录

    当前目录：进程得启动目录，

    路径得描述：

    绝对路径：\ : 路径分隔符

    window：D：\ files \ a.txt  根盘符 : \ 文件名 \ 文件.后缀名

    linux：/ mac： D: / 文件夹 / 文件名

    相对路径：进程启动时的目录

    1. public class 相对路径 {
    2.     public static void main(String[] args) throws IOException {
    3.         File file = new File("./a.txt");
    4.         System.out.println(file.getCanonicalPath());
    5.     }
    6. }

    当前在file文件夹 ： 描述a.txt 就为 ： file\a.txt

    代码中得路径: windows中 \ 表示转义 ，所以 windows中得代码： D:\\file\\a.txt

    java是一个跨平台得语言，所以代码中可以不区分正反斜杠

    File类：

    构造方法

     普通方法：

     

    删除文件delete()

    只能删除叶子节点或者空得文件夹；

    deleteOnExit() ： 在程序退出时删除文件；

    删除非空得文件夹，只能先将文件夹删除为空，才能删除该文件夹

     文件得创建与判断

    windows上删除文件相当于剪切复制，将文件从当前节点复制回收站中，

    delete()方法是将文件系统中真正的删除掉，不进入回收站

    1. package com.yyk.io.IO操作文件;
    2.  
    3. import java.io.File;
    4. import java.io.IOException;
    5. import java.util.ArrayDeque;
    6. import java.util.Arrays;
    7. import java.util.Date;
    8. import java.util.Deque;
    9.  
    10. public class FileMetohd {
    11.     public static void main(String[] args) throws IOException {
    12.         File file = new File("D:\\IO\\.\\..\\..\\IO\\hello.txt");
    13.         System.out.println("文件存在吗："+file.exists());
    14.         System.out.println("是文件夹吗："+file.isDirectory());
    15.         System.out.println("是文件吗" + file.isFile());
    16.         System.out.println("***********在该路径下创建hello.txt*******");
    17.         file.createNewFile();
    18.         System.out.println("文件存在吗："+file.exists());
    19.         System.out.println("是文件夹吗："+file.isDirectory());
    20.         System.out.println("是文件吗" + file.isFile());
    21.         System.out.println();
    22.         System.out.println("********获取文件得路径**********");
    23.         System.out.println("文件得绝对路径：" +file.getAbsoluteFile());//返回得是文件
    24.         System.out.println("文件得绝对路径：" +file.getAbsolutePath());//返回得是字符串
    25.         System.out.println("文件得权威绝对路径：" +file.getCanonicalFile());//返回得是文件，将中间的没有意义的点去掉
    26.         System.out.println("文件得权威绝对路径：" +file.getCanonicalPath());//返回得是字符串,去掉中间的文件..和.
    27.         System.out.println("文件名：" + file.getName());
    28.         System.out.println("文件的父路径：" + file.getParent());
    29.         System.out.println("文件的父路径的权威路径：" + file.getParentFile().getCanonicalPath());
    30.         System.out.println("文件的大小：" + file.length());
    31.         System.out.println("用绝对路径创建的文件吗：" +file.isAbsolute());
    32.         System.out.println("文件被隐藏吗：" +file.isHidden());
    33.         System.out.println("文件最后一次被修改的时间：" + new Date(file.lastModified()));
    34.         System.out.println("该文件的父目录下的文件个数：" + Arrays.toString(file.getParentFile().listFiles()));
    35.         System.out.println();
    36.         System.out.println("********文件的深度优先遍历***********");
    37.         DFSFilePath(file.getParentFile());
    38.         System.out.println();
    39.         System.out.println("********文件的广度优先遍历***********");
    40.         NFSFilePath(file.getParentFile());
    41.         System.out.println("文件系统的根目录" + file.listRoots());
    42.         System.out.println();
    43.         System.out.println("*****mkdir****创建文件夹*******mkdirs****");
    44.         File file1 = new File("D:\\IO\\A\\BB\\CCC");
    45.         file1.mkdirs();
    46.         System.out.println("mkdirs创建不存在路径下的文件夹" + file1.getCanonicalPath());
    47.         File file2 = new File("D:\\IO\\D");
    48.         file2.mkdir();
    49.         System.out.println("mkdir在已经存在的目录下创建文件夹：" + file2.getCanonicalPath());
    50.         System.out.println("重命名文件:" );
    51.         File dest = new File("D:\\IO\\你好.txt");
    52.         System.out.print(file.getName()+" 被重命名为 ");
    53.         file.renameTo(dest);
    54.         dest.delete();//删除文件夹
    55.         System.out.println(dest.getName());
    56.         System.out.println("文件的重命名相当于文件的剪切复制");
    57.  
    58.     }
    59.  
    60.     /**
    61.      * 文件的深度优先遍历
    62.      * @param dir
    63.      */
    64.     public static void DFSFilePath(File dir) throws IOException {
    65.         File[] files = dir.listFiles();
    66.         if (dir == null){
    67.             return;
    68.         }
    69.         for (File file: files) {
    70.             if (file.isDirectory()){
    71.                 System.out.println(dir.getCanonicalPath()+"目录下的"+file.getName()+"文件夹");
    72.                 DFSFilePath(file);
    73.             }else {
    74.                 System.out.println(dir.getCanonicalPath()+"目录下的"+file.getName()+"文件");
    75.             }
    76.         }
    77.  
    78.     }
    79.  
    80.     /**
    81.      * 文件广度优先遍历
    82.      * @param dir
    83.      * @throws IOException
    84.      */
    85.     public static void NFSFilePath(File dir) throws IOException {
    86.         Deque fileDeque = new ArrayDeque<>();
    87.         fileDeque.offer(dir);
    88.         while (!fileDeque.isEmpty()){
    89.             File file = fileDeque.poll();
    90.             if (file.isDirectory()){
    91.                 File[] files = file.listFiles();
    92.                 for (File f:files) {
    93.                     fileDeque.offer(f);
    94.                 }
    95.                 System.out.println("文件夹：" + file.getCanonicalPath());
    96.             }else {
    97.                 System.out.println("文件：" + file.getCanonicalPath());
    98.             }
    99.  
    100.         }
    101.  
    102.     }
    103. }

     文件的读写

    文件的读数据：FileInputStream

    1，以字节流形式进行文件的读操作

    概念模型：

     

    2，以字符流方式进行文件的读操作（文本方式的文件）

    无论是字节流还是字符流，都是用Scanner类来读取数据

    1. public class 读数据都用Scanner {
    2.     public static void main(String[] args) throws Exception{
    3.         try(InputStream is = new FileInputStream("./hello.txt")){
    4.             try(Scanner scanner = new Scanner(is,"UTF-8")){
    5.                 while (scanner.hasNextLine()){
    6.                     String next = scanner.nextLine();
    7.                     System.out.println(next);
    8.                 }
    9.             }
    10.         }
    11.     }
    12. }

     写OutputStream:

    写数据在关闭资源的时候，需要对缓冲区进行刷盘，避免缓冲区中还未写入的数据。

     

    文件的复制

    1. public class 文件复制 {
    2.     public static void main(String[] args) throws Exception {
    3.         InputStream is = new FileInputStream("D:\\IO\\12.jpg");
    4.         byte[] buff = new byte[10240];//缓冲区，用来匹配内存和硬盘之间读写速度的差距
    5.         OutputStream os = new FileOutputStream("D:\\IO\\34.jpg");
    6.         while (true){
    7.             int read = is.read(buff);
    8.             if (read == -1){//如果是EOS，便是没有数据了，直接退出
    9.                 break;
    10.             }
    11.             os.write(buff);//将读到缓冲区的字节全部写入文件中
    12.             os.flush();//最后冲刷缓冲区
    13.         }
    14.  
    15.     }
    16. }

    文件夹的复制

    1. package com.yyk.io.IO操作文件;
    2.  
    3. import java.io.*;
    4.  
    5. public class 文件夹复制 {
    6.     static File srcFile = new File("D:\\IO\\A");//源文件目录
    7.     static File tarFile = new File("D:\\IO\\D"); //目标文件目录
    8.     public static void main(String[] args) throws Exception{
    9.         copy(srcFile);
    10.     }
    11.     private static void copy(File dirFile) throws Exception {
    12.         File[] files = dirFile.listFiles();
    13.         if (files == null){
    14.             return;
    15.         }
    16.         for (File file:files) {
    17.             String filePath = file.getCanonicalPath();//当前文件的目录
    18.             String tarFilePath = tarFile.getCanonicalPath();//需要复制的文件的根目录
    19.             String aimPath= tarFilePath + filePath.substring(srcFile.getCanonicalPath().length());//需要复制的目录
    20.             File aimFile = new File(aimPath);
    21.             if (file.isDirectory()) {//如果是文件夹，创建文件夹
    22.                 aimFile.mkdir();
    23.                 //就继续遍历
    24.                 copy(file);
    25.             }else if (file.isFile()){
    26.                 copyFile(file,aimFile);
    27.             }
    28.         }
    29.     }
    30.     public static void copyFile(File file,File aimFile) throws Exception {
    31.         InputStream is = new FileInputStream(file);
    32.         byte[] buff = new byte[10240];//缓冲区，用来匹配内存和硬盘之间读写速度的差距
    33.         OutputStream os = new FileOutputStream(aimFile);
    34.         while (true){
    35.             int read = is.read(buff);
    36. //            System.out.println("读到了"+read+"个字节");
    37.             if (read == -1){//如果是EOS，便是没有数据了，直接退出
    38.                 break;
    39.             }
    40.             os.write(buff,0,read);//将读到缓冲区的字节全部写入文件中
    41.             os.flush();//最后冲刷缓冲区
    42.         }
    43.  
    44.     }
    45. }

    模拟OJ测试文档的编写

    1. package com.yyk.io.IO操作文件.oj;
    2.  
    3. public class Node {
    4.     int val ;
    5.     Node next;
    6.     public Node(int val){
    7.         this.val = val;
    8.     }
    9. }
    1. package com.yyk.io.IO操作文件.oj;
    2.  
    3. public class Solution {
    4.     public Node reverse(Node head){
    5.         Node prev = null;
    6.         Node cur = head;
    7.         while (cur != null){
    8.             Node next = cur.next;
    9.             cur.next = prev;
    10.             prev = cur;
    11.             cur =next;
    12.         }
    13.         return prev;
    14.     }
    15. }
    1. package com.yyk.io.IO操作文件.oj;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.InputStream;
    6. import java.io.OutputStream;
    7. import java.util.Scanner;
    8.  
    9. public class 测试用例的检验 {
    10.     static Solution solution = new Solution();
    11.     static File inputFile = new File("D:\\IO\\C\\input.txt");
    12.     static File resFile = new File("D:\\IO\\C\\output.txt");
    13.  
    14.     public static void main(String[] args){
    15.         try{
    16.             //按行读输入输出文件
    17.             InputStream is = new FileInputStream(inputFile);//输入
    18.             InputStream res = new FileInputStream(resFile);//结果
    19.             Scanner isSc = new Scanner(is,"UTF-8");
    20.             Scanner resSc = new Scanner(res,"UTF-8");
    21.             while (isSc.hasNextLine()){
    22.                 String inStr = isSc.nextLine();
    23.                 String resStr = resSc.nextLine();
    24.                 test(inStr,resStr);
    25.             }
    26.             System.out.println("通过所有测试用例");
    27.         }catch (Exception e){
    28.  
    29.         }
    30.     }
    31.     private static void test(String inStr,String resStr){
    32.         StringBuilder sb = new StringBuilder();
    33.         try {
    34.             //将instr按找空格隔开，转为int，创建链表然后反转
    35.             String[] strs = inStr.split(" ");
    36.             Node head = new Node(-1);
    37.             Node tem = head;
    38.             for (String s:strs) {
    39.                 Node node = new Node(Integer.parseInt(s));
    40.                 tem.next = node;
    41.                 tem = node;
    42.             }
    43.             Node newNode = solution.reverse(head.next);//反转后的新链表
    44.             //遍历链表转为字符串
    45.             while (newNode != null){
    46.                 sb.append(newNode.val + " ");
    47.                 newNode = newNode.next;
    48.             }
    49.             //最后去掉最后一个空格
    50.             sb.delete(sb.length() - 1,sb.length());
    51.             if (!resStr.equals(sb.toString())){
    52.                 System.out.println("输入用例：" + inStr);
    53.                 System.out.println("期望输出：" + resStr);
    54.                 System.out.println("实际输出：" + sb.toString());
    55.                 System.exit(1);
    56.             }
    57.         }catch (Exception e){
    58.             System.out.println("输入用例：" + inStr);
    59.             System.out.println("期望输出：" + resStr);
    60.             System.out.println("实际输出：" + sb.toString());
    61.             e.printStackTrace();
    62.         }
    63.     }
    64. }

  • 相关阅读:
    【生产力++】脚本自动化提取待复习内容 极大提高复习效率（下）
    Java开发常用服务端口整理
    Java医院绩效考核管理系统源码，设有手工录入功能（可以批量导入）
    【面试：并发篇35：多线程：设计模式】享元模式
    json、pikcle序列化模块
    硬件及接口学习总结
    nginx测试配置文件的问题
    R语言计算两个向量成对元素的最小值：使用pmin函数计算dataframe数据中多个数据列的逐行最小值
    Linux相关命令整理
    Sass样式使用集锦
  • 原文地址：https://blog.csdn.net/qq_52655865/article/details/125864135