java file类的父类_IO流与File类

IO流

概念：内存与存储设备之间传输数据的通道。

流的分类

按方向分：

输入流：将【存储设备】中的内容读入到【内存】中。

输出流：将【内存】中的内容写入到【存储设备】中。

按单位分：

字节流：以字节为单位，可以读写所有数据。

字符流：以字符为单位，只能读写文本数据。

按功能分：

节点流：具有实际传输数据的读写功能。

过滤流：在节点流的基础之上增强功能。

字节流

字节流的父类(抽象类)：

InputStream(抽象类):字节输入流

OutputStream(抽象类):字节输出流

字节流的实现类：FileInputStream的使用

public static void main(String[] args) throws IOException {

//1.创建FileInputStream对象，并指定文件路径

FileInputStream inputStream = new FileInputStream("d:\\aaa.txt");

//2读取文件

//第一种方法读取文件

int data=0;

while ((data=inputStream.read())!=-1){

System.out.println(data);

}

//第二种方法读取文件

byte[] bytes=new byte[100];

int count=0;

while((count=inputStream.read(bytes))!=-1){

System.out.println(new String(bytes,0,count));

}

//3.关闭

inputStream.close();

System.out.println("执行完毕");

}

FileOutputStream的使用

public static void main(String[] args) throws IOException{

//1创建文件字节输出流

//如果为false，则直接覆盖该文件上的内容，如果为true，则在文件内容的后面追加添加的字节。

FileOutputStream outputStream = new FileOutputStream("d:\\bbb.txt",true);

//2写入文件

//单个字节的写入

outputStream.write(97);

outputStream.write('b');

outputStream.write('e');

outputStream.write('q');

//多个字节的写入

String s="hello io";

outputStream.write(s.getBytes());

//关闭

outputStream.close();

System.out.println("执行完毕");

}

字节流文件的复制：(可以复制图片，以及二进制文件)

public static void main(String[] args) throws Exception {

FileInputStream fi = new FileInputStream("d:\\aaa.txt");

FileOutputStream fo=new FileOutputStream("d:\\ccc.txt");

byte[] bytes=new byte[1024];

int count=0;

while ((count=fi.read(bytes))!=-1){

fo.write(bytes,0,count);

}

fi.close();

fo.close();

}

字节缓冲流

BufferedInputStream/BufferedOutputStream

提高IO效率，减少访问磁盘的次数。

数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close。

BufferedInputStream和BufferedOutputStream的使用

public static void main(String[] args) throws Exception {

FileInputStream fi = new FileInputStream("d:\\aaa.txt");

//创建字节缓冲流,bi作为缓冲区

BufferedInputStream bi = new BufferedInputStream(fi);

int data=0;

while((data=bi.read())!=-1){

System.out.print((char)data);

}

bi.close();

}

------------------------------------------------------------------

public static void main(String[] args) throws Exception {

FileOutputStream fo = new FileOutputStream("d:\\ccc.txt");

BufferedOutputStream bo = new BufferedOutputStream(fo);

for (int i=0;i<10;i++){

bo.write("hello\r\n".getBytes());

bo.flush(); //将缓冲区内容刷新到磁盘中

}

bo.close(); //直接调用close时，同样将内容刷新到磁盘中了

}

对象流：ObjectOutputStream/ObjectInputStream

增强了缓冲区功能。

增强了读写8种基本数据类型和字符串功能。

增强了读写对象的功能：

readObject() :从流中读取一个对象(反序列化)

writeObject() ：向流中写入一个对象(序列化)

public static void main(String[] args) throws Exception {

//1创建对象流

FileOutputStream fo = new FileOutputStream("d:\\ddd.txt");

ObjectOutputStream oo = new ObjectOutputStream(fo);

//写入对象(序列化)

Student student = new Student("张三",18);

oo.writeObject(student);

//3.关闭

oo.close();

System.out.println("序列化完成");

}

public static void main(String[] args) throws Exception {

//1创建对象流

FileInputStream fi = new FileInputStream("d:\\ddd.txt");

ObjectInputStream oi = new ObjectInputStream(fi);

//2读取文件(反序列化)

Student student=(Student)oi.readObject();

//3关闭

oi.close();

System.out.println("反序列化");

System.out.println(student);

}

注意点：

序列化的类必须实现Serializable接口。

序列化类中对象属性要求实现Serializable接口。

序列化版本号ID serialVersionUID，保证序列化的类和反序列化的类是同一个类。

使用transient修饰类属性，则这个属性不能被序列化了。

静态属性不能被序列化。

序列化多个对象，可以借助集合实现。

字符流的父类(抽象类)：

Reader:字符输入流(抽象类)

Writer:字符输出流(抽象类)

文件字符流

FileReader

FileWriter

文件字符流的复制(只能复制文本文件,不能复制图片，以及二进制文件)

图片是二进制文件，没有字符编码。不能使用字符流复制。

public static void main(String[] args) throws Exception {

//1创建字符流的输入、输出

FileReader fr = new FileReader("d:\\write.txt");

FileWriter fw = new FileWriter("d:\\write2.txt");

//2复制

int data=0;

while((data=fr.read())!=-1){

fw.write(data);

fw.flush();

}

//3关闭

fr.close();

fw.close();

}

字符缓冲流BufferedReader\BufferedWriter

高效读写

支持输入换行符

可一次写一行，读一行

打印流PrintWriter

封装了print()/println()方法，支持写入后换行。

支持数据的原样打印。

转换流 InputStreamReader\OutputStreamWriter

可将字节流转换为字符流

可设置字符的编码方式

public static void main(String[] args) throws Exception {

FileInputStream fi = new FileInputStream("d:\\write.txt");

InputStreamReader is = new InputStreamReader(fi, "utf-8"); //可设置编码方式

int data=0;

while((data=is.read())!=-1){

System.out.print((char)data);

}

is.close();

}

public static void main(String[] args) throws Exception {

FileOutputStream fo = new FileOutputStream("d:\\write2.txt");

OutputStreamWriter ow = new OutputStreamWriter(fo, "utf-8");//可设置编码方式

for (int i=0;i<10;i++){

ow.write("好好学习，天天向上\r\n");

ow.flush();

}

ow.close();

}

File类

概念：代表物理盘符中的一个文件或者文件夹。

调用路径分隔符; File.pathSeparator

调用名称分隔符\ File.separator

//文件操作

public static void main(String[] args) throws IOException, InterruptedException {

// separator();

file();

}

public static void separator(){

System.out.println("路径分隔符"+ File.pathSeparator);

System.out.println("名称分隔符"+File.separator);

}

public static void file() throws IOException, InterruptedException {

//创建文件

File file = new File("d:\\file.txt");

//System.out.println(file.toString());

//判断文件是否存在

if (!file.exists()){

boolean newFile = file.createNewFile();

System.out.println("创建结果为"+newFile);

}

//1直接删除

// System.out.println("删除结果为"+file.delete());

//2使用JVM退出的时候删除

// file.deleteOnExit();

// Thread.sleep(5000);

//获取文件信息

System.out.println("获取绝对路径"+file.getAbsolutePath());

System.out.println("获取路径"+file.getPath());

System.out.println("获取父目录"+file.getParent());

System.out.println("获取文件长度"+file.length());

System.out.println("获取文件生成时间"+new Date(file.lastModified()).toLocaleString());

//判断

System.out.println("是否可写"+file.canWrite());

System.out.println("是否是文件"+file.isFile());

System.out.println("是否隐藏"+file.isHidden());

}

//文件夹操作

public static void dir(){

//创建文件夹

File dir = new File("d:\\aaa\\bbb");

if (!dir.exists()){

// dir.mkdir(); 只能生成单级目录

System.out.println("创建结果"+dir.mkdirs());

}

//删除文件夹

//dir.delete(); (只能删除空目录)

//dir.deleteOnExit();

//获取文件信息

System.out.println("获取绝对路径"+dir.getAbsolutePath());

System.out.println("获取路径"+dir.getPath());

System.out.println("获取父目录"+dir.getParent());

System.out.println("获取文件夹长度"+dir.length());

System.out.println("获取文件夹生成时间"+new Date(dir.lastModified()).toLocaleString());

//判断

System.out.println("是否是文件夹"+dir.isDirectory());

System.out.println("是否隐藏"+dir.isHidden());

//获取文件夹中的所有内容

String[] list = dir.list();

for (String s : list) {

System.out.println(s);

}

}

FileFilter接口：当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才 可出现listFiles()的返回值中。

//FileFilter接口的使用，过滤一些文件

File[] files = dir.listFiles(new FileFilter() {

public boolean accept(File pathname) {

if (pathname.getName().endsWith(".jpg")){

return true;

}

return false;

}

});

for (File file : files) {

System.out.println(file);

}

}

递归遍历文件夹，递归删除文件夹

public static void main(String[] args) {

// listDir(new File("d:\\aaa"));

deletedIR(new File("d:\\aaa"));

}

//递归遍历文件夹

public static void listDir(File dir){

File[] files = dir.listFiles();

System.out.println(dir.getAbsolutePath());

if(files!=null&&files.length>0){

for (File file : files) {

if (file.isDirectory()){ //如果file是文件夹，则进行递归。

listDir(file);

}else{

System.out.println(file.getAbsolutePath());

}

}

}

}

//递归删除文件夹及里面的文件

public static void deletedIR(File dir){

File[] files = dir.listFiles();

if(files!=null&&files.length>0){

for (File file : files) {

if(file.isDirectory()){

deletedIR(file);

}else{

System.out.println(file.getAbsolutePath()+"删除"+file.delete());

}

}

}

System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());

}