24. File类 及IO操作

于 2020-06-20 12:20:42 发布
阅读量116 收藏
点赞数
分类专栏： Java SE学习笔记 文章标签： 字符串 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_41907361/article/details/106524643
版权

24. File类 及I/O操作

1、File类

1.1 概述

  • File类是http://java.io包很重要的一个类；
  • File类的对象可以表示文件，也可以是目录。
  • File对象只可以对文件或目录的属性进行操作，不可以操作文件的具体数据，即不能对文件进行读/写操作。

1.2 构造方法

（1） File(File parent, String child)

从父抽象路径名和子路径名字符串创建新的 File实例。

（2）File(String pathname)

通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

（3） File(String parent, String child)

从父路径名字符串和子路径名字符串创建新的 File实例。

（4） File(URI uri)

通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。

代码案例：

//创建文件的方法

public class CreateFile {

	public static void main(String[] args) {
		// 创建文件对象。
		File file = new File("D:/FileDemo/FileDemo.txt");
		// 创建文件
		if (!file.exists()) {
			try {
				if (file.createNewFile()) {
					System.out.println("文件创建成功");
				} else {
					System.out.println("文件创建失败");
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("文件已存在");
		}

	}

}

//创建目录的方法

import java.io.File;

public class CreateDirectory {

	public static void main(String[] args) {
		File file = new File("D:\\FileDemo");

		if (!file.exists()) {
			if (file.mkdirs()) {
				System.out.println("创建成功");
			} else {
				System.out.println("创建目录失败");
			}
		} else {
			System.out.println("目录已存在,创建失败");
		}
	}

}

1.3 常用方法

遍历方法：

//遍历方法

import java.io.File;

public class FileList{
	public static void main(String[] args) {
		// 创建目录对象。
		File file = new File("E:\\");

		// 使用list方法
		String[] fileNameList = file.list();
		
		// 遍历目录数组
		for (String s : fileNameList) {
			System.out.println(s);
		}
		
		System.out.println("------------------------------------");

		// 使用listFiles方法
		File[] fileList = file.listFiles();	
		
		for (File f : fileList) {
			System.out.println(f.getAbsolutePath());
		}
	}
}

1.4 FileFilter文件过滤器

1.4.1 两个作用：

（1）过滤不符合规格的文件名

  • 文件名过滤器接口：interface FilenameFilter
  • 需重写accept方法自定义过滤规则

boolean accept(File dir, String name) – dir：表示文件的当前目录。 – name：表示当前目录的子目录或者文件的名字。

  • File类中提供了使用文件名过滤器遍历目录的方法

String[] list(FilenameFilter filter) – 把满足指定过滤条件的文件和目录，返回到String数组中。 File[] listFiles(FilenameFilter filter) – 把满足指定过滤条件的文件和目录，返回到File数组中。

（2）常用于检测文件是否存在

  • 文件过滤器接口：interface FileFilter
  • 需重写accept方法自定义过滤规则,如下：

boolean accept(File pathName) – pathName：表示当前目录的子目录或者文件的名字。

  • File类中提供了使用文件过滤器遍历目录的方法：

File[] listFiles(FilenameFilter filter) – 把满足指定过滤条件的文件和目录，返回到File数组中。

代码演示：

public class FileFilterDemo {

	public static void main(String[] args) {
		//创建目录对象
		File dir = new File("D:\\FileDemo");

		//使用"匿名内部类"的方式创建过滤器
		FileFilter filter = new FileFilter() {
			@Override
			public boolean accept(File file) {
				return file.getName().toLowerCase().endsWith(".txt");
			}
		};
		
		File[] files = dir.listFiles(filter);
		
		for (File file : files) {
			System.out.println(file);
		}
	}

}

2、输入流与输出流

类：InputStream、OutputStream、Reader、Writer

2.1 流按着数据的传输方向分为：

  1. 输入流：往内存中读叫输入流。
  2. 输出流：从内存中往外写叫输出流。

（1）所有输入流都是InputStream类或者Reader类的子类。

  • 类名以InputStream结尾的类都是InputStream的子类。
  • 类名以Reader结尾的类都是Reader类的子类。

（3）所有输出流都是OutputStream类或者Writer类的子类。

  • 类名以OutputStream结尾的类都是OutputStream的子类。
  • 类名以Writer结尾的类都是Writer类的子类。

2.2 从数据流编码格式上划分为：

  1. 字节流：处理单元为1个字节
  2. 字符流：处理单元为2个字节

（1）InputStream和OutputStream的子类都是字节流

  • 可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。

（2）Reader和Writer的子类都是字符流

  • 主要处理字符或字符串，字符流处理单元为2个字节。
  • 字节流将读取到的字节数据，去指定的编码表中获取对应文字。

由于上述两种分类都是针对InputStream、OutputStream、Reader、Writer四个类，所以代码案例写在一起

代码案例：

//字节输入流（FileInputStream）

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

public class FileInputStreamDemo {

	public static void main(String[] args) {
    
        //建立文件对象
        File file=new File("C:\\Users\\25849\\Desktop\\1.txt"); 
   
        try
        {
            //建立链接
            FileInputStream fileInputStream=new FileInputStream(file);
            
            int  n=0; 
            
            StringBuffer sBuffer=new StringBuffer();
 
            while (n!=-1)  //当n不等于-1,则代表未到末尾
            {
                
               n=fileInputStream.read();//读取文件的一个字节(8个二进制位),并将其由二进制转成十进制的整数返回
              
               char by=(char) n; //转成字符
               
               sBuffer.append(by);
 
            }
           System.out.println(sBuffer.toString());
   
        }
        catch (FileNotFoundException e)
        {
          
           System.out.println("文件不存在或者文件不可读或者文件是目录");
        }
        catch (IOException e)
        {
           System.out.println("读取过程存在异常");
        } 
    }
}

结果：由于文件存的是字符类型，以字节形式读取，会把原本的字符分解为两个字节，所以乱码了

????¤§???????¤§asfsa???
sdg sgdf???dfhfh
?¤§?????????????????¨é??
?????¨é???????¨é??sf?

//字节输出流（FileOutputStream）

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

public class FileOutputStreamDemo {

	public static void main(String[] args) {
		// 建立文件对象
		File file = new File("C:\\Users\\25849\\Desktop\\1.txt");

		try {
			String content = "我生来坚强\n只要不死\n我就笑得猖狂";
			FileOutputStream out = new FileOutputStream(file, true);
			out.write(content.getBytes());
			System.out.println("写入成功");
		}

		catch (FileNotFoundException e) {

			System.out.println("文件不存在或者文件不可读或者文件是目录");
		} catch (IOException e) {
			System.out.println("读取过程存在异常");
		}
	}
}

结果：

写入成功
在没有实力之前，你要学会比狼能忍
在有了实力之后，你要学会比狼更狠我生来坚强我生来坚强
只要不死
我就笑得猖狂

//字符输入流（FileReader）

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

public class FileReaderDemo2 {

	public static void main(String[] args) {

		// 建立文件对象
		File file = new File("C:\\Users\\25849\\Desktop\\1.txt");

		try {
			// 建立链接
			FileReader fileReader = new FileReader(file);
			int n = 0;

			char[] chars = new char[10];
			String s ;

			while ((n = fileReader.read(chars)) != -1) // 当n不等于-1,则代表未到末尾
			{
				String string = new String(chars,0,n);
				
				System.out.println(string);

			}

		} catch (FileNotFoundException e) {

			System.out.println("文件不存在或者文件不可读或者文件是目录");
		} catch (IOException e) {
			System.out.println("读取过程存在异常");
		}
	}
}

//字符输出流（FileWriter）

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

public class FileWriterDemo2 {

	public static void main(String[] args) {
		FileWriter filewriter = null;
		try {

			filewriter = new FileWriter("C:\\Users\\25849\\Desktop\\1.txt",true);

			String content = "abcdefghigklmn";
			
			filewriter.write( content );
		
		} catch (IOException e1) {
			e1.printStackTrace();
		}finally{
			try {
				//清空缓存区
				filewriter.flush();
				//关闭“文件字符输出流”
				filewriter.close();
				System.out.println("写入成功！");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}
}

2.3 从封装类型不同分为：

  1. 节点流：如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等，则称为节点流。
  2. 处理流：如果流封装的是其它流对象，称为处理流。处理流提供了缓冲功能，提高读写效率。

（1）节点流中常用类

  • 字节输入流 FileInputStream
  • 字节输出流 FileOutputStream
  • 字符输入流 FileReader
  • 字符输出流 FileWriter

（2）处理流中常用类

  • 缓冲字节输出流 BufferedOutputStream
  • 缓冲字节输入流 BufferedInputStream
  • 缓冲字符输入流 BufferedReader
  • 缓冲字符输出流 BufferedWriter

上面的节点流就是之前描述的，在这里着重描述处理流

2.3.1 处理流：

1.缓冲区原理：

-缓冲区的概念。

-缓冲区的作用：要对操作的数据进行临时的缓存，提高了读写效率。

-缓冲区如何提高读写效率。

2.处理流的特点：

  • 字符缓冲输入流提供了读取一行的方法readLine() 。
  • 字符缓冲输出流提供了写入一个空行的方法newLine()。
  • 字符缓冲输出流，把写入的数据先写入到内存，再使用flush()方法将内存数据刷到硬盘上。

注意：在使用字符缓冲输出流时，一定先flush(),然后再close(),避免数据的丢失。

代码案例：

//缓冲字节输入处理流(BufferedInputStream)

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo2 {

	public static void main(String[] args) {
		FileInputStream fileInputStream = null;
		BufferedInputStream bufferedInputStream = null;
		try {
			fileInputStream = new FileInputStream("C:\\Users\\25849\\Desktop\\1.txt");
			
			bufferedInputStream = new BufferedInputStream(fileInputStream);		

			byte[] bytes = new byte[16];
	
			int length = 0;
		
			while ((length = bufferedInputStream.read(bytes)) != -1) {
				System.out.println(new String(bytes, 0, length));
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bufferedInputStream.close();
				System.out.println("读取完成！");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

//缓冲字节输出处理流(BufferedOutputStream)

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo2 {

	public static void main(String[] args) {

		FileOutputStream fileOutputStream = null;

		BufferedOutputStream bufferedOutputStream = null;
		try {

			fileOutputStream = new FileOutputStream("C:\\Users\\25849\\Desktop\\1.txt");

			bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

			String content = "abcdefghigklmn";

			byte[] bytes = content.getBytes();

			bufferedOutputStream.write(bytes);

			System.out.println("写入成功！");
		} catch (IOException e) {

			e.printStackTrace();

		} finally {
			try {
				// 刷新 “缓冲字节输出处理流”
				bufferedOutputStream.flush();
				// 关闭 “缓冲字节输出处理流”
				bufferedOutputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

//缓冲字符输入处理流(BufferedReader)

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

public class BufferedReaderDemo2 {

	public static void main(String[] args) {

		FileReader fileReader = null;
	
		BufferedReader bufferedReader = null;
		try {
	
			fileReader = new FileReader("C:\\Users\\25849\\Desktop\\1.txt");
	
			bufferedReader = new BufferedReader(fileReader);
	
			String content = null;
			int length = 0;
			
			while ((content = bufferedReader.readLine()) != null) {
	
				System.out.println(content);
			}

		} catch (IOException e) {

			e.printStackTrace();
		} finally {

			try {
				//关闭  “字符输入处理流”
				bufferedReader.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

//缓冲缓冲字符输出处理流(BufferedWriter )

2.4 节点流和处理流速度的对比

//用字节节点流复制一个视频

package com.company.project.homework.h11;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.xml.crypto.Data;

//复制两个视频文件
//字节流
//用节点流

public class Demo2 {
	public static void main(String[] args) throws IOException {
		
		long now = System.currentTimeMillis();
		
		FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");
		FileOutputStream fos ;
		
		File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");
		if(!newfile.exists()) {
			newfile.createNewFile();
		}
		fos = new FileOutputStream(newfile);

		
		byte[] by = new byte[128];
		int num = 0 ;
		while ((num = fis.read(by)) != -1) {
			fos.write(by,0,num);
			
		}
		System.out.println("复制完成");
		System.out.println("使用时间:" + (System.currentTimeMillis() - now));
		fos.close();
		fis.close();
		
	}
}

结果：

复制完成
使用时间:203

//用字节处理流复制同一个视频

package com.company.project.homework.h11;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.xml.crypto.Data;

//复制两个视频文件
//字节流
//用处理流

public class Demo {
	public static void main(String[] args) throws IOException {
		
		long now = System.currentTimeMillis();
		
		FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");
		FileOutputStream fos ;
		
		File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");
		if(!newfile.exists()) {
			newfile.createNewFile();
		}
		fos = new FileOutputStream(newfile);
		
		
		BufferedInputStream bis = new BufferedInputStream(fis);
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		
		byte[] by = new byte[128];
		int num = 0 ;
		while ((num = bis.read(by)) != -1) {
			bos.write(by,0,num);
			
		}
		System.out.println("复制完成");
		System.out.println("使用时间:" + (System.currentTimeMillis() - now));
		bos.close();
		bis.close();
		fos.close();
		fis.close();
		
	}
}

结果：

复制完成
使用时间:15

明显速度提升了很多！！！！

一直流浪~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值