一、概述
IO流是用来传输数据的，如文件的读写，有字节流和字符流之分，字节流可以处理任何文件数据，字符流只能处理纯文本文件，这里说的是字符流。
1、字符流分类：
字符输入流：FileReader、BufferedReader
字符输出流：FileWriter、BufferedWriter
2、FileWriter使用：
创建：FileWriter fw = new FileWriter("xxx.txt");
写入：fw.write("Hoello");
关闭：fw.close();
3、追加写入：
FileWriter fw = new FileWriter("xxx.txt"，true); //第二个参数为 true
4、实现换行
在Windows中： \r\n
在macOS中：\r或\n
在Linux中：\n
5、五种writer方法的重载
写字符串的整体：public void writer(String str);
写字符串的部分：public void writer(String str,int offset,int count);
写字符数组的整体：public void writer(Char[] array);
写字符数组的部分：public void writer(Char[] array,int offset,int count);
写单个字符对应的数字（参考ASCII码或Unicode表）：public void writer(int ch);
6、FileReader的使用
创建：FileReader fr = new FileReader("xxx.txt");
读单个字符：
int ch; //单个字符的ASCII值
while((ch = fr.read()) != -1)
{
//......
}
读字符数组：
char[] buf = new char[1024];
int len; //有效个数
while((len = fr.read(buf)) != -1)
{
String str = new String(buf,0,len);
}
7、BufferedXxx和FileXxx的区别：
BufferedXxx有一个8192长度的char[]字符数组作为缓冲区
BufferedXxx性能更高
8、BufferedWriter额外方法：
public void newLine()，根据操作系统自动换行
9、BufferedReader额外方法：
public void newLine()，读取一行字符串，不包含换行符
10、代码实例：
FileWriter & FileReader
package File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
FileWriter fw1 = new FileWriter("test1.txt"); //创建FileWrite对象(覆盖写入)
//重载一：写字符串的整体
fw1.write("Hello,my love!"); //调用writer方法写数据
fw1.write("\r\n"); //Windows系统中的换行方式
fw1.write("LongRu\r\n");
//重载二：写字符串的部分
String str = "Hello,my love,Longru!";
fw1.write(str,14,7);
fw1.write("\r\n");
//重载三：写字符数组的整体
char[] array1 = {'H','e','l','l','o'};
fw1.write(array1);
fw1.write("\r\n");
//重载四：写字符数组的部分
char[] array2 = {'M','y',' ','l','o','v','e'};
fw1.write(array2,3,4);
fw1.write("\r\n");
//重载五：写单个字符
fw1.write(65);
fw1.write(48);
fw1.write("\r\n");
fw1.close(); //调用close方法关闭流
FileWriter fw2 = new FileWriter("test2.txt",true); //创建FileWrite对象(追加写入)
fw2.write("Hello,my love!"); //调用writer方法写数据
fw2.write("LongRu");
fw2.close(); //调用close方法关闭流
System.out.println("==================================================");
//重载一：读取单个字符
FileReader fr1 = new FileReader("test1.txt");
int ch;
while ((ch = fr1.read()) != -1)
{
System.out.println((char) ch);
}
//重载二：读取指定长度字符
FileReader fr2 = new FileReader("test2.txt");
char[] buf = new char[2];
int len; //代表有效个数
while ((len = fr2.read(buf)) != -1)
{
String str3 = new String(buf,0,len);
System.out.println(str3);
}
fr2.close();
}
}
BufferedWriter & BufferedReader
package BufferFile;
import java.io.*;
public class Main {
public static void main(String[] ages) throws IOException {
FileWriter fw = new FileWriter("test3.txt"); //创建BufferedWriter
BufferedWriter bw = new BufferedWriter(fw);
bw.write("hello"); //写入
bw.newLine(); //BufferedWriter特有的自动根据操作系统换行功能
bw.write("My love!");
bw.close(); //关闭
//读单个字符，其实是从8192的缓冲区读取单个字符
FileReader fr = new FileReader("test3.txt"); // 创建BufferedReader
BufferedReader br = new BufferedReader(fr);
int ch;
while ((ch = br.read()) != -1)
{
System.out.println((char)ch);
}
br.close();
//BufferedReader提供了一个读取一行字符串的方法
FileReader fr2 = new FileReader("test1.txt"); // 创建BufferedReader
BufferedReader br2 = new BufferedReader(fr2);
String line; //代表一行字符串
while ((line = br2.readLine()) != null)
{
System.out.println(line);
}
}
}
二、File 类
1、File类的概述和作用
File类是文件和目录路径名的抽象表示形式
Java中把文件或者目录（文件夹）都封装成File对象
在硬盘上操作文件，直接使用 File 类
2、File类静态的成员变量
pathSeparator：与系统有关的路径分隔符，为了方便，它被表示为一个字符串
separator：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串
public static void main(String[] args) {
//File类静态成员变量
//与系统有关的路径分隔符
String separator = File.pathSeparator;
System.out.println(separator);// 是一个分号,目录的分割(window中环境变量配置各个路径用分号分割，表示一个完整的路径结束) Linux中是冒号 :
//与系统有关的默认名称分隔符
separator = File.separator;
System.out.println(separator);// 向右 \ 目录名称分割 Linux /
}
3、File 类的构造方法
File(String pathname)：将路径封装File类型对象
File(String parent，String child)：根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 对象
File(File parent，String child)：将parent封装成file对象
public static void main(String[] args){
//将路径封装File类型对象
String pathName = "F:\\TestPath";
File f1 = new File(pathName);//将Test22文件封装成File对象。注意；有可以封装不存在文件或者文件夹，变成对象。
System.out.println(f1);
//根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 对象
File f2 = new File("F:\\TestPath","a.txt");
System.out.println(f2);
//将parent封装成file对象。
File dir = new File("F:\\TestPath");
File f3 = new File(dir,"a.txt");
System.out.println(f3);
}
4、File 类创建、删除文件（文件、文件夹）
public boolean createNewFile()：创建文件 如果存在这样的文件，就不创建了
public boolean mkdir()：创建文件夹 如果存在这样的文件夹，就不创建了
public boolean mkdirs()：创建文件夹,如果父文件夹不存在，会帮你创建出来
public boolean delete()：删除文件或者文件夹
public static void main(String[] args) throws IOException {
//创建文件
File F1 = new File("F:\\TestPath\\a.txt");
boolean B1 = F1.createNewFile();
System.out.println(B1);
//创建文件夹
File F2 = new File("F:\\TestPath\\a");
boolean B2 = F2.mkdir();
System.out.println(B2);
//删除文件
File F3 = new File("F:\\TestPath\\a.txt");
boolean B3 = F3.delete();
System.out.println(B3);
}
5、File 类获取功能
String getName()：返回路径中表示的文件或者文件夹名（获取路径中的最后部分的名字）
long length()： 返回路径中表示的文件的字节数
String getAbsolutePath()：获取绝对路径，返回String对象
File getAbsoluteFile() ：获取绝对路径，返回File对象
String getParent()：获取父路径，返回String对象
File getParentFile()：获取父路径，返回File对象
public static void main(String[] args) throws IOException {
File F1 = new File("F:\\TestPath\\a.txt");
F1.createNewFile();
String S1 = F1.getName(); //返回路径中表示的文件或者文件夹名，即获取路径中最后部分的名字
long L1 = F1.length(); //返回路径中表示的文件的字节数
File absolute = F1.getAbsoluteFile(); //获取绝对路径，返回File对象
File parent = F1.getParentFile(); //获取父路径，返回File对象
System.out.println(S1);
System.out.println(L1);
System.out.println(absolute);
System.out.println(parent);
}
6、File 类判断功能
boolean exists()：判断File构造方法中封装路径是否存在
boolean isDirectory()：判断File构造方法中封装的路径是不是文件夹
boolean isFile()：判断File构造方法中封装的路径是不是文件
7、File 类 list 获取功能
String[] list()：获取到File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
File[] listFiles()：获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
static File[] listRoots(): 列出可用的文件系统根
public static void main(String[] args)
{
File dir = new File("F:\\TestPath");
//获取的是目录下的当前的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
System.out.println("========================");
//获取目录下当前文件以及文件对象，只要拿到了文件对象，那么就可以获取其中想要的信息
File[] files = dir.listFiles();
for(File file : files){
System.out.println(file);
}
}
注意：
指定的目录必须存在
指定的必须是目录，否则容易返回数组null，出现NullPointerException
8、文件过滤器
使用文件过滤器可以删选出某些关键字的文件或文件夹，即过滤一个目录下的指定扩展名的文件，或者包含某些关键字的文件夹
常用方法：
public String[] list(FilenameFilter filter)：
public File[] listFiles(FileFilter filter)：
自定义过滤器类
//自定义过滤器实现FileFilter接口,重写抽象方法
public class myFilter implements FileFilter {
@Override
public boolean accept(File pathname) {
return pathname.getName().endsWith(".txt");
}
}
在main中调用
public static void main(String[] args)
{
File F = new File("F:\\TestPath");
File[] filearr = F.listFiles(new myFilter());
for(File f : filearr)
{
System.out.println(f);
}
}
分析：
listFiles()遍历目录的同时，获取到了文件名全路径，调用过滤器的方法accept，将获取到的路径传递给accept方法的参数pathname
accept方法接收了参数pathname，参数是listFiles传递来的
在accept方法中，进行判断，如果这个路径是txt文件，返回true，走着返回false
一旦方法返回了true，listFiles将路径保存到File数组中
9、递归全目录，寻找指定文件
自定义过滤器
//自定义过滤器实现FileFilter接口,重写抽象方法
public class myFilter implements FileFilter {
public boolean accept(File pathname) {
if(pathname.isDirectory()) {
return true;
}
return pathname.getName().endsWith(".txt");
}
}
在main中递归调用
public static void main(String[] args)
{
File F = new File("F:\\TestPath");
gitAllDir(F); //递归遍历所有目录
gitAllTxt(F); //递归遍历所有txt文件
}
public static void gitAllDir(File F)
{
//System.out.println(F);
//调用方法listFiles()对目录,dir进行遍历
File[] allFile = F.listFiles();
for(File f : allFile)
{
//System.out.println(f);
//判断变量f表示的路径是不是文件夹
if(f.isDirectory())
{
//是一个目录,就要去调用getAllDir递归遍历这个目录
gitAllDir(f);
}
else
{
System.out.println(f);
}
}
}
private static void gitAllTxt(File F)
{
File[] fileTxt = F.listFiles(new myFilter());
for(File f : fileTxt)
{
//System.out.println(f);
if(f.isDirectory())
{
gitAllTxt(f);
}
else
{
System.out.println(f);
}
}
}
网友评论