IO流
java.in.File类的使用
java.in.File指的是计算机操作系统中的文件和文件夹
IO原理及流的分类
IO：指的就是input和output
流的概念：通过程序把一个图片放到某个文件夹，把图片转化为一个数据集（例如二进制），把这些数据一点一点传到文件夹，这个传递的过程就很类似水的流动，我们就可以称这个整体的数据集是一个数据流。
文件流
数据流的读写基于文件操作
FileInputStream / FileOutputStream / FileReader / FileWriter
缓冲流
数据流的读写都是基于内存操作
BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter
转换流
InputStreamReader / OutputStreamReader
标准输入/输出流
打印流
PrintStream / PintWriter
其实就是System.out.println
数据流
DataInputStream / DataOutputStream
对象流
把一个对象转化为一个数据流进行读写
ObjectInputStream / ObjectOutputStream
随机存取文件流
RandomAccessFile
例如：一个TXT文件，其中有100行数据，可以直接读取第50行的数据，也可以在第89行插入数据，这个才是随机的概念
File类
File类只能操作文件本身，不能操作文件内容
public class Test1 {
public static void main(String[] args) {
File file = new File("D:\\demo\\test.txt"); //file就是test.txt文件
// File file1 = new File("D:" + File.separator + "\\test.txt");
// File file2 = new File("D:\\demo", "test.txt");
//注意：\在文件中是路径的分隔符，在java编程中一个\代表转义字符，\\或者/才是文件的分隔符
//也可以用File.separator作为文件分隔符
System.out.println(file.getName()); //获取文件名
File file3 = new File("D:\\demo");
System.out.println(file3.getName()); //获取当前文件夹名
System.out.println(file.getPath()); //获取文件或文件夹的路径
File file4 = new File("src\\com\\company\\day13\\Test1.java"); //使用相对路径
System.out.println(file4.getPath());
System.out.println(file4.getAbsolutePath()); //获取当前文件的绝对路径
System.out.println(file4.getParent()); //返回当前文件/文件夹的父级路径
file.renameTo(new File("D:\\demo\\test11.txt")); //给文件或者文件夹重命名
System.out.println(file.exists()); //判断文件或者文件夹是否存在
System.out.println(file4.canWrite()); //判断文件是否可写
System.out.println(file4.canRead()); //判断文件是否可读
System.out.println(file4.isFile()); //判断当前file对象是否是文件
System.out.println(file4.isDirectory()); //判断当前file对象是否是目录
System.out.println(file4.length()); //返回文件的长度，单位是字节数
System.out.println(file4.lastModified()); //获取文件最后修改时间，返回的是一个毫秒数
File file5 = new File("D:\\demo\\test22.txt");
System.out.println(file5.exists());
if (!file5.exists()) {
try {
file5.createNewFile(); //创建新文件
} catch (IOException e) {
e.printStackTrace();
}
}
file5.delete(); //删除文件
File file6 = new File("D:\\demo\\aa");
file6.mkdir(); //创建单层目录
File file7 = new File("D:\\demo\\aa\\bb\\cc\\dd");
file7.mkdirs(); //创建多层目录
File file8 = new File("D:\\demo");
String[] list = file8.list(); //返回当前文件夹的子集的名称。包括目录和文件
if (list != null) {
for (String s : list) {
System.out.println(s);
}
}
File[] files = file8.listFiles(); //返回当前文件夹的子集的file对象，包括目录和文件
if (files != null) {
for (File f : files) {
System.out.println(f);
}
}
}
}File类递归遍历文件
public class Test1 {
public static void main(String[] args) {
File f = new File("D:\\demo");
new Test1().IterateOverFiles(f);
}
/**
* 递归遍历文件
* @param file
*/
public void IterateOverFiles(File file) {
if (file.isFile()) {
System.out.println(file.getAbsolutePath() + "是文件");
} else {
System.out.println(file.getAbsolutePath() + "是文件夹");
//如果是文件夹，这个文件夹就可能有子文件夹或文件
File[] files = file.listFiles();
if (files != null && files.length > 0) {
for (File f : files) {
IterateOverFiles(f); //递归调用
}
}
}
}
}文件字节流
public class Test2 {
public static void main(String[] args) {
Test2.FileInputStream("D:\\demo\\test11.txt");
Test2.FileOutputStream("这个是Hello World！", "D:\\demo\\test22.txt");
Test2.CopyFile("D:\\demo\\test11.txt", "D:\\demo\\aa\\bb\\cc\\dd\\test11.txt");
}
/**
* 文件字节输入流FileInputStream
* @param inpath
*/
public static void FileInputStream(String inpath) {
try {
FileInputStream inputStream = new FileInputStream(inpath);
byte[] bytes = new byte[1024]; //设置一个byte数组接收读取的文件内容
int len = 0; //设置一个读取数据的长度
while ((len = inputStream.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, len));
//new String(bytes, 0, len),参数1是缓冲数据的数组，参数2是从数组的哪个位置开始转换字符串，参数3是总共转化几个字节
}
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 文件字节输出流FileOutputStream
* @param text
* @param outpath
*/
public static void FileOutputStream(String text, String outpath) {
try {
FileOutputStream outputStream = new FileOutputStream(outpath); //指定向test22输出数据
byte[] bytes = text.getBytes();
outputStream.write(bytes); //把数据写到内存
outputStream.flush(); //把内存中的数据刷写到硬盘
outputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 复制文件到指定位置
* @param inpath 源文件路径
* @param outpath 复制到的文件夹路径
*/
public static void CopyFile(String inpath, String outpath) {
try {
FileInputStream inputStream = new FileInputStream(inpath); //读取的源文件
FileOutputStream outputStream = new FileOutputStream(outpath); //复制到哪里
byte[] bytes= new byte[1024];
int len = 0;
while ((len = inputStream.read(bytes)) != -1) {
outputStream.write(bytes, 0, len);
}
outputStream.flush(); //把写到内存的数据刷到硬盘
outputStream.close();
inputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}文件字符流
public class Test3 {
public static void main(String[] args) {
Test3.FileReader("D:\\demo\\test11.txt");
Test3.FileWriter("hello world", "D:\\demo\\test33.txt");
Test3.CopyFiles("D:\\demo\\test11.txt", "D:\\demo\\aa\\bb\\test11.txt");
}
/**
* 文件字符输入流FileReader
* 在读取文件时，必须保证该文件已存在，否则出异常
* @param inpath
*/
public static void FileReader(String inpath) {
try {
FileReader fileReader = new FileReader(inpath);
char[] chars = new char[1024];
int len = 0;
while ((len = fileReader.read(chars)) != -1) {
System.out.println(new String(chars, 0, len));
}
fileReader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 文件字符输出流FileWriter
* 在写入一个文件时，如果目录下有同名文件，将被覆盖
* @param text
* @param outpath
*/
public static void FileWriter(String text, String outpath) {
try {
FileWriter fileWriter = new FileWriter(outpath);
fileWriter.write(text); //写到内存中
fileWriter.flush(); //把内存的数据刷到硬盘
fileWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 字符流完成拷贝文件，字符流只适合操作内容是字符的文件
* @param inpath
* @param outpath
*/
public static void CopyFiles(String inpath, String outpath) {
try {
FileReader fileReader = new FileReader(inpath);
FileWriter fileWriter = new FileWriter(outpath);
char[] chars = new char[1024];
int len = 0;
while ((len = fileReader.read(chars)) != -1) {
fileWriter.write(chars, 0, len);
}
fileWriter.flush();
fileWriter.close();
fileReader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
