Java基础之IO流(八)

JavaIO流!

File类：//文件和文件夹路径的抽象表示形式

​ java.io.File;
​ file:文件
​ directory:文件夹/目录
​ path:路径
​ 方法:
​ 静态方法：
​ static String pathSeparator//路径分割符 字符串 ;
​ static char pathSeparatorchar
​ //windows: ; \ linux: : /
​ static String separator//名称分隔符 字符串
​ static char separatorchar
​ “+File.separator+” 来分开分割//Linux和Windows系统不同
​ 构造方法：
​ File(String Pathname);//
​ File(String parent,String child)//子路径和父路径
​ file（file parent,String child）//父路径可以使用file的方法
​ 获取方法：
​ public String getAbsolutePath();//文件绝对路径
​ public String getPath();//转换为路径字符串
​ public String getname();//返回文件或者目录名称结尾文件
​ public long length();//返回文件大小
​ 判断方法：
​ public boolean exists();//文件和目录是否实际存在
​ public boolean isDirectory();//是否为目录
​ public boolean isFile();//判断file表示的是否为文件
​ 创建和删除方法：
​ public Boolean createNewFile();//创建一个空文件
​ public Boolean delete();//删除文件文件夹
​ public Boolean mkdir();//创建文件夹单级文件夹一个文件夹
​ public Boolean mkdirs();//创建文件夹单级文件夹多级文件夹
​ 目录遍历：//构造方法给出的目录
​ public String[] list();//增强for循环来遍历只打印文件名称
​ public File[] listFiles();//打印路径和文件
递归：
​ 直接递归和间接递归：
​ 自己调用自己方法；
​ 构造方法不能递归
过滤器：
​ java.io.filefilter;
​ File[] listfile（filefilter filter）；//过滤文件
​ boolean accept(file pathname);//
​ File[] listfile（filefilter filter）；//
​ boolean accept(File dir,String name);//
​ 过滤器接口没有实现类，需要我们来实现；
​ pathname.getname().tolowerCase().endswith("");//过滤掉结尾的文件
​ ((file dir,string name)->{return})
io流：
​ 字节流：
​ 入：inputStream:
​ 出：outputStream:
​ 字符流：
​ 入：Reader:
​ 出：Writer:
​ 字节流：//一切皆为字节
​ java.io.OutputStream;//最顶层的io**都可以用抽象类
​ public void close();//关闭
​ public void flush();//
​ public void write(bytr[] b);//多个字节
​ public void write(byte[] b,int off/开始index/,int len/长度/);//多个字节字节数组的一部分写到文件
​ public abstract void write(int b);//一次写一个字节
​ 写字符串:byte[] getBytes();//字符串转化为字节数组String方法
​ 追加写/续写：
​ FileOutputStream(String name,boolean append）；
​ FileOutputStream(File file,boolean append）；
​ 换行：window：\r\n linux:/n
​ java.io.FileOutputStream;
​ 构造：
​ FileOutputStream(String name);//目的地的文件路径
​ FileOutputStream(File file);//目的地是一个文件
​ 使用步骤：
​ 1.创建一个对象，目的地
​ 2.调用方法写入文件；
​ 3.释放资源
​ 字节输入流：//读完返回-1
​ java.io.InputStream;//同上
​ java.io.FileInputStream;//文件读取
​ int read(b);//从输入流中读取数据的洗一个字节
​ int read(byte[] b);//一次读取多个字节
​ 构造;
​ FileInputStream(String name）；//文件路径
​ FileInputStream(File file);//文件
​ String类的构造方法:
​ String(byte[] bytes);//把字节数组转化为字符串
​ String(byte[] bytes,int offset,int length);//把数组中一部分转化为字符串，offset为开始索引
​ 循环读取：
​ int len=0;
​ while((len=fis.read())!=-1){
​ System.out.println();
​ }
​

字符流：
java.io.Reader;//字符输入流  最顶层   抽象类
	int read();//读取一个字符
	int read(char[] cbuf);//读取放进一个数组
java.io.FileReader;//子类 InputStreamReader/Reader继承这俩
	FileReader(String fileName);//文件路径
	FileReader(File file);//一个文件
步骤：
	1.创建对象
	2.读取文件
	3.释放对象
java.io.Writer;//抽象类 字符输出流 最顶层的
	void write(int n);//
	void write(char[] ch);
	abstract void write(char[] ch,int off,int len);
	void write(String str);
	void write(String str,int off,int len);
	void flush();//刷新该流缓存
	void close();//关闭资源
java.io.FileWriter;//outputStreamWriter/Writer  继承关系
	构造：
		FileWriter(File file);//文件的路径
		FileWriter(String filename);//一个文件
	步骤:
		1.创建对象
		FileWriter fw=new FileWriter("c://");
		2.方法把数据写入到内存缓存区
		fw.write(97);
		char[] cs={'1','2'};
		fw.write(cs);
		fw.write(cs,1,3);
		fw.write("zheshiyigezhu");
		fw,write("zheshishu",2,3);
		3.使用flush刷新到文件中
		fw.flush();
		4.释放资源；
		fw.close();
	close和flush区别：
		close:先刷新流，再释放资源，不能再使用流
		flush:刷新缓冲区，还能继续使用流
	续写：
		FileWriter(string fileName,boolean append);//续写，路径 boolean
		FileWriter(File file,boolean append);//文件目的地
	io流异常：
		jdk1.7之前:try{}catch(e){}finally{};
		jdk1.7开始：try(定义流对像...){}catch{};
		jdk9:try前面可以定义流对象，再（）直接引用流对象；
			A a=New A();
			try(A){}catch(){};

Properties:属性集合：双列表，v,k
	java.util.Properties;//extends Hashtable<k.v>implements map<k,v>	
		store();//临时数据持久写到硬盘
		load();//读取到集合中使用
	object setProperty(String key,String value);//添加数据
	String GetProperty(String key);//获取key的数据
	stringPropertyNames//存储到一个set集合，然后遍历
	set<String> stringPropertyNames();//
		void store(outputStream out,String comments);
		void store(Writer writer,String comments);
	步骤：
		1.创建集合对象，添加数据
		properties prop=new properties();
		prop.setProperty(k,v);
		2.创建流对象，构造方法输出的目的地
		FilWriter fw=new FileWriter();
		3.使用store把集合中临时数据持久写到硬盘中
		prop.store（fw,date）
		4.释放资源
		fw.close();
	读取：
		void load(InputStream inStream);
		void load(Reader reader);
		1.创建对象
		2.读取一个字符
		3.遍历

缓存流：//加强流buffersdIputStream(); 其父类为OutputStream
字节：BufferediPutStream()
BufferedOutputStream()
字符：BufferedReader()
BufferedWriter()
构造:
BufferedOutputStream(outputStream out);//字节输出流
BufferedOutputStream(outputStream out,int size);//int size 缓存大小
步骤：
1.创建FileOutputStream对象，绑定输出目的地；
FileInputStream fis=new FileOutputStream(目的地);
2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高效率；
BufferedOutputStream bos=new BufferedOutputStream(fos);
3.使用BufferedOutputStream对象方法write方法写进缓存区
bos.write(string);
4.使用BufferedOutputStream对象方法flush,刷新到文件中
bos.flush();
5.释放资源
bos.close();
BufferedInputStream();//读取
BufferedInPutStream(InputStream in);
BufferedInPutStream(InputStream in,int size);
步骤：
1.创建对象
FileInputStream fis=new FileInputStream();
2.传递对象
bufferedInoutStream bis=new bufferedInoutStream(fis);
3.方法来读
循环来读取
4.释放资源
fis.close();
//记录时间 long time=System.currentTimeMillis();
字符缓存流：
public BufferedWriter(Reader in);//写
bufferedWiter(Writer out);
bufferedWiter(Writer out,int size);//newLine();换行
public BufferedReader();//读
BufferedReader(Reader in);
BufferedReader(Reader in,int size);
成员方法;
String readLine();//读取一行数据换行没有为空
转化流：//桥梁
java.io.InputStreamReader;//读取
构造：
InputStreamReader(InputStream in);
InputStreamReader(InputStream in,String charsetName);
步骤：
1.创建对象
2.readr方法读取
3.释放资源

java.io.OutputStreamWriter;//Wrier继承
	构造：	
		OutputStreamWriter(outputStream out);
		OutputStreamWriter(outputStream out,String charsetname);
	步骤：
		1.创建outputStreamWriter对象，
		OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream(地址，utf-8)）;
		2.使用方法writer;
		osw.write("nihao");
		3.flush刷新到内存
		osw.flush();
		4.资源释放；
		osw.close();序列化和反序列化：//对象的写和读  静态不能序列化
	java.io.objectOutputStream;//对象以流的方式来写进去
		构造：
			objectOutputStream(outputStream out);//字节输出流
		方法：
			void writeobject(object obj);
		步骤：//需要把对象的类实现java.io.Serializable;
			1.创建objectOutputStream对象，构造方法中传递字节输出流；
				objectOutputStream oos=new objectOutputStream(new FileOutputStream(dizhi));
			2.使用方法把对象写进去；
			oos.writeobject(new person(1.2));
			3.释放资源
			oos.close();
	java.io.objectInputStream;//
		构造：
			objectInputStream(InputStream in);
		方法：
			object readobject();
		步骤：
			1.创建对象
			objectInputStream ois=new objectInputStream(new FileInputStream(dizi));
			2.读取一个字符
			object o=ois.readobject();
			3.释放资源；
			ois.close();
			4.打印一下
			system.out.println();
		前提：
		1.实现接口
		2.必须存在类对应的class文件
	  transient:瞬态关键字//不想序列化
		被修饰的成员变量不能序列化；
		序列号：
			static final long 
打印流：
	java.io.printStream;//继承outputStream
		print();
		println();
	构造：
		printStream(*);
		*；File file/OutputStream out/String filename
		注意：
			父类的write写数据，就会查询编码表97->a
			自己的方法就会原样打印//print（）
	改变打印流的目的地：
		static void setOut(printStream out);