Shell的文件描述符操作，包括标准输入，标准输出，自定义文件描述符

Abstract:

1) Linux Shell 命令的标准输入、标准输出、标准错误，及其重定位；

2）Linux Shell 操作自定义文件描述符；

文件描述符是与文件相关联的一些整数，他们保持与已打开文件的关联。众所周知的文件描述符是标准输入stdin、标准输出stdout、标准错误stderr，我们可以重定位这些文件描述符关联文件的内容到另外一个文件文件描述符。

1. Linux Shell 命令的标准输入、标准输出、标准错误

当我们在编写 shell 脚本时，我们会非常频繁地操作执行命令的标准输入stdin、标准输出stdout、标准错误stderr。过滤 shell 脚本或者执行命令的输出信息并且把它们重定位到特定的地方，成了我们分析脚本执行情况的必要工作。当我们执行脚本文件或者执行一个 shell 命令的时候，单从终端输出我们很难区分哪些是标准输出，哪些是标准错误。然而，我们把这些信息重定向特定的地方，以便于我们分析脚本文件及 shell 命令的执行情况。

文件描述符是与打开文件或者数据流相关联的整数，0、1、2 是系统保留的三个文件描述符，分别对应标准输入、标准输出、标准错误。

Linux Shell 使用 " > "  ">>"  进行对文件描述符进行重定位。

">"  与 ">>"  的作用是不一样的，前者使用本次输出内容替换原有文件的内容，后者则是把本次输出追加到原文件的后面。

在对文件描述符进行详细分析之前，先执行以下命令，为后面的实验操作准备一些必要的文件：

  1. echo -e "\e[42;31m --- Prepare resource file ---\e[0m";
  2. echo "This is example text 1." > temp.txt;
  3. echo "This is example text 2." >> temp.txt;
  4. cat temp.txt;
  5. echo "a1" > a1;
  6. echo "a2" > a2;
  7. echo "a3" > a3;
  8. sudo chmod 000 a3;
  9. ls -alF a*;

1.1 获取 Linux Shell 命令执行结果

Linux Shell 中每一条 shell 命令的执行都有返回值，用以返回命令的执行结果。

在命令执行结束后，通过引用 $? 获取最后一条命令执行的返回值，当返回值为零代表命令执行成功。

  1. echo -e "\e[42;31m --- Get command execution result! ---\e[0m";
  2. ls + ;
  3. echo -e "\e[1;32m --- ‘ls + ‘ executed and return value is: $? \e[0m";
  4. ls -alF ./ ;
  5. echo -e "\e[1;32m --- ‘ls -alF ./‘ executed and return value is: $? \e[0m";

由于 “ ls + ” 的输入参数 “ + ”是一个 “ls” 命令不能接受的参数，所以由上面的执行结果可以看到命令执行的错误信息以及命令执行的返回值为： 2 ；

接下来的命令 “ls -alF” 是一条合法的命令，所以，我们看到它成功执行的返回值为：0 ；

重定位运算符 ">" ">>" 的默认参数为标准输出 stdout ，即 1 ;

所以 ">" 等价于 "1>"; ">>" 等价于 "1>>"

1.2 Linux Shell 标准输出 stdout 的重定位

  1. echo -e "\e[42;31m --- Redirect stdout ! ---\e[0m";
  2. ls + > out.txt;
  3. echo -e "\e[1;32m --- ‘ls + > out.txt‘ executed and return value is: $? \e[0m";
  4. echo -e "\e[1;32m --- Contents of out.txt as following descriptions:\e[0m \e[1;33m";
  5. cat out.txt;
  6. echo -e "\e[0m";
  7. rm out.txt;

由实验结果可以看出标准输出 stdout 重定向输出文件 out.txt 的内容为空；

因为 “ ls + ”命令的输入参数 “+” 为非法参数，所以命令执行失败，没有输出结果，并且同时看到命令执行返回值为： 2 ，非零，表示执行失败。

1.3 Linux Shell 标准错误 stderr 的重定位

  1. echo -e "\e[42;31m --- Redirect stderr ! --- \e[0m";
  2. ls + 2> out.txt;
  3. echo -e "\e[1;32m ‘ls + 2> out.txt‘ executed and return value is: $? \e[0m";
  4. echo -e "\e[1;32m Contents of out.txt as following descriptions:\e[0m \e[1;33m";
  5. cat out.txt;
  6. echo -e "\e[0m";
  7. rm out.txt;

由实验结果看出非法命令 "ls + 2> out.txt" 的执行并没有任何的输出，与之前的姐果一样；

不同的是，错误信息也没有在命令执行的时候输出到终端上面，而是被重定向到了文件 out.txt 里面；

1.4 Linux Shell 分别重定向标准输出 stdin 与标准错误 stderr 到指定的文件：

  1. echo -e "\e[42;31m --- Redirect stdout and stderr to exclusive files ! ---\e[0m";
  2. cat a* 2>stderr.txt
    1>stdout.txt;
  3. echo -e "\e[1;32m‘cat a* 2>stderr.txt 1>stdout.txt‘ executed and return value is: $? .\e[0m";
  4. echo -e "\e[1;32mContents of stderr.txt is:\e[0m \e[1;33m";
  5. cat stderr.txt;
  6. echo -e "\e[0m";
  7. echo -e "\e[1;32mContents of stdout.txt is:\e[0m \e[1;33m";
  8. cat stdout.txt;
  9. echo -e "\e[0m";
  10. rm stderr.txt stdout.txt;

这次的执行中无论是标准输出 stdout 与标准错误 stderr 都没有在命令执行时输出到终端上，只是分别输出到 stdout.txt 与 stderr.txt 中；

由于 a3 是一个没有读、写、执行命令权限的文件，所以当 cat a3 的时候就会有错误信息输出到 stderr.txt ；

a1、a2 则把文件内容输出到 stdout.txt ；

1.5 Linux Shell 重定向标准错误到标准输出：

1.5.1 使用 " 2>&1" 把标准错误
stderr 重定向到标准输出 stdout ；

  1. echo -e "\e[42;31m --- Redirect stderr to stdout approach first! ---\e[0m";
  2. cat a* > output.txt
    2>&1;
  3. echo -e "\e[1;32m‘cat a* 2>&1 output.txt‘ executed and return value is: $?\e[0m";
  4. echo -e "\e[1;32mContents of output.txt is:\e[0m \e[1;33m";
  5. cat output.txt;
  6. echo -e "\e[0m";
  7. rm output.txt;

由上面的实验结果看出， 无论是标准输出 stdin 还是标准错误 stderr ，都被重定向到了 output.txt 里面。

1.5.2 使用 "&>" 把标准错误 stderr 重定向到标准输出 stdout ；

  1. echo -e "\e[42;31m --- Redirect stderr to stdout approach second ! ---\e[0m";
  2. cat a* &> output.txt;
  3. echo -e "\e[1;32m‘cat a* &> output.txt‘ executed and return value is: $?\e[0m";
  4. echo -e "\e[1;32mContents of output.txt is:\e[0m \e[1;33m";
  5. cat output.txt;
  6. echo -e "\e[0m";
  7. rm output.txt

由实验结果，标准错误 stderr 被转化为标准输出 stdout ，并重定向到了 output.txt 中；

1.6 把标准错误 stderr 重定向到 /dev/null

  1. echo -e "\e[42;31m --- Redirect stderr to /dev/null ! ---\e[0m";
  2. cat a* 2>/dev/null;
  3. echo -e "\e[1;32m‘cat a* 2>/dev/null‘ executed and return value is $?\e[0m";

"/dev/null" 是一个特殊的设备文件，所有输入到其中的比特流都会被丢弃；

由实验结果看出，标准输出如常输出到终端上，而标准错误则没有输出，被重定位到 "/dev/null" 。

1.7 使用 tee 命令，实现重定向与终端双输出

当我们使用重定向输出时，所有信息都被重定向输出到我们指定的文件描述符，终端上面就再也看不到这些信息了；

我们可以通过 tee 命令，实现把信息重定向输出到文件的同时输出到终端，附上 tee 的使用说明：

tee 命令会从标准输出接受信息，把信息保存到指定的文件同时，把信息输出到标准输出；

1.7.1 把标准输出 stdout 重定向到
tee 的标准输入 stdin ：

  1. echo -e "\e[42;31m --- Redirect stdout as stdin of tee! --- \e[0m";
  2. cat a* | tee out.txt | cat -n;
  3. echo -e "\e[1;32m‘cat a* | tee out.txt | cat -n‘ executed and return value is: $?\e[0m";
  4. echo -e "\e[1;32mContents of out.txt is:\e[0m \e[1;33m";
  5. cat out.txt;
  6. echo -e "\e[0m";
  7. rm out.txt;

"cat a*" 的标准输出 stdout 通过pipe( "|" )重定向为 tee 的标准输入；

tee 把这些信息重定向到 out.txt 的同时，输出到 tee 的标准输出 stdout ；

tee 的标准输出通过 pipe("|") 重定向到了 "cat -n" 的标准输入；

所以以上实验结果应该这样看：

1）因为pipe("|") 只处理标准输出的信息，所以 cat a3 的错误信息依旧在终端直接输出，没有被重定向处理；

2）tee 从它的标准输入 stdin 只接收到 a1、a2 的内容，所以我们通过 "cat -n" 给输出信息加上行号来标识出 tee 接收到的信息；

3）再通过查看 out.txt 文件，发现 tee 命令输出到 out.txt 的信息，与 "cat -n"的信息是一致的；

1.7.2 把标准错误 stderr 转换成标准输出 stdout ，一同输出到 tee 的标准输入，以便把所有信息重定向到文件的同时，输出到终端：

  1. echo -e "\e[42;31m --- Redirect stdout burden with stderr as stdin of tee! --- \e[0m";
  2. cat a* 2>&1 | tee
    out.txt | cat -n;
  3. echo -e "\e[1;32m‘cat a* 2>&1 | tee out.txt | cat -n‘ executed and return value is: $?\e[0m"
  4. echo -e "\e[1;32mContents of out.txt is:\e[0m \e[1;33m";
  5. cat out.txt;
  6. echo -e "\e[0m";
  7. cat a* 2>&1 | tee -a out.txt | cat -n;
  8. echo -e "\e[1;32m‘cat a* 2>&1 | tee -a out.txt | cat -n‘ executed and return value is: $?\e[0m"
  9. echo -e "\e[1;32mContents of out.txt is:\e[0m \e[1;33m";
  10. cat out.txt;
  11. echo -e "\e[0m";
  12. rm out.txt;

前面提到的 " 2>&1 " 参数可以把命令的标准错误转换为标准输出，这里利用一下，举个实用的例子，呵呵！

tee 命令会把输出文件之前的内容冲掉，再把自己的输出信息输出到文件，但可以使用 " -a " 参数，实现追加方式把信息重定向到指定文件。

1.8 重定位标准输入 stdin

1.8.1 把重定向的标准输入作为命令的输入参数：

先来看看我们貌似已经十分熟悉的 cat 命令的帮助，不知道各位是否留意到有这样一招，反正我之前是没有留意到，呵呵！！！

原来 cat 使用 "-" 作为参数，就是把它接受的标准输入stdin 直接输出到它的标准输出；

呵呵！只能说之前学艺不精，没看到啊！

这里也学会了一点，就是在看linux 下命令的 help 时，我们要多加留心一下是否接受 stdin ；

如果接受 stdin 作为输入，这些命令的扩展用法就可以多好多咯。。。

好，言归正传，来一段实践代码再说，有图有真相嘛，呵呵！！！

  1. echo -e "\e[42;31m --- Use stdin as a command argument ! --- \e[0m";
  2. ls -alF | cat;
  3. echo -e "\e[1;32m‘ls -alF | cat‘ executed and return value is: $?\e[0m"
  4. ls -alF | cat -;
  5. echo -e "\e[1;32m‘ls -alF | cat -‘ executed and return value is: $?\e[0m";
  6. ls -alF | cat -n;
  7. echo -e "\e[1;32m‘ls -alF | cat -n‘ executed and return value is: $?\e[0m";
  8. ls -alF | cat /dev/stdin;
  9. echo -e "\e[1;32m‘ls -alF | cat /dev/stdin‘ executed and return value is: $?\e[0m"

这里要提提的就是 "-" 等价于 /dev/stdin ，你懂的。。。

1.8.2 从文件重定向 shell 命令的标准输入：

Linux Shell 使用 "cmd
< FILE " 的方式从一个文件重定向命令的标准输入；

  1. echo -e "\e[42;31m --- Redirect stdin from file ! --- \e[0m";
  2. cat < a1
  3. echo -e "\e[1;32m‘cat < a1‘ executed and return value is: $?\e[0m";
  4. cat - < a2;
  5. echo -e "\e[1;32m‘cat - < a2 executed and return value is: $?\e[0m";
  6. cat /dev/stdin < temp.txt;
  7. echo -e "\e[1;32m‘cat /dev/stdin < temp.txt‘ executed and return value is: $?\e[0m";

上面的 3 条执行命令把 a1、a2、a3 三个文件的内容重定向到命令的标准输入 stdin 。

1.8.3 把文本块重定向为 shell 命令的标准输入 stdin ：

有时候，我们需要把一个文本块（多行的文本）重定向给一个 shell 命令作为标准输入。

我们假设有这样一种情况，文本块来源于一个 shell 执行脚本里面，在这个 shell 脚本执行的时候，需要把这个文本块输出到一个文件；

如这样一个例子，一个 shell 脚本需要把它的执行 log 写到一个文件里面，

在文件的开头，需要加入几行信息作为这个 log 文件的开头用以注释一下这个文件，我们可以如下操作：

  1. echo -e "\e[42;31m --- Redirecting from a text block to a file within a script! --- \e[0m";
  2. cat <<EOF>log.txt
  3. Hello
  4. EOF
  5. echo -e "\e[1;32m‘cat <<EOF > log.txt Hello world! EOF‘ executed and return value is: $?\e[0m";
  6. echo -e "\e[1;32mContents of log.txt as following: \e[0m \e[1;33m";
  7. cat log.txt;
  8. echo -e "\e[0m";
  9. echo -e "\e[42;31m --- Redirecting from a text block to append into a file within a script! --- \e[0m";
  10. cat <<EOF >> log.txt
  11. Nice to meet
  12. EOF
  13. echo -e "\e[1;32m‘cat <<EOF >> log.txt Nice to meet you! EOF‘ executed and return value is $?\e[0m";
  14. echo -e "\e[1;32mContents of log.txt as following: \e[0m \e[1;33m";
  15. cat log.txt;
  16. echo -e "\e[0m";
  17. rm log.txt;

1）使用 "<<EOF text block 
 EOF" 的形式把一个 text block 重定向到一个 shell command 的标准输入；

2）上述实验把 text block 重定向给 cat 命令的标准输入， cat 再把它自己的标准输出 stdout 重定向到 log.txt ；

3）上述实验采取了 "> log.txt" 与 ">> log.txt" 两种方式对 cat 的标准输出 stdout 进行重定向到 log.txt ，

前者是重新创建文件进行信息的输出，后者是以追加的方式进行重定向输出；

2.
用户自定义文件描述符：

现在我们知道 0、1、2是 shell 保留的文件描述符；

另外，我们还可以定义自己的文件描述符，并对其进行读写；

用户自定义文件描述符使用 "exec" 命令进行创建；

用户自定义文件描述符的创建有三种形式：

1）只读方式的文件描述符；

2）截断模式创建写方式的文件描述符；

3）追加模式创建写方式的文件描述符；

2.1
以读方式创建文件描述符：

使用 "
exec descriptor<file
Name " 的模式创建只读模式的用户自定义文件描述符；

使用 "&descriptor" 的模式引用文件描述符；

只读方式的文件描述符只能读取一次，要再次读取，需要对文件描述符重新打开赋值；

  1. echo -e "\e[42;31m --- Create a file descriptor for reading file! --- \e[0m";
  2. exec 3<a1;
  3. echo -e "\e[1;32m‘exec 3<a1‘ executed to create a file descriptor 3 for reading and return value is: $? ---\e[0m";
  4. echo -e "\e[1;32mContents of a1 as following output:\e[0m \e[1;33m";
  5. cat <&3;
  6. echo -e "\e[0m";
  7. echo -e "\e[1;32mContents of a1 with file descriptor 3 to read again as following output:\e[0m \e[1;33m";
  8. cat <&3;
  9. echo -e "\e[0m";

如实验结果，当我们再次打开文件对文件描述符重新赋值之前，我们再次使用文件描述符 3 对文件进行读取时，没有任何输出内容。

2.2 以截断模式创建写方式的文件描述符：

所谓截断模式，就是相当于重新创建文件，文件之前的内容将会丢失；

使用 " exec descriptor>file
Name " 的模式创建截断模式的用户自定义的写方式的文件描述符；

使用 "&descriptor" 的模式引用文件描述符；

写方式的文件描述符只要一次打开便可多次写入，并且后续的写入操作会一直追加到文件的结尾，但是文件打开之前的内容就会丢失；

  1. echo -e "\e[42;31m --- Create a file descriptor for writing file in truncation mode!\e[0m";
  2. echo -e "\e[1;32mContents of a2 before writing it as following output: \e[0m \e[1;33m";
  3. cat a2;
  4. echo -e "\e[0m";
  5. exec 4>a2;
  6. echo -e "\e[1;32m ‘exec 4>a2‘ executed to create a file descriptor 4 for writing.\e[0m";
  7. echo "newline in truncation mode" >&4;
  8. echo -e "\e[1;32m ‘echo \"newline in truncation mode\" >&4‘ executed and return value is: $?\e[0m";
  9. echo -e "\e[1;32mContents of a2 after writing in truncation mode as follwing output: \e[0m \e[1;33m";
  10. cat a2;
  11. echo -e "\e[0m";
  12. echo "newline in truncation mode 2" >&4;
  13. echo -e "\e[1;32m ‘echo \"newline in truncation mode 2\" >&4‘ executed and return value is: $?\e[0m";
  14. echo -e "\e[1;32mContents of a2 after writing twice in truncation mode as follwing output: \e[0m \e[1;33m";
  15. cat a2;
  16. echo -e "\e[0m";
  17. exec 4>a2;
  18. echo -e "\e[1;32m ‘exec 4>a2‘ executed to reassign file descriptor 4 for writing\e[0m";
  19. echo "newline in truncation mode 3" >&4;
  20. echo -e "\e[1;32m ‘echo \"newline in truncation mode 3\" >&4‘ executed and return value is: $?\e[0m";
  21. echo -e "\e[1;32mContents of a2 after reassign its file descriptor for writing in truncation mode: \e[0m \e[1;33m";
  22. cat a2;
  23. echo -e "\e[0m";

由上述实验结果可以看到，我们引用 "&4" 文件描述符，并且对其进行多次写入，后面的写入内容会追加到之前写入信息的后面；

当我们对文件描述符进行再次打开后，再引用 "&4" 文件描述符，并且对其进行写入，发现之前两次写入的内容已经丢失，只剩下最后一次写入的信息了。

2.3 以追加模式创建写方式的文件描述符：

所谓追加模式，就是打开文件进行写操作，文件之前的内容不会丢失，写操作写入的内容以追加方式添加到文件的末尾；

使用 " exec descriptor>>file
Name " 的模式创建追加模式的用户自定义的写方式的文件描述符；

使用 "&descriptor" 的模式引用文件描述符；

写方式的文件描述符只要一次打开便可多次写入，并且后续的写入操作会一直追加到文件的结尾；

  1. echo -e "\e[42;31m --- Create a file descriptor for writing file in append mode!\e[0m";
  2. echo -e "\e[1;32mContents of temp.txt before writing it as following output: \e[0m \e[1;33m";
  3. cat temp.txt;
  4. echo -e "\e[0m";
  5. exec 5>>temp.txt;
  6. echo -e "\e[1;32m ‘exec 5>>temp.txt‘ executed to create a file descriptor 5 for appending.\e[0m";
  7. echo "newline in append mode" >&5;
  8. echo -e "\e[1;32m ‘echo \"newline in append mode\" >&5‘ executed and return value is: $?\e[0m";
  9. echo -e "\e[1;32mContents of temp.txt after writing in append mode as follwing output: \e[0m \e[1;33m";
  10. cat temp.txt;
  11. echo -e "\e[0m";
  12. echo "newline in append mode 2" >&5;
  13. echo -e "\e[1;32m ‘echo \"newline in append mode 2\" >&5‘ executed and return value is: $?\e[0m";
  14. echo -e "\e[1;32mContents of temp.txt after writing twice in append mode as follwing output: \e[0m \e[1;33m";
  15. cat temp.txt;
  16. echo -e "\e[0m";
  17. exec 5>>temp.txt;
  18. echo -e "\e[1;32m ‘exec 5>>temp.txt‘ executed to reassign file descriptor 5 for writing: $?\e[0m";
  19. echo "newline in append mode 3" >&5;
  20. echo -e "\e[1;32m ‘echo \"newline in append mode 3\" >&5‘ executed and return value is: $?\e[0m";
  21. echo -e "\e[1;32mContents of temp.txt after reassign its file descriptor for writing in append mode: \e[0m \e[1;33m";
  22. cat temp.txt;
  23. echo -e "\e[0m";

时间： 2024-10-09 15:20:46

Shell的文件描述符操作，包括标准输入，标准输出，自定义文件描述符的相关文章

Java File 类 文件的常用操作（递归遍历所有文件，统计文件大小，删除文件）

1 package com.beiwo.homework; 2 3 import java.io.File; 4 5 /* 6 4.将一个文件夹中所有的文件查找出来,按照一定的格式 7 分析 : 1.一个文件夹中存在文件,子文件夹 8 2.除了当前文件夹,还有子文件夹中的文件也需要找出来. 9 3.子文件查找文件和当前文件查找文件是一样的操作,就可以定义一个方法来做文件查找 10 11 3.删除一周前的数据 12 13 2.获取文件夹中所有文件的大小 14 15 1.判断是否有隐藏文件 16 1

Java实现读取文件夹下（包括子目录）所有文件的文件名

在编程的过程中,经常会用到对文件的读写操作等.比如,找出某一个文件夹下的所有文件名等. 下面的程序给出了,获取某一给定文件夹下所有文件的绝对路径的程序.可以作为某一个模块,在需要的时候直接使用. package src; import java.io.BufferedWriter; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStrea

linux中文件I/O操作（系统I/O）

我们都知道linux下所有设备都是以文件存在的,所以当我们需要用到这些设备的时候,首先就需要打开它们,下面我们来详细了解一下文件I/O操作. 用到的文件I/O有以下几个操作:打开文件.读文件.写文件.关闭文件等,对应用到的函数有:open.read.write.close.lseek(文件指针偏移) 文件描述符:对于内核而言,所有打开的文件都通过文件按描述符引用.文件描述符是一个非负整数.                      当打开一个现有文件或者创建一个新文件时,内核向进程返回一个文件描

IO系统-文件与目录操作

1.文件内核数据结构 一个打开的文件在内核中使用三种数据结构表示: (1)文件描述符表 文件描述符标志 文件表项指针 (2)文件表项: 文件状态标志:读.写.追加.同步和非阻塞等状态标志 当前文件偏移量 i节点表项指针 引用计数器 (3)i节点 文件类型和对该文件的操作函数指针 当前文件长度 文件所有者 文件所在的设备.文件访问权限 指向文件数据在磁盘上所在位置的指针等. 2. 原子操作 (1)文件追加 打开文件时使用O_APPEND标志,进程对文件偏移量调整和数据追加成为原子操作. O_APP

总结文件打开及操作

文件处理的三个步骤: 1.打开文件拿到文件对象(文件对象====>操作系统打开文件====>硬盘) f=open(r'文件路径'.mode='rb')(mode后面''中的前世打开的模式后面是文件操作内容模式): 绝对路径D:\a\d\a\.txt 相对路径:相对于当前执行文件夹为起始点进行查找(\  /  无影响都可读) 2.操作文件:读/写 f.read() 全部读出来 f.readline() 读从起始点遇到换行符的第一行 f.readline()全部读取并以列表形式体现 f.reada

Python小白学习之路（二十）—【打开文件的模式二】【文件的其他操作】

打开文件的模式(二) 对于非文本文件,我们只能使用b模式,"b"表示以字节的方式操作(而所有文件也都是以字节的形式存储的,使用这种模式无需考虑文本文件的字符编码.图片文件的jgp格式.视频文件的avi格式) rb:   以字节方式读文件 wb: 以字节方式写文件ab: 以字节方式追加文件 注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型,所以不能指定编码 1. rb #错误举例 f = open ('test1.py', 'rb', encoding = 'utf

【Java】利用文件输入输出流完成把一个文件夹内的所有文件拷贝的另一的文件夹的操作

一.基本目标 使用Java完成如下的操作: 把一个文件夹内的所有文件拷贝的另一的文件夹,例如,在F盘中有a与b两个文件夹: f:/a里面有一堆文件,运行Java程序之后就会全部复制到f:/b,并且完成重命名,在所有文件之前加rename_的前缀,如果里面有文件夹,则文件夹不重命名,里面的文件进行重命名,同样在所有文件之前加rename_的前缀: 二.制作过程 1.首先主函数非常简单,就是调用了上面FileTest类中的copyFolder函数 public class FileCopy { pu

C/C++关于文件的读写操作以及文件的打开和保存

通过近来的学习,总结一下关于文件的读写操作以及文件的打开和保存的方法. 一.文件的读写操作: (1)C语言对文件的读写操作 在C语言中,对文件的读写操作是用FILE结构体和常用的对文件操作的函数实现的,下面总结一下C语言中对文件操作的常用函数: fopen()   打开以文件名指定的文件 fwrite()  写文件 fread()  读文件 fseek()  移动文件的指针到新的位置通过该函数的参数设定的偏移量和初始位置 rewind()  移动文件的指针到文件流的开始位置,在通常情况下可用fs

人生苦短之Python文件的IO操作

在Python中也有涉及到文件的相关操作,从最简单的文件读取说起 文件读取 file = open('/Users/macbookpro/Desktop/使用教程.txt', 'r', encoding='utf-8') print(file.read()) file.close() 使用open打开一个文件,第一个参数是文件路径,第二个参数是操作模式,第三个参数是文件编码.'r'代表的意思是只读方式,只可以读取文件里的内容.那么还有哪些操作呢 以行读取 readline(),后面括号可以添加数

Java.io下的方法是对磁盘上的文件进行磁盘操作

File类(java.io.*)可表示一个文件,也有可能是一个目录(在JAVA中文件和目录都属于这个类中,而且区分不是非常的明显). Java.io下的方法是对磁盘上的文件进行磁盘操作,但是无法读取文件的内容. 注意:创建一个文件对象和创建一个文件在JAVA中是两个不同的概念.前者是在虚拟机中创建了一个文件,但却并没有将它真正地创建到OS的文件系统中,随着虚拟机的关闭,这个创建的对象也就消失了.而创建一个文件才是在系统中真正地建立一个文件. 1 package TomTexts; 2 impor