java学习-day13-IO(一) File文件流-字节输入流-字符输入流

数据读写
字节流: 针对二进制文件
抽象父类: InputStream 实现子类: FileInputStream BufferedInputStream ObjectInputStream
抽象父类: OutputStream 实现子类: FileOutputStream BufferedOutputStream ObjectOutputStream
字符流: 针对文本文件(读写易乱码,建议指定编码集为 utf-8)
抽象父类: Writer 实现子类: BufferedWriter OutputStreamWriter
抽象父类: Reader 实现子类: BufferedReader InputStreamReader PrintWriter/PrintStream

File文件流

创建方式:

File(String pathname)

常用方法:

文件,文件夹属性

length();            

文件的字节量

exists();        

文件是否存在,存在返回true

isFile();        

是否为文件,是返回true

isDirectory();    

是否为文件夹,是文件夹返回true

getName();        

获取文件/文件夹名

getParent();    

获取父文件夹的路径

getAbsolutePath();

获取文件的完整路径

创建,删除

creatNewFile();  

新建文件，文件夹不存在会异常，文件已经存在返回false

mkdir();      

新建单层不存在的文件夹\a

mkdirs();    

新建多层不存在的文件夹\a\b\c

delete();  

删除文件，删除空文件夹

文件夹列表

list();     

返回String[]，包含文件名

listFiles(); 

返回File[]，包含文件对象

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
public class Test1 {
	public static void main(String[] args) throws IOException {
		//1、创建对象-- 参数是路径，可以是文件的/文件夹的/不存在的
		File file = new File("C:\\Users\\Administrator\\Desktop\\test\\1.txt");//这是一个文件路径
		//2、常用方法
		System.out.println(  file.length()  );//获取文件的字节量
		System.out.println(  file.exists()  );//判断文件是否存在
		System.out.println(  file.isFile()  );//判断file是文件吗
		System.out.println(  file.isDirectory()  );//判断file是文件夹吗
		System.out.println(  file.getName()  );//获取文件名
		System.out.println(  file.getParent()  );//获取父目录
		System.out.println(  file.getAbsolutePath()  );//获取完整路径
		file = new File("C:\\Users\\Administrator\\Desktop\\test\\2.txt");//不存在的文件
		System.out.println(  file.createNewFile()  );//创建不存在的文件返回true，如果存在返回false
		file = new File("D:\\iotest\\b");//单层不存在的文件夹
		System.out.println(  file.mkdir()  );//创建单层不存在的文件夹
		file = new File("D:\\iotest\\m\\n\\o");//多层不存在的文件夹
		System.out.println(  file.mkdirs()  );//创建多层不存在的文件夹
		file = new File("D:\\iotest\\m\\n\\o\\1.txt");
		System.out.println(  file.delete()  );//删除文件   或者  删除 空的 文件夹
		//列表方法--列出文件夹里的资源
		file = new File("D:\\iotest");
		String[] strs = file.list();//列出文件的名称放入数组
		System.out.println(Arrays.toString(strs));
		File[] files = file.listFiles();//列出文件并封装成file对象放入数组
		System.out.println(Arrays.toString(files));
	}
}

递归求目录总大小

import java.io.File;
import java.util.Scanner;
//这个类用来测试 递归求目录总大小  
/*
 * 1、列出文件夹下的所有资源
 * 2、判断当前的资源是文件吗？如果是文件直接length()求字节量的和  
 * 3、判断当前的资源是文件夹吗？如果是文件夹  --  重复的干1 2 3的事情
 */
public class Test2_File2 {
	public static void main(String[] args) {
		//接收用户输入的目录  的路径
		String path = new Scanner(System.in).nextLine();
		//把路径封装成file对象
		File dir = new File(path);
		//调用size() ---求大小
		long total = size(dir);
		System.out.println(total);
	}
	//求大小
	public static long size(File dir) {
		//1、列出文件夹下的所有资源
		File[] a = dir.listFiles();
		//获取每个资源
		long sum = 0 ;//定义变量，记录和
		for (int i = 0; i < a.length; i++) {
			//2、判断当前的资源是文件吗？如果是文件直接length()求字节量的和  
			//循环中，想要获取每个资源 a[i]
			if(  a[i].isFile()  ){
				sum = sum + a[i].length() ;//每个文件的长度相加求和
			}else if( a[i].isDirectory() ) {
				//	3、判断当前的资源是文件夹吗？如果是文件夹  --  重复的干1 2 3的事情
				sum = sum + size( a[i] ) ; //递归调用  size()   求目前资源a[i]的大小
			}
		}
		return sum;//把最终记录的和  返回给  调用位置
	}
}

字节流读取

InputStream

是字节流 读取流的父类 。是抽象类，不能创建对象，只能学习共性方法。
常用方法:

void close(); 

关闭此输入流并释放与该流关联的所有系统资源。

abstract int read();  

从输入流中读取数据的下一个字节。

int read(byte[] b); 

从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中

int read(byte[] b, int off, int len); 

将输入流中最多 len 个数据字节读入 byte 数组

FileInputStream

子类.
创建对象:

FileInputStream(File file)
FileInputStream(String name)

BufferedInputStream

子类.
创建对象:

BufferedInputStream(InputStream in)

缓冲的输出流,缓冲区默认 8k 的 byte[]

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
//这个类用来测试字节流   读取
//总结：
//字节流的读取：普通流FileInputStream和高效流BufferedInputStream
//效率上来讲：BufferedInputStream  >  FileInputStream
//原因：BufferedInputStream底层维护了一个数组，把数组读满了直接给程序一次就行，减少交互提高效率
public class Test3 {
	public static void main(String[] args) {
//		method();//方法调用，用普通子类FileInputStream
		method2();//用高效子类BufferedInputStream
	}
	private static void method2() {
		try {
			//1，创建字节读取流对象  
			InputStream in = new BufferedInputStream( new FileInputStream("D:\\iotest\\1.txt") ) ;//构造方法需要InputStream类型的参数，没有就new
			//2、开始读取
			int b = 0 ;//定义变量，记录读取到的数据
			while(   ( b  = in.read()  )  !=  - 1  ) {
				System.out.println(b);
			}
			//3、释放资源
			in.close();
		} catch (IOException e) {//捕获一个大点的异常，io操作中最大的就是IOException
			e.printStackTrace();
		}
	}
	public static void method() {
		try {
			//1，创建字节读取流对象
			InputStream in = new FileInputStream(new File("D:\\iotest\\1.txt")  );//触发FileInputStream(File) 构造方法
			InputStream in2 = new FileInputStream("D:\\iotest\\1.txt");//触发FileInputStream(String) 构造方法
			//2、调用父类的功能，开始读取
//			 System.out.println(  in.read()  ); //从输入流中读取数据的下一个字节
//			 System.out.println(  in.read()  ); 
//			 System.out.println(  in.read()  ); 
//			 //3、当读取到没有数据了的到时候，read()返回-1
//			 System.out.println(  in.read()  ); 
			//读取的代码改造
			int b = 0 ; //定义变量，记录读取到的数据
			while(  (  b = in.read()  )  !=  -1 ) {//有数据才读，没数据时read()返回-1时就不读了 
				System.out.println(b);
			}
			 //4、释放资源
			 in.close();
			 in2.close();
		} catch (IOException e) {//捕获一个大的异常
			e.printStackTrace();
		}
	}
}

字符流读取

只能读取字符文件, txt

Reader

是字符流读取流的父类。是抽象类，不能创建对象，所以只能学共性方法。
常用方法:

abstract  void close()  

关闭该流并释放与之关联的所有资源。

int read()  

读取单个字符

int read(char[] cbuf) 

将字符读入数组

abstract int read(char[] cbuf, int off, int len) 

将字符读入数组的某一部分

int read(CharBuffer target)  

试图将字符读入指定的字符缓冲区

FileReader

创建对象:

FileReader(File file)
FileReader(String fileName) 

BufferedReader

创建对象:

BufferedReader(Reader in)

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
//这个类用来测试  字符 读取流
//总结：
//字符读取流：普通对象读取FileReader，高效对象读取BufferedReader
//效率来讲：BufferedReader  > FileReader
//原因：BufferedReader底层也维护了一个char[](默认容量是8K)，读取时满了一个数组给程序一次，减少交互提高效率
public class Test4 {
	public static void main(String[] args) {
		method();//普通读取流FileReader
		method2();//高效读取流BufferedReader
	}
	private static void method2() {
		try {
			//1，创建对象
			Reader in = new BufferedReader(new FileReader("D:\\iotest\\1.txt"));
			//2，开始读取
			int b = 0;//定义变量，记录每次读取到的数据
			while( ( b = in.read()  )    !=  -1 ) {
				System.out.println(b);
			}
			//3，释放资源
			in.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	//普通读取流
	public static void method() {
		try {
			//1，创建对象
			Reader in = new FileReader("D:\\iotest\\1.txt");//触发FileReader(String)构造方法
			Reader in2 = new FileReader( new File("D:\\iotest\\1.txt") );//触发FileReader(File)构造方法
			//2，开始读取
//			System.out.println( in.read() );
//			System.out.println( in.read() );
//			System.out.println( in.read() );
//			//read()读到最后，没有数据时会永远返回-1
//			System.out.println( in.read() );
//			System.out.println( in.read() );
//			System.out.println( in.read() );
			//改造读取代码
			int b = 0;//定义变量，记录每次读取到的数据
			while( ( b = in.read()  )    !=  -1 ) {
				System.out.println(b);
			}
			//3，释放资源
			in.close();
			in2.close();
		} catch (IOException e) {// 捕获大异常
			e.printStackTrace();
		}
	}	
}

字节流写出

OutputStream

字节输出流的父类。抽象类，不能创建对象，只能学习共性方法
共性方法:

void close() 

关闭此输出流并释放与此流有关的所有系统资源

void flush()   

刷新此输出流并强制写出所有缓冲的输出字节

void write(byte[] b)   

将 b.length 个字节从指定的 byte 数组写入此输出

void write(byte[] b, int off, int len)   

将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

abstract  void write(int b)  

将指定的字节写入此输出流

FileOutputStream

子类 使用了父类的共性方法，只要学习创建对象
创建对象

FileOutputStream(File file) 
FileOutputStream(File file, boolean append) 
FileOutputStream(String name) 
FileOutputStream(String name, boolean append) 

BufferedOutputStream

子类 使用了父类的共性方法，只要学习创建对象
创建对象

BufferedOutputStream(OutputStream out)

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
//这个类用来测试  字节输出流
public class Test5 {
	public static void main(String[] args) {
		method();//普通输出流
	}
	private static void method() {
	OutputStream out = null;
	OutputStream out2 = null;
		try {
			//1，创建对象
			out  = new FileOutputStream("D:\\iotest\\1.txt");//默认是数据覆盖模式
			out2  = new FileOutputStream(  new File("D:\\iotest\\1.txt",true) );//是数据追加模式
			//2，开始写出
			out.write(97);
		} catch (IOException e) {//捕获大异常
			e.printStackTrace();
		}finally{
			try {
				//3，释放资源
				out.close();
				out2.close();
				} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}