Day15_IO流（上）
Day15_IO流（上）
File类
File.separator表示路径里的“/”，在跨平台编程中需要用这个符号表示路径。
File类中，创建一层目录用mkdir()，创建多层目录用mkdirs()。
遍历文件夹
import java.io.File;
public class Demo01 {
public static void main(String[] args) {
//创建一个File类对象,将文件夹的路径复制进去
File f=new File("/Users/Desktop/java");
System.out.println(f);
//遍历文件夹
bianli(f,1);
}
public static void bianli(File f,int level){
File[] files=f.listFiles();
for(File file:files){
for (int i = 0; i < level; i++) {
System.out.print("-");
}
System.out.println(file.getName());
if(file.isDirectory()){
bianli(file,level+1);
}
}
}
}
输出：
/Users/Desktop/java
-.DS_Store
-java面经.pdf
-code
--.DS_Store
--Hello.class
--Hello.java
-Blog
--Day06_java对象上.md
--学习安排.md
--.DS_Store
--Day10_数组（下）.md
--Day02mac下java卸载.md
--Day03_流程控制.md
--Day05_java数组.md
--常用类（下）.md
--Day14_数据结构和集合(下).md
--Day04_java方法.md
--Day08_网络编程（上）.md
--Day07_java对象下.md
--Day13_数据结构.md
--Day09_数组(上）.md
--Day01.md
--Day11_包装类（上）.md
--Day03_java基础知识.md
IO流引入
四个抽象类，abstract class
三种分类方法
| 1.大小\2.方向 | 输入 | 输出 |
|---|---|---|
| 字节 | InputStream | OuputStream |
| 字符 | Reader | Writer |
3.处理方式
处理流：管套着管---流结合流
节点流：直接和源文件或者目标文件接触的流
文件字节流
字符知识：1字符=2字节=16位
读文件
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Demo02 {
public static void main(String[] args) {
//文件---》程序
//1.确定一个文件
File f=new File("/Users/Desktop/java/test/Hello.txt");
//2.将"一个管放进"源文件中
try {
FileInputStream fis = new FileInputStream(f);
//对读取的文件大小进行预估
System.out.println(fis.available());
//3.开始"动作"
int n=fis.read();
while(n!=-1){
System.out.print(n+"\t");
n=fis.read();
}
System.out.println();
System.out.println("-----------------");
//一种高效读取方法
//定义缓冲数组，数组长度8，那么下面就读8个字节
byte[] b=new byte[8];
//返回值m代表这个数组中被占用的数量
FileInputStream fis1 = new FileInputStream(f);
int m=fis1.read(b);
while(m!=-1){
for (int i = 0; i <m ; i++) {
System.out.print(b[i]+"\t");
}
m=fis1.read(b);
}
fis1.close();
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出
30
228 189 160 229 165 189 239 188 129 232 167 129 229 136 176 228 189 160 229 190 136 233 171 152 229 133 180 239 188 129
-----------------
-28 -67 -96 -27 -91 -67 -17 -68 -127 -24 -89 -127 -27 -120 -80 -28 -67 -96 -27 -66 -120 -23 -85 -104 -27 -123 -76 -17 -68 -127
写文件
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo03 {
public static void main(String[] args) throws IOException {
//1.确定一个文件：目标文件
File f=new File("/Users/Desktop/java/test/b.txt");
//2.将管子放到目标文件中
FileOutputStream fos=new FileOutputStream(f);
//如果用空构造器，文件直接覆盖；如果用两个参数的构造器，设置true，在文件内容结尾追加
//FileOutputStream fos=new FileOutputStream(f,true);
//3.给一个字符串
String str="abc你好";
//4.开始动作
byte[] bytes=str.getBytes();
for (byte b:bytes) {
fos.write(b);
}
//关闭fos流
fos.close();
}
}
运行结果：生成b.txt文件，将abc你好写入了b.txt文件中。
复制文件
import java.io.*;
public class Demo04 {
public static void main(String[] args) throws IOException {
//1.确定源文件
File f1=new File("/Users/Desktop/java/test/b.txt");
//2.确定目标文件
File f2= new File("/Users/Desktop/java/test/c.txt");
//3.将一个管放入源文件中
FileInputStream fis = new FileInputStream(f1);
//4.将一个管放入目标文件中
FileOutputStream fos=new FileOutputStream(f2);
//5.开始动作
//利用字节流，源文件和目标文件各访问了文件（内容所占的字节数）次。
// int n=fis.read();
// while(n!=-1){
// fos.write(n);
// n=fis.read();
// }
//高效动作
//利用缓冲数组，源文件和目标文件各访问了文件（内容长度/缓冲数组的长度）次。
byte[] b=new byte[6];
int len=fis.read(b);
while(len!=-1){
//0-len保证只把有效的字节复制进c.txt
fos.write(b,0,len);
len=fis.read(b);
}
//6.关闭流：先开后关
fos.close();
fis.close();
}
}
运行结果：生成c.txt文件，将b.txt文件的内容复制进了b.txt文件中。
文件字符流
复制文件
import java.io.*;
public class Demo05 {
public static void main(String[] args) throws IOException {
//确定源文件
File f1=new File("/Users/Desktop/java/test/c.txt");
//确定目标文件
File f2=new File("/Users/Desktop/java/test/d.txt");
//3.将一个管放入源文件中
FileReader fr = new FileReader(f1);
//4.将一个管放入目标文件中
FileWriter fw=new FileWriter(f2);
//5.开始动作
//利用字节流，源文件和目标文件各访问了文件（内容的字符数）次。
// int n=fr.read();
// while(n!=-1){
// fw.write(n);
// n=fr.read();
// }
//用char格式读取文件内容
//利用缓冲数组，源文件和目标文件各访问了文件（内容长度/缓冲数组的长度）次。
char[] ch=new char[4];
int len=fr.read(ch);
while(len!=-1){
fw.write(ch,0,len);
len=fr.read(ch);
}
//6.关闭流：字符流必须进行刷新,如果写的是关闭流，那么底层直接帮你做了flush动作
//fw.flush();
fw.close();
fr.close();
}
}
运行结果：生成d.txt文件，将c.txt文件的内容复制进了d.txt文件中。
缓冲流
缓冲流的作用就是把数据先放在一个地方，然后再把数据一次性交付。
缓冲字节流
复制文件
import java.io.*;
public class Demo06 {
public static void main(String[] args) throws IOException {
//确定源文件
File f1=new File("/Users/Desktop/java/test/d.txt");
//确定目标文件
File f2=new File("/Users/Desktop/java/test/e.txt");
//3.直接接触的是字节流，字节流站在工作第一线，直接跟源文件，目标文件接触
FileInputStream fis=new FileInputStream(f1);
FileOutputStream fos=new FileOutputStream(f2);
//字节流外面包着缓冲字节流
BufferedInputStream bis=new BufferedInputStream(fis);
BufferedOutputStream bos=new BufferedOutputStream(fos);
//开始动作
//利用缓冲字节流，源文件和目标文件各只访问了一次。
byte[] b=new byte[4];
int n=bis.read(b);
while(n!=-1){
bos.write(b,0,n);
n=bis.read(b);
}
//关闭流：只关闭高级流就可以，低级流会自动关闭。但是为了保险，在执行一次关闭低级流的语句
bos.close();
bis.close();
fos.close();
fis.close();
}
}
运行结果：生成e.txt文件，将d.txt文件的内容复制进了e.txt文件中。
缓冲字符流
复制文件
import java.io.*;
public class Demo07 {
public static void main(String[] args) throws IOException {
//确定源文件
File f1 = new File("/Users/Desktop/java/test/e.txt");
//确定目标文件
File f2 = new File("/Users/Desktop/java/test/f.txt");
//3.直接接触的是字符流，字符流站在工作第一线，直接跟源文件，目标文件接触
FileReader fr = new FileReader(f1);
FileWriter fw = new FileWriter(f2);
//字符流外面包着缓冲字符流
BufferedReader br = new BufferedReader(fr);
BufferedWriter bw = new BufferedWriter(fw);
//开始动作
String str=br.readLine();
while (str != null) {
bw.write(str);
//加换行
// bw.write("\n");
//bw.newLine();
str=br.readLine();
}
//关闭流：只关闭高级流就可以，低级流会自动关闭。但是为了保险，在执行一次关闭低级流的语句
bw.close();
br.close();
fw.close();
fr.close();
}
}
运行结果：生成f.txt文件，将e.txt文件的内容复制进了f.txt文件中。
