IO流File的讲解及使用

IO流对象

File类

• 文件：计算机中存储数据(音乐，电影，word)
• 目录：Directory 计算机中的文件夹，文件夹不能存储数据，保护文件的容器
• 路径：文件和目录所在计算机中的位置
  java.io.File类：文件和目录以及路径，变成对象，File类的方法，操作对象
  File类具有平台无关性：Windows系统，Linux系统，Mac系统

File类的构造方法

URI:统一资源标识符，包含了URL，包含非网址
URL:统一资源定位符，就是互联网的网络地址 协议://域名 http://www.baidu.com

• File(String path)字符串参数必须是路径，字符串路径变成File对象
• File(String parent,String child)parent字符串类型的父路径，child字符串子路径
  。绝对路径：路径在计算机中具有唯一性
  。相对路径：C: \Java\jdk1.8\bin，jdk1.8为参照路径
  .。c:\java是参照路径的父路径 (上一季度文件夹) 唯一性
  .。bin 是参照路径的子路径 (下一级的文件夹) 可以多个
• File(File parent,String child)e(File parent,String child) parent是File类型父路径,child字符串子路径

public static void main(String[ ] args) {
	method( );
	method_2();
	method_3();
}
/*
*File类构造,传递字符串参数(路径)
*/
public static void method() {
	// C: \Java\jdk1.8.0_ 221\bin
	File file = new File("C: \\Java\\jdk1.8.0_ 221\\bin");
	System.out.println(file);
}
/*
*File类构造,传递字符串的父路径和字符串的子路径
*/
public static void method_2() {
	File file = new File("C:\\Java","jdk1.8.0_221");
	System.out.println(file);
}
/*
*File类构造,传递File类型父路径和字符串的子路径
*/
public static void method_3(){
	File parent = new File("C:\\Java");
	File file = new File(parent, "jdk1.8.0_ _221");
	System.out.println(file);
}

File类的静态成员变量

• static String separator与系统有关的默认名称分隔符 \
• static String pathSeparator与系统有关的路径分隔符 ；一个路径结束

File类的创建

boolean createNewFile()创建新文件，创建成功返回true，文件的路径和文件名，在File的构造方法中
。如果文件已经存在，不会创建，返回false

• boolean mkdirs()创建文件夹，创建成功返回true
  。如果已经存在，不会创建，返回false

public static void main(String[] args) throws IOException {
	method( ) ;
	method_2( );
}
/*
*File类方法createNewFile()创建文件
*/
public static void method() throws IOException {
	File file = new File("d:\\abc.txt");
	boolean b = file. createNewFile( );
	System. out. println(b);
}
/*
*File类方法,mkdirs()创建文件夹
*/
public static void method_2( ) {
	File file =new File("d:\\abc");
	boolean b =file . mkdirs();
	System. out. println(b);
}

File类的删除方法

• boolean delete()删除文件

public static void main(String[] args) throws IOException {
	method_ 3( );
}
public static void method_ 3( ) {
	File file = new File("d:\\1. txt");
	boolean b=file.delete();
	System. out. println(b);
}

File类的判断方法

boolean exists()判断File构造方法中的路径，是否真的存在，存在返回true
boolean isDirectory()判断File构造方法中的路径，是不是一个目录(文件夹)，是目录返回true
boolean isFile()判断File构造方法中的路径，是不是一个文件，是文件返回true

public Istatic void main(String[] args) {
	method( );
	method_2( );
}
/*
*File类方法,判断路径是否存在exists()
*/
public static void method( ) {
	File file = new File("d:\\springboot_ initializr.jar");
	boolean b=file.exists();
	System. out. println(b);
}
/*
*File类方法，判断路径是文件,还是文件夹
*isDirectory() isFile()
*/
public static void method_2( ) {
	File file = new File("d:\\driver");
	if(file.exists()) {
		boolean b = file. isDirectory();
		System. out . println(b);
		b = file. isFile();
		System. out . println(b);
	}
}

File类的获取

• String getName()返回File构造方法中，路径的名字，可能是文件名，也可能是文件夹名
• String getPath()返回路径名的字符串形式
• File getAbsoluteFile()返回路径的绝对路径,返回值是File对象
• File getParentFile()返回指定路径的父路径，返回值是File对象

public static void main(String[] args) {
	method( );
	method_2();
	method_3();
	method_4();
}
/*
*File类获取方法,getName()获取名字
*/
public static void method( ) {
	File file = new File("C:\\Java\\jdk1.8.0_221\\bin");
	String name = file. getName( );
	System. out . println(name) ;
	file = new File("C:\\Java\\jdk1.8.0_221\\bin\\javac. exe");
	String name = file. getName( );
	System. out . println(name) ;
}
/*
*File类获取方法, getPath()获取路径名的字符串形态
*/
public static void method_2() {
	File file = new File("C:\\Java\\jdk1.8.0_ 221", "bin");
	String path = file. getPath();
	System. out . println(path) ;
}
/*
*File类获取方法，getAbsoluteFile() 获取绝对路径
*eclipse环境，获取的绝对路径，是当前工程的路径
*/
public static void method_3() {
	File file = new File("bin");
	File absoluteFile =_ file. getAbsoluteFile();
	System. out . println(absoluteFile) ;
}
/*
*File类的获取方法，getParentFile() 获取父路径的
*方法返回值,是File对象
*/
public static void method_4() {
	File file = new File("C:\\Java\\jdk1.8.0_ 221\\bin");
	//获取父路径
	File parentFile = file. getParentFile();
	System. out. println(parentFile);
	parentFile = file. getParentFile();
	System. out. println(parentFile);
}

File类的list开头方法

• long length()获取到文件的字节数
• File[] listFiles()获取构造方法中路径，里面的所有文件列表（文件夹）
  。文件夹进行遍历
• static File[] listRoots()获取当前计算机系统中的所有根目录

public static void main(String[] args) {
	method();
	method_2();
	method_3();
}
/*
*File类方法,length()文件的字节数
*/
public static void method() {
	File file = new File("C:\\Java\\jdk1.8.0_ 221\\src.zip");
	long length = file.length();
	System. out. println(length);
}
/*
*File类方法，listFiles()遍历文件夹
*/
public static void method_2() {
	File file = new File("C:\\Java\\jdk1.8.0_ 221");
	File[] files = file.listFiles( );
	for(File f : files) {
		System. out . println(f) ;
	}
}
/*
 * File类方法,listRoots(()静态
 */
public static void method_3() {
	File[] files=File.listRoots();
	for(File f:files) {
		System.out.println(f);
	   }
}

文件过滤器

需求：目录d：/abc里面有多个文件，File类的方法listFiles()获取abc目录下面的文件，只要.java文件，其他类型的文件不获取

• java.io.FileFilter接口，文件过滤器接口，对获取的文件进行过滤
  。此接口的实现类，可以传递给方法listFiles()
  。抽象方法boolean accept(File f)自定义实现类
• File[] listFiles(FileFilter filter)传递文件过滤器的接口

public static void main(String[] args) {
	File file = new File("d:/abc");
	//遍历abc目录,方法传递文件过滤器实现类对象
	File[] files = file.listFiles( new MyFilter() );
	for(File f : files) {
		System. out . println(f);
	}
}

//定义文件过滤接口的实现类
class MyFilter implements FileFilter{
	public boolean accept(File pathname) {
		//判断pathname路径,表示的文件,是不是.java文件
		//文件的后缀名是不是.javal String类方法endsWith  忽略大小写
		return pathname . getName( ). toLowerCase() .endsWith(" . java"); 
	}
}

目录全遍历

在遍历一个目录的时候，如果发现还有子目录,进去继续遍历
方法自己调用自己进行的遍历

public static void main(String[ ] args) {
	iteratorDir(new File("d:/abc"));
}
/*
*目录的遍历:遍历哪个目录,传递参数
*/
public static void iteratorDir(File dir) {
	System . out . println(dir);
	//File对象方法listFiles()目录里的遍历
	File[] files = dir .listFiles();
	for(File f : files) {
		//判断，如果f还是目录
		if(f . isDirectory()) {
			//继续遍历iteratorDir()就是接收目录 ,遍历目录
			//再定义相同代码的方法，没有必要，自己调用我自己
			iteratorDir(f);
		}else {
			System . out . println(f);
		}
	}
}

IO流对象

I：Input 输入
O：Output 输出
流对象:数据流,数据从一一个设备流到另-个设备
例子:文档从硬盘中，流入到内存中，文档从内存中，流入到硬盘中
文档从硬盘中,流入到移动硬盘.
可以从一台机器,流到另一台机器

一切都是字节

任何数据，在文件中的形态，都是字节(文本，图片，音乐，游戏)，互联网的传输，下载文件，网盘

IO流的分类

• 按照数据的流向分
  。输入流 Input
  。输出流 Output
• 按照操作的数据类型分
  。字节流 字节流可以操作任意类型的数据
  。字符流 字符流只能操作文本类型数据
  ■什么是文本类型数据：使用文本公具(记事本，Notepad++，EdiPlus)打开后，人可以直接阅读的
• 分类的合并
  。字节输出流
  ■顶层的抽象父类：java.io.OutputStream
  。字节输入流
  ■顶层的抽象基类: java. io. Inputstream
  。字符输出流
  ■顶层的抽象基类: java. i0. writer
  。字符输入流
  ■顶层的抽象基类:java. io. Reader

字节输出流

可以操作任意类型数据，从java的程序中，输出Output，又称为写入
OutStream类的方法:都是写入数据的方法write

• void write(int b)写入单个字节
• void write(byte[] b)写入字节数组
• void write(byte[] b,int off,int len)写入字节数组的一部分，开始索引，写入个数
• close()关闭此流，释放资源

OutputStream类的子类

IO流对象的命名非常的有可读性前缀+后缀
前缀: 这个流能干什么时期
后缀: 这个流属于哪个分类
子类FileOutputStream：

• 构造方法
  。FileOutputStream(String name)传递字符串的文件名(数据目的)
  。FileOutputStream(File file)传递File类型的文件
  IO流对象，write方法，没有实现写入功能，调用操作系统的功能，实现的写入，释放操作系统的资源

/*
*I0流,写入文件的数据
*字节输出流的子类File0utputStream
*流对象的使用公共步骤:
*1:创建流对象
*2:调用流对象的方法，读取,写
*3:释放资源
*/
public static void main(String[] args) throws IOException{
	method();
	method_2();
	method_3();
}
/*
*File0utputStream写入单个字节
*/
public static void method() throws IOException {
	//创建流对象,构造方法绑定数据目的
	FileOutputStream fos = new FileOutputStream("d:/1.txt");
	//流对象的方法write写入数据
	fos. write(100);
	//释放资源
	fos.close();
}
/*
*File0utpdtStream写入字节数组
*/
public static void method_2() throws IOException{
	//创建流对象,构造方法绑定数据目的
	File0utputStream fos = new File0utputStream("d:/1. txt");
	//创建字节数组
	byte[] bytes=" abcdefg".getBytes();
	//字节流,写入字节数组
	fos . write(bytes);
	//释放资源
	fos.close();
}
public static void method_3() throws IOException{
	//创建流对象,构造方法绑定数据目的
	File0utputStream fos = new File0utputStream("d:/1. txt");
	//创建字节数组
	byte[] bytes=" abcdefg".getBytes();
	//字节流,写入字节数组的一部分
	//开始索引，写入个数
	fos . write(bytes,3,2);
	//释放资源
	fos.close();
}

文件的追加写入和换行

• Fileoutputstream(String name,boolean append)第二个参数传递是true,追加写入
• 换行写，需要使用换行符\r\n

public static void main(String[] args) throws IOException{
	method_4();	
	method_5();
}
/*
*File0utputStream追加写入,文件的续写
*/
public static void method_4() throws IOException {
	FileOutputStream fos = new FileOutputStream("d:/a. txt" , true);
	fos . write(122);
	fos. close();
}
/*
*File0utputStream追加写入,换行写
*上一行末尾，下一行开头也可以
*\r\n
*/
public static void method_5() throws IOException {
	FileOutputStream fos = new FileOutputStream("d:/a. txt");
	fos . write(" abc\r\n" . getBytes());
	fos . write(" xyz" . getBytes());
	fos.close();
}

/*
*I0流对象的异常处理:标准写法
*资源释放，写在finally 无论文件是否写入成功，资源必须释放
*try外定义变量，try内创建对象(提升变量的作用域)
*/
public static void main(String[] args) {
	FileOutputStream fos = nu11 ;
	//File0utputStream fos1 = null;
	try {
		fos = new File0utputStream("a. txt");
		//fos1 = new FileOutputStream("a1 . txt");
		fos . write(97);
	}catch( IOException ex) {
		ex. printStackTrace( );
	}finally{
		if(fos!=null)
		try {
				fos.close();
		}catch( IOException ex) {
			ex. printStackTrace();
		}
		/*
		* try { fos1. close(); }catch(IOException ex) { ex. printStackTrace(); 
		*/
	}
	name();
}
public static void name() {
	try (File0utputStream fos = new File0utputStream( "b:/a.txt") ;
	File0utputStream fos2 = new File0utputStream(""){
	fos . write(97);
	}catch( IOException ex) {
	ex. printStackTrace( );
	}
}

字节输入流

可以操作任意类型数据，从其他的设备中,将数据读取到ava程序
InputStream类的方法:都是读取数据的方法read

• int read()读取单个字节，返回读取到的字节，当读取到流的末尾，返回-1
• int read(byte[] b)读取字节，存储到数组，读取到流的末尾返回-1
• close()关闭此流，释放资源

InputStream类的子类

子类FileInputStream：

• 构造方法
  。FileInputStream(String name)传递字符串的文件名（数据源）
  。FileInputStream(File file)传递File类型的文件

/*
*字节输入流，FileInputStream读取文件
*读取单个字节方法read()
*/
public static void main(String[] args )throws IOException{
	//创建字节输入流对象,构造方法中,绑定数据源文件
	FileInputStream fis = new FileInputStream("a.txt");
	//读取单个字节方法read()
	int i = fis.read();
	fis. close();
}

public static void main(String[] args )throws IOException{
	//创建字 节输入流对象,构造方法中,绑定数据源文件
	FileInputStream fis = new FileInputStream("a. txt" );
	//读取单个字节方法read()
	//read()读取结束,返回-1
	int i = 0; //接收read()方法的返 回值
	while( (i = fis.read())!=-1 ) {
		System.out.print((char)i)
	}
	fis. close();
}

/*
*字节输入流，FileInputStream读取文件
*读取字节数组方法read(byte[] b)
*/
public static void main(String[] args) throws IOException{
	//创建字节输入流对象,绑定数据源
	FileInputStream fis = new FileInputStream("a.txt" );
	//定义字节数组
	byte[] bytes = new byte[2];
	int i = fis.read(bytes);
	System. out. println(i);
	System. out . println(new String(bytes)) ;
	fis.close();
}

public static void main(String[] args) throws IOException{
	//创建字节输入流对象,绑定数据源
	FileInputStream fis = new FileInputStream("a. txt");
	//定义字节数组,长度推荐写1024整数倍1KB
	byte[] bytes = new byte[1024] ;
	int i =0; //接收read()方法返回值
	while ( (i = fis. read(bytes)) != -1 ) {
		/*
		* String类构造方法,传递字节数组,转成字符串,查询编码表
		*构造方法,还可以传递参数new String(byte[] b，开始索引，转几个)
		*/
		System. out . print(new String(bytes ,0,i));
	}
	fis. close();
}

字节输入流读取中文问题

字节输入流,读取汉字(读不了)

/*
*字节输入流,读取汉字(读不了)
*/
public static void main(String[] args) throws IOException{
	FileInputStream fis = new FileInputStream("b. txt");
	byte[] bytes = new byte[1024];
	int i=0;
	while( (i = fis.read(bytes)) !=-1) {
	System. out . print(new String(bytes,0,i));
	}
	fis. close();
}

字节流：文件赋值copy

数据源: d:/springboot_initializr.jar
数据目的: e: /springboot_initialzr.jar

• 读取一个字节，写入一个字节
• 读取一个自己数组，写入一个字节数组

pub1t.c static void main(String[] args) {
	copy_1();
	copy_2();
}
/*
*复制文件:读写单个字节
*/
public static void copy_1() throws IOException{
	//字节输入流,绑定数据源
	FileInputStream fis = new FileInputStream( " d:/springboot_initializr . jar");
	//字节输出流,绑定数据目的
	File0utputStream fos = new File0utputStream( " e:/springboot_initializr.jar");
	//fis读取一个字节，fos写入一个字节
	int i =0;
	while( (i = fis.read()) !=-1) {
		fos . write(i);
	}
	fos. close();
	fis.close() ;
}
/*
*复制文件:读写字节数组
*提升效率.
*/
public static void copy_2() throws IOException{
	//字节输入流,绑定数据源
	FileInputStream fis = new FileInputStream( " d:/springboot_initializr . jar");
	//字节输出流,绑定数据目的
	File0utputStream fos = new File0utputStream( " e:/springboot_initializr.jar");
	//fis读取一个字节数组，fos写入一个字节数组
	byte[] bytes = new byte [1024];
	int i =0;
	while( (i = fis.read(bytes)) !=-1) {
		fos . write(bytes,0,i);
	}
	fos. close();
	fis.close() ;
}