一：File
File:文件和目录(文件夹)路径名的抽象表示形式。
File的构造方法：
File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
创建功能：
A:创建文件
public boolean createNewFile():如果文件不存在，就创建。否则，不创建。
B:创建目录
public boolean mkdir():如果目录不存在，就创建。否则，不创建。
public boolean mkdirs():如果目录不存在，就创建。否则，不创建。
即时父目录不存在，也可以连父目录一起创建。
删除功能：
public boolean delete():既可以删除文件，又可以删除目录。
路径问题：
A:绝对路径 就是以盘符开始的路径(d:\\test\\aaa\\b.txt)
B:相对路径 就是不以盘符开始的路径(a.txt)
一般都是相对应当前的项目而言的。
注意事项：
A:Java程序的删除不走回收站。
B:如果目录内还有内容就不能删除。
判断功能：
public boolean isDirectory():是否是目录
public boolean isFile():是否是文件
public boolean exists():是否存在
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏
获取功能：
public String getAbsolutePath():获取绝对路径
public String getPath():获取相对路径
二：字节流及字节高效流
I/O流的分类（画图讲解）
IO流分类：
1.流向：
输入流
输出流
2 数据类型：
字节流
字节输入流 InputStream(抽象类)
字节输出流 OutputStream（抽象类）
字符流
字符输入流 Reader
字符输出流 Writer
字符输出流
注意：一般我们在讨论IO的分类时，默认是按照数据类型分的。
字节输出流：OutputStream（抽象类）
因为OutputFile是抽象类，所以我们用他的子类FileOutputStream
构造方法：
FileOutputStream(File file)
FileOutputStream(String name)
成员方法：
write(byte[] b)
write(int b) ：一次写一个字节
write(byte[] b, int off, int len) ：一次写一个字节数组的一部分
需求：请用字节流往一个文本文件中写一句话：”helloworld”。
分析：
首先要知道是字节流
写数据我们就应该知道是字节输出流
我们如何往一个文件写数据呢?
或者说就是字节输出流的操作步骤是什么呢?
A:创建字节输出流对象
B:调用写数据的方法
C:释放资源
public class OutputStreamDemo {
public static void main(String[] args) throws IOException {
/**
* 1.创建文件输出流对象
* 2.调用输出流对象的方法给文件中写数据
* 3.释放资源
*/
//public FileOutputStream(String name)
//public FileOutputStream(File file)
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("a.txt");
//调用输出流的写数据的方法给文件中写数据
byte[] byf = "helloworld".getBytes();
fos.write(byf);
//释放资源,关流操作
fos.close();
}
}字节输入流：
字节输入流操作步骤：
A:创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");
B:调用方法读取数据（一次读取一个字节数组，提升效率）
一次读取一个字节数组： public int read(byte[] b):返回实际读取长度,数据被读取到数组中。
C:释放资源
fis.close
字节缓冲区流（也叫高效流）：
BufferedInputStream(read() 一次读取一个字节, public int read(byte[] b):返回实际读取长度,数据被读取到数组中。)
BufferedOutputStream（write(byte[] b)）
流
低级流: 基本的流，可以直接操作文件。
高级流：是操作基本流的流。
练习：字节流复制文件（视频文件，并测试所用时间）：
A:基本字节流一次读写一个字节
B:基本字节流一次读写一个字节数组
C:高效字节流一次读写一个字节
D:高效字节流一次读写一个字节数组
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
*
* 字节流复制文件（视频文件，并测试所用时间）：
* A:基本字节流一次读写一个字节
* B:基本字节流一次读写一个字节数组
* C:高效字节流一次读写一个字节
* D:高效字节流一次读写一个字节数组
获取时间的方法：
System.currentTimeMillis()
*
*/
public class Test {
public static void main(String[] args) throws IOException {
//复制文件开始之前的时间
long startTime = System.currentTimeMillis();
// method1();//A:基本字节流一次读写一个字节 15099
// method2();// B:基本字节流一次读写一个字节数组 31(这种处理方案使用的是最多的)
// method3();//C:高效字节流一次读写一个字节 234
method4();//D:高效字节流一次读写一个字节数组16
long endTime = System.currentTimeMillis();
System.out.println(endTime-startTime);
}
private static void method4() throws IOException {
// TODO Auto-generated method stub
//C:高效字节流一次读写一个字节
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));
//高校字节流一次读写一个字节
byte[] byf = new byte[1024];
int len;
while ((len = bis.read(byf))!=-1) {
bos.write(byf, 0, len);
}
//3.关流
bos.close();
bis.close();
}
private static void method3() throws IOException {
//C:高效字节流一次读写一个字节
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));
//高校字节流一次读写一个字节
int by;
while ((by = bis.read())!=-1) {
bos.write(by);
}
//3.关流
bos.close();
bis.close();
}
private static void method2() throws IOException {
// B:基本字节流一次读写一个字节数组
//疯转数据剧院和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("a.mp4");
//一次读写一个字节
byte[] byf =new byte[1024];
int len;
while ((len=fis.read(byf))!=-1) {
fos.write(byf, 0, len);
}
//3.释放资源
fos.close();
fis.close();
}
private static void method1() throws IOException {
//A:基本字节流一次读写一个字节
//疯转数据剧院和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("a.mp4");
//一次读写一个字节
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}
//3.释放资源
fos.close();
fis.close();
}
}
字符流
Reader
Writer
IO流中的编码和解码问题
OutputStreamWriter:把字节输出流转换为字符输出流
InputStreamReader:把字节输入流转换为字符输入流
转换流
写入数据，把字节输出流转换为字符输出流（不指定码表）
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));
把字节输出流转换为字符输出流（指定码表）
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "GBK");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "UTF-8");
读取数据， 把字节输入流转换为字符输入流（不指定码表）
InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));
把字节输入流转换为字符输入流（指定码表）
InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"), "GBK");
总结：我们一般创建字符输入或者输出流一般情况下使用系统默认的码表就可以，
如果来来回回需要指定码表的话，就显得非常的麻烦了
如果采用刚才的方式，创建对象写起来比较复杂。
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
为了简化这种操作，java就针对这两个转换的字符流提供其子类。
FileReader和FileWriter
它们的默认编码是采用系统编码。
构造学习：
FileWriter(File file)
FileWriter(String fileName)
FileReader(File file)
FileReader(String fileName)
flush()和close()的区别?
A:flush 刷新缓冲区，流对象可以继续
B:close 先刷新缓冲区，再关闭流对象。流对象不可以继续使用了。
写数据方法：
一次写一个字符 write(int c)
一次写一个字符数组write(char[] cbuf)
一次写一个字符数组的一部分write(char[] cbuf, int off,int len)
一次写一个字符串write(String str)
一次写一个字符串的一部分write(String str,int off,int len)
字符输入流
字符输入流操作步骤:
A:创建字符输入流对象
FileReader fr = new FileReader("a.txt");
B:读取数据并显示在控制台
a:一次读取一个字符
一次读取一个字符
int ch;
while ((ch = fr.read()) != -1) {
System.out.print((char) ch);
}
b:一次读取一个字符数组
char[] chs = new char[1024];
int len;
while ((len = fr.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
C:释放资源
fr.close();
注意：字符流输入输出流复制的文件是有要求的，简单来说只要是记事本打开文件的内容你能够看得懂，就可以用字符流来进行复制，否则不行
具体原因：像复制MP3或者一些视频文件的时候，如果他的字节个数不是偶数的话，就会造成文件的缺损，
因为一个字符等于两个字节
需求：给文件中写入十个”helloworld”,每写一个换一行，每写一行必须写入一个换行符“/r/n”
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException {
//* 需求：
//* 给文件中写入十个"helloworld",每写一个换一行，每写一行必须写入一个换行符“/r/n”
//1.创建字符输出流
FileWriter fw = new FileWriter("e.txt");
//2.给文件中写10个helloworld
for (int i = 0; i < 10; i++) {
//window平台下换行符是“\r\n”
/**
* 在咱们window平台下换行符是“\r\n”，
* 但是在Linux平台和mac平台换行符和
* windows平台是完全不一样的，这样就会
* 造成一个问题，我们在windows平台台下写的代码
* 无法拿到其他平台进行使用
*/
fw.write("helloworld"+"\r\n");
fw.flush();
}
//3.释放资源
fw.close();
}
}高效流：
BufferedReader:字符缓冲输入流
构造：BufferedReader(Reader in)
特殊方法：public String readLine():包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
BufferedWriter:字符缓冲输出流
构造：BufferedWriter(Writer out)
特殊方法：public void newLine():会根据系统来确定写入不同的换行符
练习： 复制文本文件：
基本字符流一次读写一个字符
基本字符流一次读写一个字符数组
高效字符流一次读写一个字符
高效字符流一次读写一个字符数组
public class Test {
public static void main(String[] args) throws IOException {
method();//基本字符流一次读写一个字符
method2();//基本字符流一次读写一个字符数组
method3();//高效字符流一次读写一个字符
method4();//高效字符流一次读写一个字符数组
}
private static void method4() throws IOException {
//高效字符流一次读写一个字符数组
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("j.txt"));
//一次读写一个字符数组
char[] chs = new char[1024];
int len;
while ((len = br.read(chs))!=-1) {
bw.write(chs, 0, len);
bw.flush();
}
//释放资源
bw.close();
br.close();
}
private static void method3() throws IOException {
//高效字符流一次读写一个字符
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("j.txt"));
//一次读写一个字符
int ch;
while ((ch=br.read())!=-1) {
bw.write(ch);
bw.flush();
}
//关流
bw.close();
br.close();
}
private static void method2() throws IOException {
//基本字符流一次读写一个字符数组
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("j.txt");
//一次读写一个字节数组
char[] chs = new char[1024];
int len;
while ((len = fr.read(chs))!=-1) {
fw.write(chs, 0, len);
fw.flush();
}
//关流
fw.close();
fr.close();
}
private static void method() throws IOException {
//基本字符流一次读写一个字符
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("j.txt");
//一次读取一个字符,返回的是该字符对应的int值
int ch;
while ((ch=fr.read())!=-1) {
//System.out.println((char)ch);
fw.write(ch);
fw.flush();
}
//释放资源
fr.close();
fw.close();
}
}
4324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
