Cacher is the code snippet organizer for pro developers

File: 文件操作类

文件基本信息：

//文件或目录是否存在
public boolean exists()

//是否为目录
public boolean isDirectory() 

//是否为文件
public boolean isFile()

//文件长度，字节数 目录长度为0
public long length()

//最后修改时间，从纪元时开始的毫秒数
public long lastModified()

//设置最后修改时间，设置成功返回true，否则返回false
public boolean setLastModified(long time)

// 获取包含绝对路径地址的文件对象
File getAbsoluteFile() 

// 获取该文件绝对地址；
String getAbsolutePath() 

//获取该文件对象的文件名，如果是目录就是最后一层目录名；
String getName() 

// 获取父级路径的字符串表现形式，如果是相对路径，如"." 获取父级路径时会返回null
String getParent() 


//返回该文件对象父级路径所代表的文件对象，如果此路径名不指定父目录，则返回 null 
File getParentFile() 

//获取该文件对象的路径，绝对地址就输出绝对地址，相对路径就输出相对路径；
String getPath() 





文件安全和权限信息：

//是否为隐藏文件
public boolean isHidden()

//是否可执行
public boolean canExecute()
 
//是否可读
public boolean canRead()

//是否可写
public boolean canWrite()

//设置文件为只读文件
public boolean setReadOnly()

//修改文件读权限
public boolean setReadable(boolean readable, boolean ownerOnly)
public boolean setReadable(boolean readable)

//修改文件写权限
public boolean setWritable(boolean writable, boolean ownerOnly)
public boolean setWritable(boolean writable)

//修改文件可执行权限
public boolean setExecutable(boolean executable, boolean ownerOnly)
public boolean setExecutable(boolean executable)

//测试这个抽象路径名是否是绝对的 
boolean isAbsolute() 


文件操作:

/*创建*/
public boolean createNewFile() throws IOException 
//创建临时文件,prefix是必须的,且至少要三个字符,suffix为null后缀为.tmp
public static File createTempFile(String prefix, String suffix) throws IOException
public static File createTempFile(String prefix, String suffix, File directory) throws IOException

/*删除*/
//删除文件或目录,成功返回true,否则返回false。
//删除目录时，目录应为空
public boolean delete()

//将文件放入待删目录，java虚拟机退出时进行删除。钩子函数
public void deleteOnExit()

/*重命名*/
public boolean renameTo(File dest)




目录操作：

/*创建*/
//不会创建中间目录
public boolean mkdir() 
//会创建中间目录
public boolean mkdirs()

/*遍历*/
//返回的是文件名
public String[] list()
public String[] list(FilenameFilter filter)

//返回File对象
public File[] listFiles()

//FileFilter、FilenameFilter接口的accept函数返回true时才返回文件名或文件对象。
public File[] listFiles(FileFilter filter)
public File[] listFiles(FilenameFilter filter)




IO流：


IO流的分类
 根据处理数据类型的不同分为：字符流和字节流
 根据数据流向不同分为：输入流和输出流
 
字符流和字节流
字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：
 读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
 处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。


Java IO流对象

1.输入字节流InputStreamIO 

	1. InputStream 是所有的输入字节流的父类，它是一个抽象类。 
	该类中含有一个public long transferTo(OutputStream out) throws IOException
	该方法可以从该输入流中读取所有字节，并按读取的顺序将字节写入给定的输出流
	
	2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，
		它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据，
		与Piped 相关的知识后续单独介绍。
		
	3. ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。
 
2.输出字节流OutputStream
	1. OutputStream 是所有的输出字节流的父类，它是一个抽象类。
	
	2. ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。
	
	3. PipedOutputStream 是向与其它线程共用的管道中写入数据.
	
	4. ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

总结：
输入流：InputStream或者Reader：从文件中读到程序中；
输出流：OutputStream或者Writer：从程序中输出到文件中；


节点流
节点流：直接与数据源相连，读入或读出。
直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。


常用的节点流
父　类 ：InputStream 、OutputStream、 Reader、 Writer

文　件 ：FileInputStream 、 FileOutputStrean 、FileReader 、FileWriter 文件进行处理的节点流

数　组 ：ByteArrayInputStream、 ByteArrayOutputStream、 CharArrayReader 、CharArrayWriter 
		 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）
		 
字符串 ：StringReader、 StringWriter 对字符串进行处理的节点流

管　道 ：PipedInputStream 、PipedOutputStream 、PipedReader 、PipedWriter 对管道进行处理的节点流。



处理流
处理流和节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。如BufferedReader.
处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。


常用的处理流
缓冲流：BufferedInputStrean 、BufferedOutputStream、 BufferedReader、 BufferedWriter 增加缓冲功能，避免频繁读写硬盘。

转换流：InputStreamReader 、OutputStreamWriter实现字节流和字符流之间的转换。

数据流： DataInputStream 、DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来。



转换流
InputStreamReader 、OutputStreamWriter 要InputStream或OutputStream作为参数，实现从字节流到字符流的转换。

构造函数：
InputStreamReader(InputStream);        //通过构造函数初始化，使用的是本系统默认的编码表GBK。
InputStreamReader(InputStream,String charSet);   //通过该构造函数初始化，可以指定编码表。
OutputStreamWriter(OutputStream);      //通过该构造函数初始化，使用的是本系统默认的编码表GBK。
OutputStreamwriter(OutputStream,String charSet);   //通过该构造函数初始化，可以指定编码表。







四大抽象类：

1、InputStream抽象类：继承自InputStream的流都是用于向程序中输入数据的，且数据的单位为字节(8位)
2、OutputStream抽象类：继承自OutputStream的流是程序用于向外输出数据的，且数据的单位为字节(8位)
3、Reader抽象类：继承自Reader的流都是用于向程序中输入数据的，且数据的单位为字符(16位)
4、Writer抽象类：继承自Writer的流是程序用于向外输出数据的，且数据的单位为字符(16位)


InputStream的基本方法：
 public abstract int read() throws IOException {}
 //从输入流中读取数据的下一个字节, 返回读到的字节值.若遇到流的末尾,返回-1
 
 public int read(byte[] b) throws IOException {}
 //从输入流中读取 b.length 个字节的数据并存储到缓冲区数组b中.返回的是实际读到的字节总数
 
 public int read(byte[] b, int off, int len) throws IOException {}
 //读取 len 个字节的数据,并从数组b的off位置开始写入到这个数组中
 
 public void close() throws IOException {}
 //关闭此输入流并释放与此流关联的所有系统资源
 
 public int available() throws IOException {}
 //返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数
 
 public long skip(long n) throws IOException {}
 //跳过和丢弃此输入流中数据的 n 个字节，返回实现路过的字节数。
 
 例如：
 FileInputStream fis = new FileInputStream("tempfile\\fos.txt");
		
//		System.out.println(fis.available());//可以获取与之关联的文件的字节数
		byte[] buf = new byte[fis.available()];
		//创建了一个和文件大小一样的缓冲区，刚刚好



OutputStream的基本方法：
 public abstract void write(int b) throws IOException {}
 //将指定的字节写入此输出流。
 
 public void write(byte[] b) throws IOException {}
 // 将 b.length 个字节从指定的 byte 数组写入此输出流。
 
 public void write(byte[] b, int off, int len) throws IOException {}
 //将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
 
 public void flush() throws IOException {}
 //刷新此输出流并强制写出所有缓冲的输出字节。
 
 pulbic void close() throws IOException {}
 //关闭此输出流并释放与此流有关的所有系统资源。


Reader的基本方法：
 public int read() throws IOException {}
 //读取单个字符，返回作为整数读取的字符，如果已到达流的末尾返回-1
 
 public int read(char[] cbuf) throws IOException {}
 //将字符读入数组，返回读取的字符数
 
 public abstract int read(char[] cbuf, int off, int len) throws IOException {}
 //读取 len 个字符的数据，并从数组cbuf的off位置开始写入到这个数组中
 
 public abstract void close() throws IOException {}
 //关闭该流并释放与之关联的所有资源
 
 public long skip(long n) throws IOException {}
 //跳过n个字符。
 
 public int available()  
 //还可以有多少能读到的字节数


Writer的基本方法：
 public void write(int c) throws IOException {}
 //写入单个字符
 
 public void write(char[] cbuf) throws IOException {} 
 //写入字符数组
 
 public abstract void write(char[] cbuf, int off, int len) throws IOException {} 
 //写入字符数组的某一部分
 
 public void write(String str) throws IOException {} 
 //写入字符串
 
 public void write(String str, int off, int len) throws IOException {}
 //写字符串的某一部分

 public abstract void close() throws IOException {} 
 //关闭此流，但要先刷新它
 
 public abstract void flush() throws IOException {}  
 //刷新该流的缓冲，将缓冲的数据全写到目的地



节点流之文件流：

JDK提供了4种文件流: 
FileInputStream继承自InputStream, 
FileOutputStream继承自OutputStream, 构造器 FileOutputStream(String name, boolean append) , append是否追加模式
FileReader继承自Reader, 
FileWriter继承自Writer,还提供了一个FileWriter(String fileName, boolean append) 构造方法来指定是否使用追加模式


FileReader的方法:
    1、构造方法： 
		FileReader(File file) //在给定从中读取数据的 File 的情况下创建一个新 FileReader。
        FileReader(String fileName)// 在给定从中读取数据的文件名的情况下创建一个新 FileReader。
    2、方法：
		int read() //读取单个字符
        int read(char[] cbuf) //将字符读入数组
        int read(char[] cbuf,int off, int len)//将字符读入数组的某一部分
        void close()//关闭该流并释放与之关联的所有资源。
		
FileWriter的方法:
    1、构造方法： 
		FileWriter(File file)//根据给定的 File 对象构造一个 FileWriter 对象。
        FileWriter(File file,boolean append)//根据给定的 File 对象构造一个 FileWriter 对象,写入的内容追加在上次写入内容后面。
        FileWriter(String fileName)//根据给定的文件名构造一个 FileWriter 对象。
        FileWriter(String fileName,boolean append)//根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。(追加)
    2、方法：
		void write(int c)//写入单个字符
        void write(char[] cbuf,int off,int len)//写入字符数组的一部分
        void writer(String str,int off,int len)//写入字符串的某一部分
        void flush()//刷新该流的缓冲
        void close()//关闭此流,但要先刷新它

		
		

内存流:

内存流主要用来操作内存 
ByteArrayInputStream
主要完成将内容从内存读入程序之中

ByteArrayOutputStream(byte[] toByteArray())
主要是将数据写入到内存中
输入和输出可以从文件中，也可以将设置在内存之上。 



转换流：在IO包中，实际上就是分为字节流和字符流，但是除了这两个流之外，还存在了一组字节流-字符流的转换流。
转换流用于在字节流和字符流之间转换。 
JDK提供了两种转换流： 
InputStreamReader：是Reader的子类，将输入的字节流变为字符流，即：将一个字节流的输入对象变为字符流的输入对象。
	InputStreamReader需要和InputStream“套接”，它可以将字节流中读入的字节解码成字符。 
	
OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流的输出对象。
	OutputStreamWriter需要和OutputStream“套接”，它可以将要写入字节流的字符编码成字节。 
转换步骤: 
写出数据:程序—>>字符数据—>>字符流—>>OutputStreamWriter(OutputStream)—>>字节流—>>文件 
读入数据:程序<<—字符数据<<—字符流<<—-InputStreamReader(InputStream)<<—字节流<<—文件



打印流: 
PrintStream和PrintWriter都属于输出流，分别针对字节和字符。
PrintStream和PrintWriter类都提供了一系列重载的print和println方法来输出各种类型的数据。
PrintStream和PrintWriter的输出操作不会抛出异常。System.out就是PrintStream的一个实例。

构造方法: 
	PrintStream(OutputStream out)//创建新的打印流。
	PrintStream(OutputStream out, boolean autoFlush)////创建新的打印流,自动刷新缓冲
	PrintWriter(Writer out)//创建不带自动行刷新的新 PrintWriter。
	PrintWriter(Writer out, boolean autoFlush)// 创建带自动刷新的新 PrintWriter。
	PrintWriter(OutputStream out)//根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
	PrintWriter(OutputStream out, boolean autoFlush)//通过现有的 OutputStream 创建新的 PrintWriter，带自动刷新



Object流（对象流）: 
JDK提供的ObjectOutputStream和ObjectInputStream类是用于存储和读取基本数据类型或对象的过滤流。 
用ObjectOutputStream类保存基本数据类型或对象的机制叫序列化.用ObjectInputStream类读取基本数据类型或对象的机制叫反序列化.
能被序列化的对象所对应的类必须实现java.io.Serializable这个标识性接口 或者实现Externalizable接口.

构造方法:
	public ObjectOutputStream(OutputStream out) throws IOException{}
	//创建写入指定 OutputStream 的 ObjectOutputStream。
	
    public ObjectInputStream(InputStream in) throws IOException{}
	//创建从指定 InputStream 读取的 ObjectInputStream。
	
    transient关键字: transient关键字修饰成员变量时，表示这个成员变量是不需要序列化。static修饰的成员变量也不会被序列化。
	实现了Serializable接口的类都应该生成一个private static final long serialVersionUID 序列化版本ID作为标识。


随机访问流(RandomAccessFile)

1、主要功能：主要功能是完成随机读取功能，可以读取指定位置的内容。
 
2、构造方法： 
public RandomAccessFile(File file, String mode)throws FileNotFoundException{}
//创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。

3、文件的打开模式：“r” 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。 
“rw” 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。 

4、常用方法： 
length() 
//返回此文件的长度。
 
getFilePointer() 
//返回此文件中的当前偏移量。
 
skipBytes(int)
 //尝试跳过输入的 n 个字节以丢弃跳过的字节。
 
seek(long)
 //设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
 
read(byte[] b, int off, int len) 
//将最多 len 个数据字节从此文件读入 byte 数组。 

write(byte[] b, int off, int len)
 //将 len 个字节从指定 byte 数组写入到此文件，并从偏移量 off 处开始。 
 
writeUTF(String) 
//使用 modified UTF-8 编码以与机器无关的方式将一个字符串写入该文件。
 
writeBytes(String s) 
//按字节序列将该字符串写入该文件。 

writeChars(String s) 
//按字符序列将一个字符串写入该文件。 

writeBoolean(boolean v)
 //按单字节值将 boolean 写入该文件。 
 
writeByte(int v) 
// 按单字节值将 byte 写入该文件。
 
writeChar(int v)
 //按双字节值将 char 写入该文件，先写高字节。 
 
writeInt(int v) 
// 按四个字节将 int 写入该文件，先写高字节。



查看文件编码：
System.getProperty("file.encoding")

查看字符编码：
Charset.defaultCharset()

在转换输出流中：
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("./file_demo/a.txt"), "gbk");
将字节流转换成字符流，使用指定的编码方式 gbk
System.out.println(outputStreamWriter.getEncoding());
获取转换输出流对象的编码方式；



编码转换：
先使用文本编码读取转成字符或者字符串，然后使用目标编码写入文件。


PrintStream打印流：

构造函数：
public PrintStream(OutputStream out)
使用OutputStream节点流来包装一个printStream的包装打印流

public PrintStream(OutputStream out, boolean autoFlush)
增加自动刷新标志位，默认为false，自动刷新，每当写入数据的时候会自动调用flush()方法。

public PrintStream(OutputStream out, boolean autoFlush, String encoding)
增加编码，使用指定的编码格式写入数据。



改变系统输出方向 控制台-》文本；
PrintStream ps = new PrintStream("ps.txt");
    // 设置系统的打印流流向,输出到ps.txt  
     System.setOut(ps);
    // 调用系统的打印流,ps.txt中输出97  
     System.out.println(97);