File类的使用

Java程序如何访问文件？通过 java.io.File 类

使用File类需要先创建文件对象 File file=new File(String pathname);，创建时在构造函数中指定物理文件或目录，然后通过文件对象的方法操作文件或目录的属性。

\ 是特殊字符，要使用需要转义 \\

File 类常用方法

使用示例：

import java.io.File;
import java.io.IOException;

public class TestFile {

    public static void main(String[] args) {
        //创建File对象 传入文件的路径
        File file=new File("D:\\a.txt");
        //创建File对象 传入文件夹的路径
        File dir=new File("D:/word");
        //判断是否存在
        if(file.exists()) {
            if(file.isFile()) {
                //getName()获取名字
                System.out.println(file.getName()+" 是文件");
            }else if(file.isDirectory()){
                System.out.println(file.getName()+" 是目录");
            }            
        }else {
            System.out.println(file.getName()+" 不存在！");
            try {
                //创建文件
                file.createNewFile();
                System.out.println("文件大小："+file.length()+" 字节");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        if(dir.exists()) {
            if(dir.isFile()) {
                System.out.println(dir.getName()+" 是文件");
            }else if(dir.isDirectory()) {
                System.out.println(dir.getName()+" 是文件夹");
                //绝对路径
                System.out.println(dir.getAbsolutePath());
            }            
        }else {
            System.out.println(dir.getName()+" 不存在！");
            //创建目录
            dir.mkdirs();
        }
        
    }
}

流

流：指一连串流动的字符，是以先进先出方式发送信息的通道

输入流：源数据流向程序(读)

输入流：程序中的数据流向目标数据源(写)

Java流的分类

按流向

• 输出流(OutputStream和Writer作为基类)
• 输入流(InputStream和Reader作为基类)

输入输出流是相对于计算机内存来说的

按照处理数据单元划分

• 字节流

  • 字节输入流(InputStream基类)
  • 字节输出流(OutputStream基类)

• 字符流

  • 字符输入流(Reader基类)
  • 字符输出流(Writer基类)

字节流是8位(1B)通用字节流，字符流是16位(2B)Unicode字符流

字节流

FileInputStream 是 InputStream 的子类

InputStream 类常用方法

FileInputStream 类常用构造方法

使用 FileInputStream 读取文件

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestFileInputStream {

    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("D:\\a.txt");
            //读取结果存入StringBuffer
            StringBuffer sb=new StringBuffer();
            System.out.println("预计读取："+fis.available()+"字节");
            //记录每次读取的长度
            int len=0;
            //缓冲区字节数组
            byte[] buff=new byte[1024];
            while((len=fis.read(buff))!=-1) {
                System.out.println("还剩余："+fis.available()+"字节");
                sb.append(new String(buff,0,len));
            }
            System.out.println("结果：");
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream 是 OutputStream 的子类

OutputStream 类常用方法

FileOutputStream的构造方法

使用 FileOutputStream 写文件

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestFileOutputStream {

    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
            //创建输出流对象
            fos=new FileOutputStream("D:\\c.txt");
            //要输出的字符
            String str="hello world 你好";
            //将字符串转成字节数组并写入到流中
            fos.write(str.getBytes());
            //刷新流
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字符流

上面的内容我们看到，字节流不能直接操作字符，所以操作字符用字符流。

FileReader 是 Reader 的子类

Reader 类常用方法

使用 FileReader 读取文本文件

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class TestReader {

    public static void main(String[] args) {
        Reader r=null;
        try {
            //创建FileReader对象
            r=new FileReader("D:\\a.txt");
            //字符缓冲数组
            char[] chrs=new char[512];
            //记录每次读取的个数
            int len=0;
            //循环读取
            while((len=r.read(chrs))!=-1) {
                String str=new String(chrs, 0, len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (r!=null) {
                try {
                    r.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter 是 Writer 的子类

Writer 类常用方法

使用 FileWriter 写入文本文件

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class TestWriter {

    public static void main(String[] args) {
        Writer w=null;
        try {
            //创建字符输出流
            w=new FileWriter("D:\\msg.txt");
            String msg="hello every bady 兄嘚";
            //将字符串写入到流中
            w.write(msg);
            w.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (w!=null) {
                try {
                    w.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

缓冲字符流

如果频繁的对字符进行读写操作，墙裂建议使用缓冲！

BufferedReader 类带有缓冲区，可以先把一批数据读到缓冲区，接下来的读操作都是从缓冲区内获取数据，避免每次都从数据源读取数据进行字符编码转换，从而提高读取操作的效率。

使用BufferedReader读取文本文件

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestBufferedReader {

    public static void main(String[] args) {
        FileReader reader=null;
        BufferedReader br=null;
        try {
            //创建字符读入流
            reader=new FileReader("D:\\a.txt");
            //将字符读入流包装成字符缓冲流
            br=new BufferedReader(reader);
            //记录每行读入的内容
            String line=null;
            //用于拼接保存每行读入的内容
            StringBuffer content=new StringBuffer();
            while ((line=br.readLine())!=null) {
                content.append(line+"\n");
            }
            System.out.println("所有内容：");
            System.out.println(content);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (reader!=null) {
                    reader.close();
                }
                if (br!=null) {
                    br.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

BufferedReader 是 Reader 的子类，带有缓冲区，特有方法 readLine() 按行读取内容

BufferedWriter 类带有缓冲区，与BufferedReader的方向正好相反，BufferedWriter 是把一批数据写到缓冲区，当缓冲区满的时候，再把缓冲区的数据写到字符输出流中。避免每次都执行物理写操作，提高写操作的效率。

使用 BufferedWriter 写文件

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class TestBufferedWriter {

    public static void main(String[] args) {
        FileWriter writer=null;
        BufferedWriter bw=null;
        try {
            writer=new FileWriter("D:\\out.txt");
            bw=new BufferedWriter(writer);
            bw.write("hello");
            //内容换行
            bw.newLine();
            bw.write("world");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (bw!=null) {
                    bw.close();
                }
                if (writer!=null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

关闭流的顺序与创建流的顺序相反

数据流

DataInputStream 类

• FileInputStream 的子类
• 与 FileInputStream 类结合使用读取二进制文件

DataOutputStream 类

• FileOutputStream 的子类
• 与 FileOutputStream 类结合使用写二进制文件

使用数据流复制图片

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestCopy {

    public static void main(String[] args) {
        //文件输入流
        FileInputStream fis=null;
        //数据输入流(包装fis得到)
        DataInputStream dis=null;
        //文件输出流
        FileOutputStream fos=null;
        //数据输出流(包装fos得到)
        DataOutputStream dos=null;
        
        try {
            fis=new FileInputStream("D:\\a.jpg");
            dis=new DataInputStream(fis);
            fos=new FileOutputStream("F:\\b.jpg");
            dos=new DataOutputStream(fos);
            //缓冲数组
            byte[] buff=new byte[1024];
            //记录每次读取的字节个数
            int len=0;
            //循环读入
            while((len=dis.read(buff))!=-1) {
                //循环写入len个字节
                dos.write(buff,0,len);
            }
            System.out.println("完成");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (dis!=null) {
                    dis.close();
                }
                if (dos!=null) {
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}