摘要
Java基础加强重温_09：
File类（绝对路径/相对路径、创建文件/文件夹对象、获取/判断/创建/删除/遍历）
递归（递归概念:方法自己调用自己）
IO流（字节流/字符流、输入流/输出流）
字节输入流（InputStream类、FileInputStream类、读取字节/循环读取字节/读取字节数组/有效读取字节转换）
字节输出流（OutStream类、FileInOutStream类、写出字节/写出字节数组/写出指定长度字节数组/写出数据追加/写出换行）
字符输入流（Reader类、FileReader类、读取字符/读取字符数组/有效读取字符转换）
字符输出流（Wrtiter类、FileWriter类、写出字符/写出字符数组/写出字符串/关闭和刷新）
字节、字符、字节数组、字符数组、字符串
一、File类
java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
绝对路径
以盘符开始的路径，在系统中具有唯一性
比如说： c:/aaa/bbb/a.txt、d:/xxx/yyy/a.txt
相对路径
相对某个位置而已，不具有唯一性
比如：a.txt，默认相对于当前项目的根目录
比如：aaa/a.txt 默认相对于当前项目的根目录
当前项目的根目录
当前项目的根目录即为project目录
IDEA_IDEA项目-根目录-重命名
https://blog.csdn.net/u010003835/article/details/81705379
如何判断文件路径是相对路径还是绝对路径？
判断是否以盘符开始
如果是则是绝对路径，否则是相对路径：默认相对于当前项目的根目录
1、构造方法
public File(String pathname)
//根据文件路径字符串创建文件对象。
public File(String parent, String child)
//根据父路径字符串和子路径字符串创建文件对象（父子路径合并）
public File(File parent, String child)
//根据父路径文件对象和子路径字符串创建文件对象（对象路径字符串路径合并）
构造方法示例
public class Demo02 {
public static void main(String[] args) {
// public File(String pathname) 根据文件路径字符串创建文件对象
// 使用相对路径
File f1 = new File("a.png");
System.out.println(f1);
// 使用绝对路径
File f2 = new File("c:/a/b/c.txt");
System.out.println(f2);
// public File(String parent,String child)
// 根据父路径字符串和子路径字符串创建文件对象
File f3 = new File("d:/aaa/", "a.txt");
System.out.println(f3);
/*
*public File(File parent,String child)
根据父路径文件对象和子路径字符串创建文件对象
* */
File f4 = new File(new File("d:/aaa/"), "a.txt");
System.out.println(f4);
}
}
2、File类的静态成员变量（pathSeparator、separator）
File类两个常见的静态成员变量：pathSeparator、separator
static String pathSeparator 路径分割符
* 与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
* 不同的系统有不同的分隔符
* windows系统是：; (分号)
* linux或mac系统是： : （冒号）
static String separator 默认名称分隔符
* 与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
* 不同的系统有不同的分隔符
* windows系统是：\
* linux或mac系统是： /
pathSeparator、separator使用示例
public class Demo04 {
public static void main(String[] args)throws Exception {
System.out.println(File.pathSeparator);
System.out.println(File.separator);
FileReader fr = new FileReader("aaa"+File.separator+"a.txt");
fr.read();
fr.close();
}
}
二、File类常用方法
1、获取功能的方法（获取文件信息）
public String getAbsolutePath()
//获得文件的绝对路径字符串
public String getPath()
//获得创建文件对象时指定的路径字符串
public String getName()
//获得文件或文件夹名字
public long length()
//获得文件的大小，单位：字节
//只能获得文件的大小，不能获得文件夹的大小
//如果是文件夹则返回值是一个不确定的值：垃圾值
API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。
代码示例
public class Demo031 {
public static void main(String[] args) {
// 创建文件对象
File f = new File("/Users/pkxing/documents/124期");
// 获得文件的绝对路径字符串
System.out.println(f.getAbsolutePath());
// 获得创建文件对象时指定的路径字符串
System.out.println(f.getPath());
// 获得文件名
System.out.println(f.getName());
// 获得文件大小
System.out.println(f.length());
}
}
2、判断功能的方法
boolean exists();
//判断文件或文件夹是否存在
//存在返回true，否则false
boolean isDirectory();
//判断文件对象关联的是否是文件夹
//是则返回true，否则false
boolean isFile();
//判断文件对象关联的是否是文件
//是返回true，否则false
代码示例
public class Demo032 {
public static void main(String[] args) {
// 创建文件对象
File f = new File("/Users/pkxing/documents/xxx");
// 判断文件是否存在
System.out.println(f.exists());
// 判断是否是文件夹
System.out.println(f.isDirectory());
// 判断是否是文件
System.out.println(f.isFile());
}
}
3、创建功能的方法（创建文件和文件夹）
boolean createNewFile();
创建文件，只能创建文件不能创建文件夹
创建成功返回true，失败返回false
如果文件存在了，则不会再创建，返回false
boolean mkdir(); //mkdir=make directory
创建单级文件夹，只能创建文件夹，不能创建文件
创建成功返回true，失败返回false
如果文件夹存在了，则不会再创建，返回false
boolean mkdirs();
创建多级文件夹,只能创建文件夹，不能创建文件
创建成功返回true，失败返回false
如果文件夹存在了，则不会再创建，返回false
代码示例
public class Demo033 {
public static void main(String[] args) throws IOException {
// 创建文件对象
File f = new File("eee.txt");
// 创建文件
// System.out.println(f.createNewFile());
// 创建单级目录（文件夹)
File f2= new File("newDir");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否创建:"+f2.mkdir()); // true
System.out.println("是否存在:"+f2.exists());// true
// 创建多级目录（文件夹)
File f4= new File("newDira\\newDirb");
System.out.println(f4.mkdirs());// true
}
}
4、删除功能的方法
boolean delete();
删除文件或文件夹，删除成功返回true，否则false。
如果是文件夹，只能删除空文件夹（包含文件/文件夹的文件夹不能删除）。
代码示例
public class Demo034 {
public static void main(String[] args) {
// 创建文件对象
File f = new File("/Users/pkxing/documents/aaa.mp4");
// 删除文件
System.out.println(f.delete());
//创建文件夹
File f2 = new File("/Users/pkxing/documents/newDirc");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否创建:"+f2.mkdir()); // true
//删除文件夹
System.out.println(f2.delete()); // true
}
}
API中说明：delete方法，如果此File表示目录，则目录必须为空才能删除。
5、遍历功能的方法（目录的遍历）
目录即文件夹
String[] list();
用来获得当前文件夹下的所有文件和文件夹的名字，返回字符串数组
文件名字：电脑显示后缀则包括后缀，不显示则不包括（与人自己看到的一样）
File[] listFiles();
用来获得当前文件夹下的所有文件和文件夹的绝对路径，返回文件对象数组（File[]）
//注意实现：使用上面两个方法时，文件对象关联的必须是文件夹
File类中的list()和listFiles()方法
https://www.jianshu.com/p/9c47e9a9ed84
代码示例1
public class FileFor {
public static void main(String[] args) {
File dir = new File("d:\\java_code");
//获取当前目录下的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
//获取当前目录下的文件以及文件夹对象
//只要拿到了文件对象，那么就可以获取更多信息
File[] files = dir.listFiles();
//数组不能直接在forEach中使用lambda表达式，需要转换成流才可以使用
for (File file : files) {
System.out.println(file);
}
}
}
调用listFiles方法的File对象，必须是实际存在的目录，否则返回null，无法进行遍历。
代码示例2
public class Demo034 {
public static void main(String[] args) {
long size = 0;
// 创建文件对象
File f = new File("/Users/pkxing/documents/aaaa");
if (f.isDirectory()){
// 用来获得当前文件夹下的所有文件
File[] files = f.listFiles();
// 增强for本质迭代器 files.iterator();
for (File file : files) {
// System.out.println(file.getName());
if (file.isFile()){
size += file.length();
}
}
}
System.out.println(size);
}
}
Java中forEach使用lambda表达式，数组和集合区别
https://blog.csdn.net/u010938610/article/details/82699321
三、递归
递归：指在当前方法内调用自己的这种现象。
public static void main(String[] args) {
System.out.println("main");
main(args);
}
递归的注意事项
1、递归必须有出口：结束递归的条件
2、递归次数不能太多
递归次数太多方法入栈消耗栈内存超过栈内存最大容量 或者 没有结束条件会一直执行递归导致异常，Exception in thread “main” java.lang.StackOverflowError：栈内存溢出
递归分类
直接递归
直接递归：方法A调用方法A (重点)
public class Demo051 {
private static int index = 0;
public static void main(String[] args) {
System.out.println("main..." + index++); // 0
testA();
System.out.println("main..." + index++); // 7
}
public static void testA() {
if (index >= 4) return;
System.out.println("testA..." + index++); // 1
testA();
System.out.println("testA..." + index++); // 6
}
}
间接递归
间接递归：方法A调用方法B，方法B调用方法C，方法C调用方法A (了解)
四、递归案例
1、递归累和
需求
使用递归求1到5的和
分析
使用递归实现功能的步骤：
- 定义方法：确定返回值和参数列表
- 找递归的规律
- 找递归的出口
分析查找递归规律
n = 5;
sum(5) = 1 + 2 + 3 + 4 + 5 = sum(4) + 5 = 15
n = 4;
sum(4) = 1 + 2 + 3 + 4 = sum(3) + 4 = 10
n = 3;
sum(3) = 1 + 2 + 3 = sum(2) + 3 = 6
n = 2;
sum(2) = 1 + 2 = sum(1) + 2 = 3
n = 1;
sum(1) = 1
当n>1时：sum(n) = sum(n-1) + n;
当n=1时：sum(1) = 1;
代码实现
public class Demo061 {
public static void main(String[] args) {
System.out.println(sum(5));
}
// 1. 定义方法：确定返回值和参数列表
public static int sum(int n){
if (n == 1) return 1;
return sum(n-1) + n;
}
}
代码执行图解
递归一定要有条件限定，保证递归能够停止下来，次数不要太多，否则会发生栈内存溢出。
2、递归求阶乘
需求：
使用递归求5!
分析
阶乘：所有小于及等于该数的正整数的积。
n的阶乘：n! = n * (n-1) *...* 3 * 2 * 1
推理得出：n! = n * (n-1)!
与累和类似，不过换成了了乘法运算，需要注意阶乘值符合int类型的范围。
代码实现
public class DiGuiDemo {
//计算n的阶乘，使用递归完成
public static void main(String[] args) {
int n = 3;
// 调用求阶乘的方法
int value = getValue(n);
// 输出结果
System.out.println("阶乘为:"+ value);
}
/*
通过递归算法实现.
参数列表:int
返回值类型: int
*/
public static int getValue(int n) {
// 1的阶乘为1
if (n == 1) {
return 1;
}
/*
n不为1时,方法返回 n! = n*(n-1)!
递归调用getValue⽅方法
*/
return n * getValue(n - 1);
}
}
3、文件搜索（递归结合File类）
需求
搜索c:\abc目录中的.java文件。
代码实现
public class Demo063 {
public static void main(String[] args) {
// 创建文件对象：关联目标文件夹
File dir = new File("/Users/pkxing/documents/124期");
printJavaFile(dir);
}
//1. 定义方法：确定返回值和参数列表
//打印指定目录下的所有Java文件名
public static void printJavaFile(File dir){
// 1. 获得当前目录下所有文件：文件数组
File[] files = dir.listFiles();
// 2. 遍历文件数组：获得每个文件对象
for (File file : files) {
// 3. 判断是否是文件夹
if (file.isDirectory()){
// 如果是则递归调用当前方法
printJavaFile(file);
} else {
// 4. 判断是否是java文件，是则输出文件名
if (file.getName().endsWith(".java")){
System.out.println(file.getName());
}
}
}
}
}
五、IO概述
1、什么是IO
生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。
我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为 输入input 和 输出output ，即流向内存是输入流，流出内存是输出流。
Java中I/O操作主要是指使用 java.io 包下的内容，进行输入、输出操作。输入叫做读取数据，输出叫做作写出数据。
Input：输入：数据从文件到内存中
Output：输出：数据从内存到文件中
为什么要使用IO？
目前数据使用集合和数组，集合或数组保存在内存中的，内存是临时性存储，一旦电脑断电或程序重新启动，数据就没有了。
如果需要保证数据永久存储，就需要将数据存储到硬盘的文件中。通过IO流我们就可以将数据保存到文件中，也可以从文件中读取数据到程序中。
IO流的作用：
保存数据和读取数据，实现数据持久化（即保存数据到本地硬盘）
保存数据：将内存中的数据保存硬盘中文件
读取数据：将文件中的数据读取到内存中
2、IO的分类
根据数据的流向分为：输入流和输出流。
输入流 ：把数据从 其他设备 上读取到 内存 中的流。
输出流 ：把数据从 内存 中写出到 其他设备 上的流。
根据数据的类型分为：字节流和字符流。
字节流 ：以字节为单位，读写数据的流。
字符流 ：以字符为单位，读写数据的流。
根据数据类型和流向分类
字节输入流：以字节为单位读取数据 FileInputStream
字节输出流：以字节为单位输出数据 FileOutputStream
字符输入流：以字符为单位读取数据 FileReader
字符输出流：以字符为单位输出数据 FileWriter
如何判断流是字符流还是字节流？
根据类名判断，如果是Stream结尾的则都是字节流，其他都是字符流
3、IO的流向说明图解
数据的本质
数据的本质是二进制数字，就是0和1
计算机小常识
计算机只能识别0和1
所有的数据在计算机都是以0和1存储
所有数据在传输过程中都是0和1
编程语言分类
机器语言 通过0和1进行编程
汇编语言 mov a,b
高级语言 c/c++/java/php/…
编码和解码概述
编码：将文本转换为二进制数据的过程
解码：将二进制数据转换为文本的过程
计算机中数据的本质
https://www.cnblogs.com/delsav/p/9236509.html
4、IO流的顶级父类
六、字节流
一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都是一个一个的字节，传输时也是如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用么样的流对象，底层传输的始终为二进制数据。
1、字节输出流超类【OutputStream】
java.io.OutputStream 抽象类是所有字节输出流的超类(即父类)，将指定的字节信息写出到目的地，以字节为单位输出数据。它定义了字节输出流的基本共性功能方法。
因为是一个抽象类：不能直接创建该类对象，只能创建子类对象
常用方法
public void write(byte[] b)
输出字节数组的内容到目标文件中：输出字节数组的所有内容
public void write(byte[] b, int off, int len)
输出字节数组的部分内容到目标文件中
off：字节数组的起始索引
len：要输出的字节个数
public abstract void write(int b)
输出一个字节
public void close()
关闭流释放资源
public void flush()
刷新缓冲区的数据强行输出
1、close方法，当完成流的操作时，必须调用此⽅方法，释放系统资源。
2、flush()，是把缓冲区的数据强行输出, 主要用在IO中，即清空缓冲区数据，一般在读写流(stream)的时候，数据是先被读到了内存中，再把数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先flush()。
输出流flush()用法：https://blog.csdn.net/iteye_10289/article/details/82450523
OutputStream类常用子类
1、FileOutputStream(今天的重点)
2、BufferedOutputStream
3、ObjectOutputStream
4、PrintStream
全面整理Java IO流：https://www.it610.com/article/1659232.htm
2、文件输出流（FileOutputStream类）
java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。
构造方法
public FileOutputStream(File file)
public FileOutputStream(String name)
* 根据文件路径字符串或文件对象创建字节输出流对象
* 如果目标文件不存在，则会自动创建
public FileOutputStream(File file, boolean append)
public FileOutputStream(String name, boolean append)
* 根据文件路径或文件对象创建字节输出流
* append 为 true 表示追加输出数据
* append 为 false 表示不追加输出数据，会先清空文件内容
代码示例
public class FileOutputStreamConstructor throws IOException {
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileOutputStream fos = new FileOutputStream(file);
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("b.txt");
}
}
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
3、文件输出流代码示例
写出字节数据
write(int b) 方法，每次可以写出一个字节数据
public class Demo102 {
public static void main(String[] args) throws Exception{
// 1. 创建字节输出流对象并关联目标文件
OutputStream fos = new FileOutputStream("a.txt");
// 2. 调用字节输出流对象的write方法输出数据
// 97 ==> 编码 ==> 010101011
// 010101011 ==> 解码 ==> 97 ==> ASCII表 ===> a
fos.write(97);
// 300 ==> 00000000 00000000 00000001 00101100
// 00101100
fos.write(300);
fos.write(44);
// 3. 调用字节输出流对象的close方法关闭流释放资源
fos.close();
}
}
- 虽然write(int b) 参数为int类型四个字节，但是只会保留一个字节的信息写出。
- 流操作完毕后，必须释放系统资源，调⽤用close⽅方法，千万记得。
写出字节数组
write(byte[] b) ，每次可以写出数组中的数据，代码使用演示：
public class Demo103 {
public static void main(String[] args) throws Exception {
// 1. 创建字节输出流对象并关联目标文件
FileOutputStream fos = new FileOutputStream("b.txt");
// 2.1 要输出的数据
String str = "你好";
// 2.2 将字符串转换为字节数组
byte[] buf = str.getBytes();
// 2.3 调用write方法输出数据
fos.write(buf);
// 输出字节数组的部分内容
byte[] b = {97,98,99,100,101}; // abcde
fos.write(b, 1, 3); // bcd
// 3. 调用close方法关闭流释放资源
// fos.close();
}
}
写出指定长度字节数组
write(byte[] b, int off, int len) ，每次写出从off索引开始，到第len个索引的字节
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
fos.write(b,2,2);
// 关闭资源
fos.close();
}
}
查看fos.txt输出结果：
cd
数据追加续写
以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。
使用追究续写的构造方法创建的输出流对象，就可以指定是否追加续写。
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt"，true);
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
fos.write(b);
// 关闭资源
fos.close();
}
}
文件操作前：cd
文件操作后：cdabcde
写出换行
Windows系统里，换行符号是 \r\n。在内容后面输出一个换行符就可以实现换行输出
\r 回车符
\n 换行符
\r\n 换行符(推荐使用)
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt");
// 定义字节数组
byte[] words = {97,98,99,100,101};
// 遍历数组
for (int i = 0; i < words.length; i++) {
// 写出一个字节
fos.write(words[i]);
// 写出一个换行, 换行符号转成数组写出
fos.write("\r\n".getBytes());
}
// 关闭资源
fos.close();
}
}
输出结果：
a
b
c
d
e
回车符 \r 和换行符 \n ：
- 回车符：回到一行的开头（return）。
- 换行符：下一行（newline）。
不同系统中的换行：
- Windows系统里，每行结尾是 回车+换行 ，即 \r\n ；
- Unix系统里，每行结尾只有 换行 ，即 \n ；
- Mac系统里，每行结尾是 回车 ，即 \r 。从 Mac OS X开始与Linux统一。
小结
注意事项小结
- 流关联的目标文件必须是普通文件，不能是文件夹
- 流一旦关闭之后就不能再读写数据了
4、字节输入流超类【InputStream】
java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
字节输入流：以字节为单位读取文件数据
是一个抽象类：不能直接创建对象，只能创建子类对象
是所有字节输入流的父类
常用方法
void close(); 关闭流释放资源
int read()
从流关联的目标文件中读取1个字节
返回读取到的字节数
如果读取到文件末尾，返回值-1
int read(byte[] b) ==> 重点
从流关联的目标文件中读取数据到指定的字节数组中
返回实际读取到的字节个数
如果读取到文件末尾，返回值-1
int read(byte[] b, int off, int len) ==> 了解
从流关联的目标文件中读取数据到指定的字节数组中
off：字节数组的起始索引
len：存储字节的长度
如果读取到文件末尾，返回值-1
close方法，当完成流的操作时，必须调用此方法，释放系统资源。
InputStream类常用子类
FileInputStream(今天重点)
BufferedInputStream
ObjectInputStream
5、文件输入流（FileInputStream类）
java.io.FileInputStream 类是文件输入流，从文件中读取字节。
继承InputStream
本质是字节输入流，以字节为单位读取数据
构造方法
FileInputStream(String path)
FileInputStream(File file)
根据文件路径字符串或文件对象创建字节输入流对象
当你创建一个流对象时，必须传入一个文件路径。该路路径下，如果没有该文件,会抛出FileNotFoundException 。
代码示例
public class FileInputStreamConstructor throws IOException{
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);
// 使用文件名称创建流对象
FileInputStream fos = new FileInputStream("b.txt");
}
}
6、字节输入流代码示例
读取单个字节数据
read 方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
//读取数据，返回一个字节
int read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
//读取到末尾,返回-1
read = fis.read();
System.out.println( read);
// 关闭资源
fis.close();
}
}
输出结果：
a
b
c
d
e
-1
循环改进读取单个数据
public class FISRead {
public static void main(String[] args) throws IOException{
//使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
//定义变量，保存数据
int b ;
// 循环读取
while ((b = fis.read())!=-1) {
System.out.println((char)b);
}
// 关闭资源
fis.close();
}
}
输出结果：
a
b
c
d
e
- 虽然读取了一个字节，但是会自动提升为int类型。
- 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
使用字节数组读取示例1
read(byte[] b) ，每次读取b长度个数的字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1
public class FISRead {
public static void main(String[] args) throws IOException{
//使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
// 定义字节数组，作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (fis.read(b) != -1) {
// 每次读取后,把数组变成字符串打印
System.out.println(new String(b));
}
// 关闭资源
fis.close();
}
}
输出结果：
ab
cd
ed
ed 错误数据 d ，是由于最后一次读取时，只读取一个字节 e ，数组中上次读取的数据没有被完全替换。所以要通过 len 获取有效读取的字节，限定每次读取2个，但最后ed只读取了1个，所以有效字节是1个。读取多少个就转换多少个。
ed 只读取了e 1个，有效读取字节为1，但d还存在数组中。所以最后ed只转换1个字节就只转换出e，不会转换出d
有效字节改进字节数组读取
public class FISRead {
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt"); // ⽂文件中为abcde
// 定义变：接收实际读取到的字节个数
int len ；
// 定义字节数组，作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=-1) {
// 每次读取后,把数组的有效字节部分，变成字符串打印
System.out.println(new String(b，0，len));// len 每次读取的有效字节个数
}
// 关闭资源
fis.close();
}
}
输出结果：
ab
cd
e
使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。
使用字节数组读取示例2
采用1024的字节数组
public class Demo113 {
public static void main(String[] args) throws Exception {
// 1. 创建流关联目标文件： abcde
FileInputStream fis = new FileInputStream("a.txt");
// 2. 创建字节数组：用来存储读取到的数据
byte[] buf = new byte[1024];
// 定义变量变量：接收实际读取到的字节个数
int len = -1;
// 循环读取数据
while((len = fis.read(buf)) != -1){ // 5
// 读取多少给字节就转换多少字节为字符串 ab cd e
System.out.print(new String(buf,0,len));
}
// 4. 调用close方法关闭流释放资源
fis.close();
}
// 没有循环优化的
public static void test01() throws Exception {
// 1. 创建流关联目标文件： abcde
FileInputStream fis = new FileInputStream("a.txt");
// 2. 创建字节数组：用来存储读取到的数据
byte[] buf = new byte[2];
// 3. 调用read方法读取数据：传递字节数组
int len = fis.read(buf);
System.out.println("len = " + len); // 2
System.out.println("buf = " + new String(buf)); // ab
len = fis.read(buf);
System.out.println("len = " + len); // 2
System.out.println("buf = " + new String(buf)); // cd
len = fis.read(buf);
System.out.println("len = " + len); // 1
System.out.println("buf = " + new String(buf)); // ed
len = fis.read(buf);
System.out.println("len = " + len); // -1
System.out.println("buf = " + new String(buf)); // ed
// 4. 调用close方法关闭流释放资源
fis.close();
}
}
七、字节流练习：图片复制
复制原理图解
代码实现
public class Demo12 {
public static void main(String[] args) throws Exception{
// 创建文件对象：源文件
File srcFile = new File("/Users/pkxing/documents/aaa.mp4");
// 创建文件对象：目标文件
File destFile = new File("/Users/pkxing/documents/bbb.mp4");
copyFile(srcFile,destFile);
}
/**
* 定义文件复制方法
* @param srcFile 源文件
* @param destFile 目标文件
*/
public static void copyFile(File srcFile, File destFile) throws Exception{
// 创建字节输入流关联源文件
FileInputStream fis = new FileInputStream(srcFile);
// 创建字节输出流关联目标文件
FileOutputStream fos = new FileOutputStream(destFile);
// 创建字节数组：用来存储读取到文件数据
byte[] buf = new byte[1024];
// 定义整形变量：接收实际读取到的字节个数
int len = -1;
// 循环读取源文件数据
while ((len = fis.read(buf)) != -1){
// 利用字节输出流数据到目标文件中
fos.write(buf,0,len);
}
// 关闭流释放资源
fis.close();
fos.close();
}
}
八、字符流
当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中⽂文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。
1、字符输入流超类【Reader类】
java.io.Reader 抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
字符输入流：以字符为单位读取数据
是一个抽象类，只能创建子类对象
是所有字符输入流的父类
常用方法
void close()
关闭流释放资源
int read()
从流关联的目标文件中读取一个字符 你 ==> 20320
如果读取到文件末尾返回-1
int read(char[] cbuf)
从流关联的目标文件中读取数据到字符数组中
返回实际读取到的字符个数
如果读取到文件末尾返回-1
int read(char[] cbuf, int off, int len)
从流关联的目标文件中读取数据到字符数组中
返回实际读取到的字符个数
如果读取到文件末尾返回-1
Reader类常用子类
FileReader(今天重点)
BufferedReader
InputStreamReader
2、文件字符输入流（FileReader类）
java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
1、字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。idea中是UTF-8
2、字节缓冲区：一个字节数组，用来临时存储字节数据。
构造方法
FileReader(String path)
FileReader(File file)
根据文件路径字符串或文件对象创建字符输入流
代码示例
public class FileReaderConstructor throws IOException{
public static void main(String[] args) {
// 使用File对象创建流对象
File file = new File("a.txt");
FileReader fr = new FileReader(file);
// 使用文件名称创建流对象
FileReader fr = new FileReader("b.txt");
}
}
3、字符输入流代码示例
读取单个字符数据
读取字符： read 方法
每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回 -1 ，循环读取。
public class FRRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存数据
int b ；
// 循环读取
while ((b = fr.read())!=-1) {
System.out.println((char)b);
}
// 关闭资源
fr.close();
}
}
虽然读取了一个字符（Char），但是会自动提升为int类型。
使用字符数组读取示例1
字符数组读取： read(char[] cbuf)
每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1
public class FileReaderDemo {
public static void main(String[] args) throws Exception{
// 使用文件名称创建流对象
FileReader fr = new FileReader("aaa.txt");
// 定义字符数组，作为装字符数据的容器
char[] chs = new char[2];
// 循环读取
while (fr.read(chs) != -1){
System.out.println(new String(chs));
}
fr.close();
}
}
使用字符数组读取示例1 （有效读取字符转换改进）
public class FISRead {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量，保存有效字符个数
int len ；
// 定义字符数组，作为装字符数据的容器器
char[] cbuf = new char[2];
// 循环读取
while ((len = fr.read(cbuf))!=-1) {
System.out.println(new String(cbuf,0,len));
}
// 关闭资源
fr.close();
}
}
使用字符数组读取示例2
public class Demo113 {
public static void main(String[] args) throws Exception {
// 1. 创建流关联目标文件： abcde
FileInputStream fis = new FileInputStream("a.txt");
// 2. 创建字节数组：用来存储读取到的数据
byte[] buf = new byte[1024];
// 定义变量变量：接收实际读取到的字节个数
int len = -1;
// 循环读取数据
while((len = fis.read(buf)) != -1){ // 5
// 读取多少给字节就转换多少字节为字符串 ab cd e
System.out.print(new String(buf,0,len));
}
// 4. 调用close方法关闭流释放资源
fis.close();
}
// 没有循环优化的
public static void test01() throws Exception {
// 1. 创建流关联目标文件： abcde
FileInputStream fis = new FileInputStream("a.txt");
// 2. 创建字节数组：用来存储读取到的数据
byte[] buf = new byte[2];
// 3. 调用read方法读取数据：传递字节数组
int len = fis.read(buf);
System.out.println("len = " + len); // 2
System.out.println("buf = " + new String(buf)); // ab
len = fis.read(buf);
System.out.println("len = " + len); // 2
System.out.println("buf = " + new String(buf)); // cd
len = fis.read(buf);
System.out.println("len = " + len); // 1
System.out.println("buf = " + new String(buf)); // ed
len = fis.read(buf);
System.out.println("len = " + len); // -1
System.out.println("buf = " + new String(buf)); // ed
// 4. 调用close方法关闭流释放资源
fis.close();
}
}
4、字符输出流【Writer类】
java.io.Writer 抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
字符输出流：以字符为单位输出数据
是一个抽象类，只能创建子类对象
是所有字符输出流的父类
常用方法
void close()
关闭流
void write(char[] cbuf)
输出字符数组的全部内容
void write(char[] cbuf, int off, int len)
输出字符数组的一部分，从索引off开始，长度为len的部分
void write(int c)
输出一个字符
void write(String str)
输出一个字符串
void write(String str, int off, int len)
输出一个字符串的一部分，从索引off开始，长度为len的部分
Writer类常用子类
FileWriter(今天重点)
BufferedWriter
OutputStreamWriter
PrintWriter
5、字符文件输出流（FileWriter类）
java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
字符输出流：以字符为单位输出数据
是一个抽象类，只能创建子类对象
是所有字符输出流的父类
构造方法
FileWriter(String path)
FileWriter(String path,boolean append)
FileWriter(File file)
FileWriter(File file,boolean append)
代码示例
public class FileWriterConstructor {
public static void main(String[] args) throws IOException {
// 使用File对象创建流对象
File file = new File("a.txt");
FileWriter fw = new FileWriter(file);
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("b.txt");
}
}
6、字符输出流代码示例
写出单个字符
方法：write(int b)
每次写出一个字符数据
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使⽤用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 写出数据
fw.write(97); // 写出第1个字符
fw.write('b'); // 写出第2个字符
fw.write('C'); // 写出第3个字符
fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
/*
【注意】关闭资源时,与FileOutputStream不同。
如果不关闭，数据只是保存到缓冲区，并未保存到文件。
*/
//fw.close();
}
}
输出结果：
abC⽥田
- 虽然参数为int类型四个字节，但是只会保留一个字符的信息写出。
- 未调用close⽅方法，数据只是保存到了了缓冲区，并未写出到文件中。
关闭和刷新
因为内置缓冲区的原因，如果不关闭输出流，就无法写出字符到文件中。但是关闭流对象后又无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要 flush 方法了。
flush ：刷新缓冲区，流对象可以继续使用。
close ：关闭流，释放系统资源。关闭前会刷新缓冲区。
flush方法和close方法的区别
flush：刷新缓存区，将缓存区中的数据输出到目标文件中，流还可以继续使用
close：关闭流释放资源，流不可再使用了，close方法内部会触发flush方法的调用
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 写出数据，通过flush
fw.write('刷'); // 写出第1个字符
fw.flush();
fw.write('新'); // 继续写出第2个字符，写出成功
fw.flush();
// 写出数据，通过close
fw.write('关'); // 写出第1个字符
fw.close();
fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
fw.close();
}
}
即便是flush方法写出了了数据，操作的最后还是要调用close方法，释放系统资源。
写出字符数组
写出字符数组 ： write(char[] cbuf) 和 write(char[] cbuf, int off, int len)
每次可以写出字符数组中的数据，用法类似FileOutputStream
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 字符串转换为字节数组
char[] chars = "黑马程序员".toCharArray();
// 写出字符数组
fw.write(chars); // 黑马程序员
// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
fw.write(chars,2,2); // 程序
// 关闭资源
fos.close();
}
}
写出字符串
方法：write(String str) 和 write(String str, int off, int len)
每次可以写出字符串中的数据，更为方便
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileWriter fw = new FileWriter("fw.txt");
// 字符串
String msg = "黑马程序员";
// 写出字符数组
fw.write(msg); //黑马程序员
// 写出从索引2开始，2个字节。索引2是'程'，两个字节，也就是'程序'。
fw.write(msg,2,2); // 程序
// 关闭资源
fos.close();
}
}
输出流的续写和换行
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象，可以续写数据
FileWriter fw = new FileWriter("fw.txt"，true);
// 写出字符串
fw.write("⿊马");
// 写出换行
fw.write("\r\n");
// 写出字符串
fw.write("程序员");
// 关闭资源
fw.close();
}
}
输出结果:
⿊马
程序员
字符流，只能操作文本文件，不能操作图片，视频等非文本文件。
当我们单纯读或者写文本文件时使用字符流，其他情况使用字节流
文本中的数据，必须是键值对形式，可以使用空格、等号、冒号等符号分隔。
九、概念对比
1、字符流和字节流用法
字符流只能操作文本文件，不能操作图片，视频等非文本文件。
其他情况使用字节流
2、字节、字符、数字概念
字节
字节（Byte）是存储数据的基本单位。常见的存储单位主要有bit（位）、B（字节）、KB（千字节）、MB（兆字节）、GB（千兆字节）。
1B=8bit、1KB=1024B、1MB=1024KB、1GB=1024MB。
其中 B 是 Byte 的缩写
二进制数只有0和1，1个二进制数（0或1）就是1bit。
即1个字节=8个二进制数
什么是字节（Byte）https://blog.csdn.net/wydyd110/article/details/84589541
1个数字=多少字节
十进制的数字需要换成二进制。
十进制0~9，最大的9换成二进制为1001。
也就是说一个数字最大为4个比特（bit），即0-9范围中两个数字为一个字节。
如果是任意数就不一定是多少个字节，比如256换成二进制就是1000000。1个“256”=7/8字节
字符
字符是什么？
字符包括：字母、数字、汉字和其他符号
字符char
字符型char是存一个字符变量的类型，字符变量用’ ‘概括表示，中间填入任意一个字符(也叫符号)，例如’a’ ‘b’ ‘c’ 之类。
“1”、“我”、“！”、“w”、“￥"是字符，单个的元素组成
“111”、“ni”、“我的”、“！！！”都不是字符，都是字符串
字符和字节
字节转字符会根据编码表，数字对应字符。这个数字再转换成二进制变成字节
不同的字符所占的字节是不同的。不同的编码方式规定了字符所占的字节。
Java采用unicode编码来表示字符
1个字符型char是2个字节
1个汉字（含繁体）或字母都占2个字节
1个英文标点符号占1个字节
1个中文标点符号占2个字节。
采用其他编码方式，一个字符占用的字节数则各不相同。
GB2312 编码或 GBK 编码
1个英文字母占1个字节
1个汉字占2个字节。
UTF-8编码
1个字母占1个字节
1个汉字占3-4个字节。
UTF-16编码
1个字母占2个字节
1个汉字占3-4个字节（Unicode扩展区的一些汉字存储需要4个字节）。
UTF-32编码中
世界上任何字符的存储都需要4个字节。
3、字节数组和字符数组
理解：
字节数组 byte[] ：存转换后对应字节的二进制数字
字符数组 char[] ：存字符(字母、数字、汉字和其他符号)
4、字符串跟字符数组的区别
字符串就是字符数组，字符串可以转换成字符数组
而字符的本质就是整数（编码表通过数字查询对应的字符），而整数可以是一个或多个字节的组成的。
计算机基础ascii码，字符就是靠用整数来编码的，字符存储时就是整数，只不过显示给你看的时候是你以为的有意义的字符而已。
如字符‘A’和整数65是可以判断相等的，因为’A’的本质就是65.
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
