要把数据持久化存储，就需要把内存中的数据存储到内存以外的其他持久化设备(硬盘、光盘、U盘等)上。
当需要把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作。
当把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作。
因此把这种输入和输出动作称为IO操作。
1 File类
有三个实体：
目录：就是文件夹
文件
路径
Java中把文件或者目录（文件夹）都封装成File对象。并且与平台无关。
1.1构造方法
1.1.1 File(String pathname)
例：
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:\\zyx\\javaFile");
System.out.println(file);
}
}
注意：
1）导java.io.File这个包
2）路径要转义写成E:\\zyx\\java（两个反斜杠）
3）打印file，是默认调用的toString()方法
4）如果文件不存在，也能构造这个对象，构造方法不会判断该路径的文件或目录是否存在
5）如果路径写成：E:\\zyx\\JAVAFile，是一样的，因为windows下不区分大小写
6）windows中，文件名和文件夹名也不能相同
1.1.2 File(String parent, String child)
传一个父路径，一个子路径，这样更灵活，可以当成一个变量传过来
例：
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:\\zyx","JAVAFile");
System.out.println(file);
}
}
1.1.3 File(File parent, String child)
可以传过来一个File对象，那么就能用对象的方法了（前面那两个构造方法只能用字符串的方法）
例：
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:\\zyx\\JAVAFile");
File file2=new File(file,"a.txt");
System.out.println(file2);
}
}
三个构造方法，根据具体需求来用，一般用第一个直接传路径的。
1.2成员变量
这其实是两个变量，一样的用法，只是返回值不同，平时只用String的就可以。
Tips：
所以写时不要把路径写死，因为与平台无关，可以把\\换成File.separator
例：
import java.io.File;
public class FileTest {
public static void main(String[] args) {
//与系统有关的路径分隔符
String s1=File.pathSeparator;
System.out.println(s1); //结果是分号
//与系统有关的名称分隔符
String s2=File.separator;
System.out.println(s2);
}
}
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:"+File.separator+"zyx"+File.separator+"JAVAFile");
System.out.println(file);
}
}
1.3普通方法
1.3.1获取文件相关信息
1）返回文件的绝对路径：
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:\\zyx\\JAVAFile");
String path=file.getAbsolutePath();
System.out.println(path);
}
}
如果是一个相对的路径：
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("abc");
String path=file.getAbsolutePath();
System.out.println(path);
}
}
还是输出一个绝对的路径
注意：相对路径中用/分隔。绝对路径用\\
2）获取文件名和路径
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:\\zyx\\JAVAFile");
String name=file.getName(); //获取文件名或文件夹名
String path=file.getPath(); //获取绝对路径
System.out.println("name："+name);
System.out.println("path："+path);
}
}
如果是一个相对的路径：
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("demo02");
String name=file.getName(); //获取文件名或文件夹名
String path=file.getPath(); //获取绝对路径
System.out.println("name："+name);
System.out.println("path："+path);
}
}
这个方法只是把路径以字符串的形式输出一下
3）isAbsolute()测试抽象路径名是否为绝对路径名
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:\\zyx\\javaFile");
boolean flag=file.isAbsolute();
System.out.println(flag);
}
}
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("abc");
boolean flag=file.isAbsolute();
System.out.println(flag);
}
}
4）length()
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file=new File("E:\\zyx\\javaFile\\eclipse.zip");
long size=file.length();
System.out.println(size);
}
}
就是文件的大小：
1.3.2文件和文件夹的创建、删除
1）创建文件
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\javaFile\\a.txt");
boolean flag=file.createNewFile();
System.out.println(flag);
}
}
如果再执行一遍这个代码，结果就是false了。
如果这样写：
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\javaFile\\a");
boolean flag=file.createNewFile();
System.out.println(flag);
}
}
可以看到创建了一个名字为a的文件，其文件类型是“文件”
所以这个方法只能创建文件，不能创建文件夹
2）删除文件或目录
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\javaFile\\a");
boolean flag=file.delete();
System.out.println(flag);
}
}
删除的文件或目录不进回收站，直接从硬盘上删除，所以要谨慎调用这个方法。
3）exists() 判断是否存在文件或文件夹
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\java");
boolean flag=file.exists();
System.out.println(flag);
}
}
所以进行文件操作时，要先判定一下是否存在
4）isDirectory() 判断文件对象是否是文件夹（目录）
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\java\\a");
boolean flag=file.isDirectory();
System.out.println(flag);
}
}
5）创建目录
mkdir()只能创建一个（一级）目录
例：
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\java\\b");
boolean flag=file.mkdir();
System.out.println(flag);
}
}
mkdirs()可以创建多级目录，一级也能创建，所以一般用这个
例：
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\java\\f\\a\\b\\c");
boolean flag=file.mkdirs();
System.out.println(flag);
}
}
总结：三个单词：
File 文件
Directory 目录
Path 路径
先判断是否存在，再判断是不是目录，不是，那就一定是文件
因为系统上只有文件或文件夹
1.3.3 listFiles()方法
获取一个目录中的所有文件或者目录中的文件夹：
例1：
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\java");
String[] files=file.list();
for(String s:files){
System.out.println(s);
}
}
}
例2：
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\java");
File[] files=file.listFiles();
for(File f:files){
System.out.println(f);
}
}
}
注意：在获取指定目录下的文件或者文件夹时必须满足下面两个条件
1）指定的目录必须是存在的，
2）指定的必须是目录。否则容易引发返回数组为null，出现NullPointerException
1.3.4文件过滤器
例：
import java.io.File;
import java.io.FileFilter;
public class MyFileter implements FileFilter{
public boolean accept(File pathname) {
return pathname.getName().toLowerCase().endsWith(".java"); //转小写，以.java结尾
}
}
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
File file=new File("E:\\zyx\\java");
File[] files=file.listFiles(new MyFileter());
for(File f:files){
System.out.println(f);
}
}
}
图说明：
每个文件都传进accept方法中，符合的，放入files数组中
是listFiles调用的accept方法
2递归
2.1递归概述
指在当前方法内调用自己的这种现象
例1：
public class Demo04 {
public static void main(String[] args) {
System.out.println(getSum(3));
}
//递归
public static int getSum(int n){
if(n==1){
return 1;
}
return n+getSum(n-1);
}
}
图说明：
例2：100的阶乘 （100！也就是100*99*98*...1）
import java.math.BigInteger;
public class Test {
public static void main(String[] args) {
System.out.println(getSum(100));
}
//递归求阶乘
public static BigInteger getSum(Integer n){
BigInteger big=new BigInteger(n.toString());
if(n==1){
return new BigInteger("1");
}
return big.multiply(getSum(n-1));
}
}
自己调用自己，但是要给出口，
否则会栈内存溢出，
递归次数不要太多，还是会溢出，
2.2递归打印所有子目录中的文件路径
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File file = new File("E:\\zyx\\java");
getFileAll(file);
}
// 获取指定目录以及子目录中的所有的文件
public static void getFileAll(File file) {
File[] files = file.listFiles();
// 遍历当前目录下的所有文件和文件夹
for (File f : files) {
// 判断当前遍历到的是否为目录
if (f.isDirectory()) {
// 是目录，继续获取这个目录下的所有文件和文件夹
getFileAll(f);
} else {
// 不是目录，说明当前f就是文件，那么就打印出来
System.out.println(f);
}
}
}
}
2.3递归过滤文件（包括子目录）
import java.io.File;
import java.io.FileFilter;
public class MyFileter implements FileFilter{
public boolean accept(File pathname) {
if(pathname.isDirectory()){
return true;
}
return pathname.getName().toLowerCase().endsWith(".java");
}
}
import java.io.File;
public class Demo05 {
public static void main(String[] args) {
File file=new File("E:\\zyx\\java");
getFile(file);
}
//递归加过滤
public static void getFile(File dir){
File[] files=dir.listFiles(new MyFileter());
for(File f:files){
//如果是文件夹,则调用自己
if(f.isDirectory()){
getFile(f);
}else{
System.out.println(f);
}
}
}
}
图说明：
3字节流
3.1字节输出流OutputStream
OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能方法。
输出流中定义都是写write方法:
3.1.1 FileOutputStream类
OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。
构造方法：
例：
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("E:\\zyx\\java\\demo.txt");
// 写字节
fos.write(100);
fos.write(49);
fos.write(48);
fos.write(48);
// 释放资源
fos.close();
}
}
练习时可以Throws抛异常:
创建的文件对象，如果文件不存在，会创建一个，如果有，则覆盖
write写时，底层会转换成二进制，写进也是二进制，但是是txt文本文件，所以走ascii表，解析成可以看懂的。
写字节数组：
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("E:\\zyx\\java\\demo.txt");
// 写字节数组
byte[] bytes = { 97, 98, 99, 100 };
fos.write(bytes);
// 释放资源
fos.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("E:\\zyx\\java\\demo.txt");
// 写字节数组
byte[] bytes = { 97, 98, 99, 100 };
fos.write(bytes,1,1);
//fos.write("字符串转成字节数组".getBytes());
// 释放资源
fos.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("E:\\zyx\\java\\demo.txt");
// 写字节数组
fos.write("字符串转成字节数组".getBytes());
// 释放资源
fos.close();
}
}
Tips:
1）一个字符是两个字节
2）文本文件：用txt打开可以看懂，就是文本文件。看不懂的就是字节文件。
3.1.2给文件中续写和换行
1）续写：
2）\r\n换行
例：
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("E:\\zyx\\java\\demo.txt", true);
// 写字节数组
byte[] bytes = { 97, 98, 99, 100 };
fos.write(bytes);
fos.write(bytes, 1, 1);
fos.write("hello,java".getBytes());
// 换行
fos.write("\r\nhello,java".getBytes());
// 释放资源
fos.close();
}
}
3.1.3 IO异常的处理
处理：
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo02 {
public static void main(String[] args) {
//创建字节输出流对象
FileOutputStream fos=null;
try {
//创建字节输出流对象
fos=new FileOutputStream("E:\\zyx\\java\\test.txt");
fos.write("你好".getBytes());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
//如果发生异常，中止程序
throw new RuntimeException();
}finally{
//释放资源
try {
if(fos!=null)
fos.close(); //如果创建时就发生异常，则没必要关了
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
throw new RuntimeException();
}
}
}
}
说明：
1）FileNotFoundException异常是IOException异常的子类，所以抛一个IO异常就可以
2）throw new RuntimeException();这句：如果下面还有写入操作，那么上面发生异常，则不能再走了，就加一个程序终止
3.2字节输入流InputStream
InputStream此抽象类，是表示字节输入流的所有类的超类。定义了字节输入流的基本共性功能方法。
int read():读取一个字节并返回，没有字节返回-1.
int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。
3.2.1 FileInputStream类
构造方法：
3.2.2读取数据read()方法
例：
import java.io.FileInputStream;
import java.io.IOException;
public class MyTest2 {
public static void main(String[] args) throws IOException {
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\demo.txt");
int len=0;
while((len=fis.read())!=-1){
System.out.print((char)len);
}
fis.close();
}
}
Tips：read()循环，要用一个变量len来做判断，不然还会往后读，和之前学的next()类似。
3.2.3读取数据read(byte[])方法
数组长度一般以1024为单位
例：
import java.io.FileInputStream;
import java.io.IOException;
public class MyTest2 {
public static void main(String[] args) throws IOException {
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\demo.txt");
//创建数组
byte[] bytes=new byte[2];
int len=0;
while((len=fis.read(bytes))!=-1){
System.out.print(new String(bytes,0,len)); //有效字符长度
}
fis.close();
}
}
3.2.4复制文件
例1：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 明确数据源
FileInputStream fis = new FileInputStream("E:\\zyx\\java\\demo.txt");
// 明确目的地
FileOutputStream fos = new FileOutputStream("E:\\zyx\\java\\demoCopy.txt");
// 开始复制
int len = 0;
while ((len = fis.read()) != -1) {
fos.write(len);
}
fis.close();
fos.close();
}
}
例2：复制压缩包（或图片），并记录复制的时间
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
method01();
}
//复制
public static void method01() throws IOException{
//明确数据源
FileInputStream fis=new FileInputStream("E:\\zyx\\java\\eclipse.zip");
//明确目的地
FileOutputStream fos=new FileOutputStream("E:\\zyx\\java\\a\\eclipse.zip");
//开始复制
byte[] bytes=new byte[1024];
long start=System.currentTimeMillis();
int len=0;
while((len=fis.read(bytes))!=-1){
fos.write(bytes);
}
fis.close();
fos.close();
long end=System.currentTimeMillis();
System.out.println(end-start);
}
}
4字符编码表
就是生活中字符和计算机二进制的对应关系表。
1、ascii： 一个字节中的7位就可以表示。对应的字节都是正数。0-xxxxxxx
2、iso-8859-1：拉丁码表 latin，用了一个字节用的8位。1-xxxxxxx 负数。
3、GB2312：简体中文码表。包含6000-7000中文和符号。用两个字节表示。两个字节第一个字节是负数,第二个字节可能是正数
4、GBK：目前最常用的中文码表，2万的中文和符号。用两个字节表示，其中的一部分文字，第一个字节开头是1，第二字节开头是0
5、GB18030：最新的中文码表，目前还没有正式使用。
6、unicode：国际标准码表，无论是什么文字，都用两个字节存储。
Java中的char类型用的就是这个码表。char c = 'a'; 占两个字节。
7、UTF-8：基于unicode，一个字节就可以存储数据，不用两个字节存储，而且这个码表更加的标准化，在每一个字节头加入了编码信息(后期到api中查找)。
Tips:
1）Java中的字符串是按照系统默认码表来解析的，简体中文版字符串默认的码表是GBK。
2）能识别中文的码表：GBK、UTF-8；正因为识别中文码表不唯一，涉及到了编码解码问题。
3）对于开发人员，常见的编码：GBK UTF-8 ISO-8859-1（以后jsp用）
4）文字--->(数字) ：编码。 “abc”.getBytes() byte[]
(数字)--->文字：解码。 byte[] b={97,98,99} new String(b,0,len)
5字符流
例：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 给文件中写中文
writeCNText();
// 读取文件中的中文
readCNText();
}
// 写中文
public static void writeCNText() throws IOException {
FileOutputStream fos = new FileOutputStream("E:\\zyx\\java\\test.txt");
fos.write("欢迎你".getBytes());
fos.close();
}
// 读取中文
public static void readCNText() throws IOException {
FileInputStream fis = new FileInputStream("E:\\zyx\\java\\test.txt");
int ch = 0;
while ((ch = fis.read()) != -1) {
System.out.println(ch);
}
fis.close();
}
}
用字节流读取的全是字节，所以要用到字符流来进行文本文件的读和写。
5.1字符输入流Reader
Reader，读取字符流的抽象超类
read():读取单个字符并返回
read(char[]):将数据读取到数组中，并返回读取的个数。
5.1.1 FileReader类
例1：
import java.io.FileReader;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
// 创建字符输入流
FileReader fr = new FileReader("E:\\zyx\\java\\demo.txt");
int len = 0;
while ((len = fr.read()) != -1) {
System.out.print((char) len);
}
fr.close();
}
}
例2：
import java.io.FileReader;
import java.io.IOException;
public class MyTest {
public static void main(String[] args) throws IOException {
FileReader fr=new FileReader("E:\\zyx\\java\\demo.txt");
char[] ch=new char[2]; //缓冲容器的作用
int len=0;
while((len=fr.read(ch))!=-1){
System.out.print(new String(ch,0,len));
}
fr.close();
}
}
5.2字符输出流Writer
Writer是写入字符流的抽象类。
5.2.1FileWriter类
构造方法
5.2.2 flush()和close()
Tips：
1）close有可能发生异常，不执行，所以写一次Flush刷一次
2）close只能用一次，关了后，对象就不能用了
3）flush可以无限用
4）close最后还能刷一下，所以最后的flush可以不用写
例：
import java.io.FileWriter;
import java.io.IOException;
public class MyTest2 {
public static void main(String[] args) throws IOException {
FileWriter fw=new FileWriter("E:\\zyx\\java\\demo.txt",true); //有true是续写
fw.write(100); //走ascii
fw.flush();
char[] ch={'a','中','b'};
fw.write(ch);
fw.flush();
fw.write("你好");
fw.flush();
fw.close();
}
}
5.2.3复制文本文件
例：
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class MyTest2 {
public static void main(String[] args) throws IOException {
// 明确数据源
FileReader fr = new FileReader("E:\\zyx\\java\\demo.txt");
// 明确目的地
FileWriter fw = new FileWriter("E:\\zyx\\java\\a\\demo.txt");
int len = 0;
char[] ch = new char[1024];
while ((len = fr.read(ch)) != -1) {
fw.write(ch, 0, len);
fw.flush();
}
fr.close();
fw.close();
}
}
不能用字符流复制图片：
可以看到，虽然复制了，但是图片无法查看。
总结：
文本文件用字符流
图片，视频，压缩包等用字节流
用到的字节数组或字符数组一般以1024为单位