java学习记录二十：File类，IO流，字节流，字符流
一、file类
一、解释
java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
- 一个File对象代表硬盘中的一个文件或者目录，还没生成文件此时。
- 无论该路径下是否存在文件或者目录，都不影响File对象的创建。
二、构造方法
public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。
File f1 = new File("H:\\aaa\\hb.jpg");
File f2 = new File("H:\\aaa","hb.jpg");
File parent = new File("H:\\aaa");
File f3 = new File(parent, "hb.jpg");
System.out.println(f1);
System.out.println(f2);
System.out.println(f3);
三、相对路径和绝对路径
- 绝对路径：从盘符开始的路径，这是一个完整的路径。
- 相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。
四、获取路径方法
public String getAbsolutePath() ：返回此File的绝对路径名字符串。public String getPath() ：将此File转换为路径名字符串。public String getName() ：返回由此File表示的文件或目录的名称。public long length() ：返回由此File表示的文件的字节大小。 不能获取目录的字节大小。
File f1 = new File("day12\\aaa\\hb.jpg");
System.out.println("f1的绝对路径:"+f1.getAbsolutePath());
System.out.println("f1的构造路径:"+f1.getPath());
System.out.println("f1的文件名:"+f1.getName());
System.out.println("f1的字节大小:"+f1.length());
File f2 = new File("day12\\aaa\\bbb");
System.out.println("f2的绝对路径:"+f2.getAbsolutePath());
System.out.println("f2的构造路径:"+f2.getPath());
System.out.println("f2的文件名:"+f2.getName());
System.out.println("f2的字节大小:"+f2.length());
五、判断文件的方法
public boolean exists() ：此File表示的文件或目录是否实际存在。public boolean isDirectory() ：此File表示的是否为目录。public boolean isFile() ：此File表示的是否为文件。
File f1 = new File("day12\\aaa\\hb.jpg");
System.out.println("f1表示的文件是否真实存在:"+f1.exists());
System.out.println("f1表示的文件是否是文件夹:"+f1.isDirectory());
System.out.println("f1表示的文件是否是文件:"+f1.isFile());
System.out.println("=====================================================");
File f2 = new File("day12\\aaa\\bbb");
System.out.println("f2表示的文件夹是否真实存在:"+f2.exists());
System.out.println("f2表示的文件夹是否是文件夹:"+f2.isDirectory());
System.out.println("f2表示的文件夹是否是文件:"+f2.isFile());
System.out.println("=====================================================");
File f3 = new File("day12\\aaa\\b.txt");
System.out.println("f3表示的文件是否真实存在:"+f3.exists());
System.out.println("f3表示的文件是否是文件夹:"+f3.isDirectory());
System.out.println("f3表示的文件是否是文件:"+f3.isFile());
File f4 = new File("day12\\aaa\\ccc");
System.out.println("f4表示的文件夹是否真实存在:"+f4.exists());
System.out.println("f4表示的文件夹是否是文件夹:"+f4.isDirectory());
System.out.println("f4表示的文件夹是否是文件:"+f4.isFile());
六、创建和删除文件方法
public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。public boolean delete() ：删除由此File表示的文件或目录，如果此File表示目录，则目录必须为空才能删除。public boolean mkdir() ：创建由此File表示的目录。public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。
File f1 = new File("day12\\aaa\\a.txt");
System.out.println("是否创建成功:"+f1.createNewFile());
File f2 = new File("day12\\aaa\\ddd");
System.out.println("是否创建成功:"+f2.createNewFile());
System.out.println("=======================================");
File f3 = new File("day12\\aaa\\eee");
System.out.println("是否创建成功:"+f3.mkdir());
File f4 = new File("day12\\aaa\\fff.txt");
System.out.println("是否创建成功:"+f4.mkdir());
File f5 = new File("day12\\aaa\\aaa\\bbb\\ccc\\ddd");
System.out.println("是否创建成功:"+f5.mkdir());
System.out.println("=======================================");
System.out.println("是否创建成功:"+f5.mkdirs());
System.out.println("=======================================");
File f6 = new File("day12\\aaa\\a.txt");
System.out.println("是否删除成功:"+f6.delete());
File f7 = new File("day12\\aaa\\eee");
System.out.println("是否删除成功:"+f7.delete());
File f8 = new File("day12\\aaa\\bbb");
System.out.println("是否删除成功:"+f8.delete());
七、File类遍历目录方法
File f = new File("day12\\aaa");
String[] arr1 = f.list();
for (String s : arr1) {
System.out.println(s);
}
System.out.println("==============================");
File[] arr2 = f.listFiles();
for (File file : arr2) {
System.out.println(file);
}
System.out.println("==============================");
File f1 = new File("H:\\System Volume Information");
String[] list = f1.list();
File[] files = f1.listFiles();
System.out.println(list+","+files);
if (list != null) {
for (String s : list) {
}
}
二、递归
一、解释
指在当前方法内调用自己的这种现象
递归的注意事项:
- 递归要有出口(结束方法),否则会报栈内存溢出错误StackOverflowError
- 递归的出口不能太晚了，还是会报栈内存溢出错误StackOverflowError
二、例子
1.计算1-n之和
int sum = getSum(5);
System.out.println("5的累加和:"+sum);
}
public static int getSum(int n){
if(n == 1){
return 1;
}
return n + getSum(n-1);
}
2.计算n的阶乘
int res = jieCheng(5);
System.out.println("5的阶乘:"+res);
}
public static int jieCheng(int num){
if (num == 1){
return 1;
}
return num * jieCheng(num-1);
}
3.递归输出day15\src目录中的所有.java文件的绝对路径。
File file = new File("day15\\src");
findFile(file);
}
public static void findFile(File file) {
File[] files = file.listFiles();
if (files != null) {
for (File file1 : files) {
if (file1.isFile() && file1.getName().endsWith(".java")){
System.out.println(file1.getAbsolutePath());
}
if (file1.isDirectory()){
findFile(file1);
}
}
}
三、IO流
一、解释
- I : Input 输入 从其他存储设备读数据到内存中就是输入
- O : Output 输出 从内存中写数据到其他存储设备
二、IO的分类
根据数据的流向分为：输入流和输出流。
- 输入流 ：把数据从
其他设备上读取到内存中的流。
- 字节输入流:以字节为基本单位,读数据
- 字符输入流:以字符为基本单位,读数据
- 输出流 ：把数据从
内存 中写出到其他设备上的流。
- 字节输出流:以字节为基本单位,写出数据
- 字符输出流:以字符为基本单位,写出数据
根据数据的类型分为：字节流和字符流。
- 字节流 ：以字节为单位，读写数据的流。
- 字节输入流:以字节为基本单位,读数据
- 字节输出流:以字节为基本单位,写出数据
- 字符流 ：以字符为单位，读写数据的流。
- 字符输入流:以字符为基本单位,读数据
- 字符输出流:以字符为基本单位,写出数据
IO的顶层父类
- 字节输入流:顶层父类 InputStream 抽象类
- 字节输出流:顶层父类 OutputStream 抽象类
- 字符输入流:顶层父类 Reader 抽象类
- 字符输出流:顶层父类 Writer 抽象类
注意事项
- utf8编码一个中文占3个字节,gbk编码一个中文占2个字节
- 如果存储和解析的编码不一致就会乱码
- idea默认编码是utf8
四、字节流
一、解释
- 字节输入流:顶层父类 InputStream 抽象类
- 字节输出流:顶层父类 OutputStream 抽象类
二、字节输出流
java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
三、字节输出流OutputStream类常用方法
public void close() ：关闭此输出流并释放与此流相关联的任何系统资源,close方法，当完成流的操作时，必须调用此方法，释放系统资源。。public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。public abstract void write(int b) ：将指定的字节输出流。
四、FileOutputStream类
java.io.FileOutputStream类是OutputStream类的子类,用来表示是文件输出流，用于将数据写出到文件。
FileOutputStream类的构造方法
public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。- 当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
FileOutputStream fos1 = new FileOutputStream("day12\\bbb\\a.txt");
FileOutputStream fos2 = new FileOutputStream("day12\\bbb\\b.txt");
FileOutputStream fos3 = new FileOutputStream(new File("day12\\bbb\\c.txt"));
FileOutputStream类的写出数据
1.写出字节：write(int b) 方法，每次可以写出一个字节数据，
FileOutputStream fos = new FileOutputStream("day12\\bbb\\a.txt");
fos.write(97);
fos.write(98);
fos.write(99);
fos.close();
2.写出字节数组：write(byte[] b)，每次可以写出数组中的数据，
FileOutputStream fos = new FileOutputStream("day12\\bbb\\b.txt");
byte[] bys = {97,98,99,100};
fos.write(bys);
fos.close();
3.写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节
FileOutputStream fos = new FileOutputStream("day12\\bbb\\c.txt");
byte[] bys = {97,98,99,100};
fos.write(bys, 1,2 );
fos.close();
4.数据追加续写
创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？
public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。
这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了
1.当你创建一个字节输出流对象时，必须传入一个文件路径。
2.该路径下，如果没有这个文件，会创建该文件(空的)。
3.如果有这个文件，并且第二个参数为true,就不清空,如果第二个参数为false,就清空
FileOutputStream fos = new FileOutputStream("day12\\bbb\\a.txt",true);
fos.write(97);
fos.close();
5.写出换行
Windows系统里，换行符号是\r\n
FileOutputStream fos = new FileOutputStream("day15\\aaa\\d.txt");
fos.write("吟诗一首".getBytes());
fos.write("\r\n".getBytes());
fos.write("看这风景美如画".getBytes());
fos.write("\r\n".getBytes());
fos.write("吟诗一首赠天下".getBytes());
fos.write("\r\n".getBytes());
fos.write("奈何本人没文化".getBytes());
fos.write("\r\n".getBytes());
fos.write("只能卧槽浪好大".getBytes());
fos.close();
- 回车符
\r和换行符\n ：
- 回车符：回到一行的开头（return）。
- 换行符：下一行（newline）。
- 系统中的换行：
- Windows系统里，每行结尾是
回车+换行 ，即\r\n； - Unix系统里，每行结尾只有
换行 ，即\n； - Mac系统里，每行结尾是
回车 ，即\r。从 Mac OS X开始与Linux统一。
五、字节输入流
java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
六、 字节输入流InputStream 类的常用方法
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。public abstract int read()： 从输入流读取数据的下一个字节。public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
七、 FileInputStream类
java.io.FileInputStream类是InputStream类的子类 , 用来表示文件输入流，从文件中读取字节。
FileInputStream类的构造方法
FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的文件对象 file命名。FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
当你创建一个输入流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException
FileInputStream fis1 = new FileInputStream("day12\\ccc\\a.txt");
FileInputStream fis2 = new FileInputStream(new File("day12\\ccc\\a.txt"));
FileInputStream fis3 = new FileInputStream("day12\\ccc\\b.txt");
FileInputStream类的读取数据
1.读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，
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);
read = fis.read();
System.out.println( read);
fis.close();
2.使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，
FileInputStream fis = new FileInputStream("day12\\ccc\\b.txt");
byte[] bys = new byte[2];
int len1 = fis.read(bys);
System.out.println("bys数组转换为字符串:"+new String(bys,0,len1));
System.out.println(len1);
int len2 = fis.read(bys);
System.out.println("bys数组转换为字符串:"+new String(bys,0,len2));
System.out.println(len2);
int len3 = fis.read(bys);
System.out.println("bys数组转换为字符串:"+new String(bys,0,len3));
System.out.println(len3);
int len4 = fis.read(bys);
System.out.println(len4);
fis.close();
五、字符流
一、解释
二、字符输入流
java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
三、字符输入流Reader类常用方法
public void close() ：关闭此流并释放与此流相关联的任何系统资源。public int read()： 从输入流读取一个字符。public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。
四、FileReader类
FileReader类的概述
java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
FileReader类的构造方法
FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。
当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。
FileReader fr1 = new FileReader("day12\\ddd\\a.txt");
FileReader fr2 = new FileReader(new File("day12\\ddd\\a.txt"));
FileReader fr3 = new FileReader("day12\\ddd\\b.txt");
FileReader类读取数据
1.读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：
FileReader fr = new FileReader("read.txt");
int b ；
while ((b = fr.read())!=-1) {
System.out.println((char)b);
}
fr.close();
2.使用字符数组读取：read(char[] cbuf)，每次读取多个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1 ，代码使用演示：
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));
}
fr.close();
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();
五、字符输出流Writer类
java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
六、字符输出流Writer类的常用方法
public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int c) ：写出一个字符。public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。public void write(String str) ：写出一个字符串。public void write(String str,int off,int len) ：写出一个字符串的一部分。
七、FileWriter类
FileWriter类的概述
java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
FileWriter类的构造方法
FileWriter(File file)： 创建一个新的 FileWriter，给定要读取的File对象。FileWriter(String fileName)： 创建一个新的 FileWriter，给定要读取的文件的名称。FileWriter(File file,boolean append)： 创建一个新的 FileWriter，给定要读取的File对象。FileWriter(String fileName,boolean append)： 创建一个新的 FileWriter，给定要读取的文件的名称。
注意:
1.当你创建一个字符输出流对象时，必须传入一个文件路径。
2.前面2个构造方法,传入的路径，如果没有这个文件，会创建该文件(空的),如果有这个文件,就会清空。
3.后面2个构造方法,传入的路径, 如果没有这个文件，会创建该文件(空的),如果有这个文件，并且第二个参数为true,就不清空,如果第二个参数为false,就清空
FileWriter fw1 = new FileWriter("day12\\ddd\\b.txt",true);
FileWriter fw2 = new FileWriter("day12\\ddd\\c.txt");
FileWriter类写出数据
1.写出字符：write(int b) 方法，每次可以写出一个字符数据，代码使用演示：
FileWriter fw = new FileWriter("day12\\ddd\\d.txt");
fw.write('a');
fw.write('b');
fw.close();
2.写出字符数组 ：write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ，每次可以写出字符数组中的数据，用法类似FileOutputStream，代码使用演示：
FileWriter fw = new FileWriter("fw.txt");
char[] chars = "黑马程序员".toCharArray();
fw.write(chars);
fw.write(b,2,2);
fos.close();
3.写出字符串：write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据，更为方便，代码使用演示：
FileWriter fw = new FileWriter("fw.txt");
String msg = "程序员";
fw.write(msg);
fw.write(msg,2,2);
fos.close();
4.续写和换行：操作类似于FileOutputStream。
FileWriter fw = new FileWriter("fw.txt"，true);
fw.write("黑马");
fw.write("\r\n");
fw.write("程序员");
fw.close();
字符流，只能操作文本文件，不能操作图片，视频等非文本文件。当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流
八、关闭和刷新
因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。
flush ：刷新缓冲区，流对象可以继续使用。close ：关闭流，释放系统资源。关闭前会刷新缓冲区。
FileWriter fw = new FileWriter("fw.txt");
fw.write('刷');
fw.flush();
fw.write('新');
fw.flush();
fw.write('关');
fw.close();
fw.write('闭');
fw.close();
六、gdk编码和utf-编码
gfk编码是一个中文占两个字节
utf-8编码是一个中文占桑字节
存和取不是同一种编码会出现乱码
idea是utf-8编码
七、字节流操作中文可能存在问题
会出现乱码，在操作中文的时候最好使用字符流
|