mixpplus
11/18/2019 - 7:03 AM

io笔记


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);