IO流知识总结
目录
7.1、java.io.OutputStreamWriter 继承Writer类
7.2、java.io.InputStreamReader 继承Reader
7.3、转换流和子类的区别OutputStreamWriter
字符—>字节———FileWriterInputStreamReader 字节—>字符———FileReader
8.1、字节缓冲输出流(java.io.BufferedOutputStream)
8.2、字节缓冲输入流(java.io.BufferedInputStream)
8.3、字符输出流缓冲区流(java.io.BufferedWriter)
8.4、字符输入流缓冲流(java.io.BufferedReader)
10.ObjectOutputStream/ObjectInputStream
11、打印流(PrintStream/PrintWriter)
1、什么是IO流？
java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。
1.1、IO流的分类
按照流的流向可以分为：输入流和输出流
- 输入流： 只能从中读取数据，而不能向其写入数据。
- 输出流：只能向其写入数据，而不能向其读取数据。
- 输入流和输出流：对输入流只能进行读操作，对输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。
按照操作单元可以为：字节流和字符流
- 字符流：顾名思义，该流只能处理字符，但处理字符速度很快
- 字节流：可以处理所有以bit为单位储存的文件，也就是说可以处理所有的文件，但是在处理字符上的速度不如字符流
1.2 字符流和字节流简单的区分与知识图
字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：
- 读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
- 处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。
2、File类(java.io.File)总结
jdk将操作系统中的文件、目录(文件夹)、路径封装成File对象
2.1、File类的构造方法
包括三种重载形式：
File file = new File(String pathname)
传递路径名:可以写到文件夹,可以写到一个文件
c:\\abc c:\\abc\\Demo.java
将路径封装File类型对象File file = new File(String parent,String child)
传递字符串父路径和字符串子路径
好处 灵活性更高,可以单独操作父路径和子路径File file = new File(File parent,String child)
传递File类型的父路径,String类型的子路径
好处:父路径是File类型,父路径可以直接调用File类的方法
关于路径可以分为：相对路径和绝对路径
绝对路径:在系统中具有唯一性
C:\\windows\\system32
http://www.itcast.cn相对路径:表示的是路径之间的相对关系
D:\\develop\\Java\\jdk1.7.0\\bin
D:\\develop\\Java\\jre7
路径之间的关系
Java 父目录D:\\develop
Java 子目录jre7 jdk1.7.0
父目录是 唯一性
子目录是 可以多个c:\\abc
c:\\abc\\jpg
c:\\abc\\Demo.javaJpg 和 Demo.java是同级关系 不管jpg是文件名还是文件夹名
2.2、File的创建功能
创建文件功能
File的创建文件功能
File file =new File("/Users/fatah/Desktop/abc/a.txt");
boolean b = file.createNewFile(); //创建a.txt文件成功返回true,创建失败(包括文件或文件夹已存在)返回false
创建的文件或者目录,在File的构造方法中给出
如果文件已经存在就不再创建
此方法创建出来的都是文件类型，因此只能创建文件,不能创建文件夹(目录);
File创建文件夹功能File file =new File("/Users/fatah/Desktop/abc/a");
boolean result = file.mkdir() 只能创建单级文件夹 //注意：若已存在同名的a文件,同样也会创建a文件夹失败返回false
创建的路径也在File构造方法中给出
若文件或文件夹已经存在了,不再创建boolean mkdirs() 创建单级或者多级文件夹(推荐使用)
最后很重要的一点：在创建之前，先要判断文件或者文件夹是否存在再创建。即判断：
if(!file.exists()) {
执行创建操作
}
2.3、File的删除功能
可以删除文件或者文件夹
boolean delete()
删除的文件或者是文件夹路径,在File的构造方法中给出
删除成功返回true
删除失败返回false
删除方法不走回收站,直接从硬盘中删除
删除有风险,运行需谨慎！！！
2.4、File类的获取功能
String getName()
File file =new File("/Users/fatah/Desktop/abc/newFile.java");
String name = file.getName(); //返回结果 : newFile.java 不管文件是否存在,本质只做字符串切割subString()
返回路径中表示的文件或者文件夹名
获取路径中的最后部分名字String getPath() 等效于file.toString()
long length()返回路径中表示的文件字节数
String getAbsolutePath() 返回此抽象路径名的绝对路径 //返回 /Users/fatah/Desktop/abc/newFile.txt
String getAbsoluteFile() 返回此抽象路径名的绝对路径源码实现:
public File getAbsoluteFile() {
String absPath = getAbsolutePath();
return new File(absPath, fs.prefixLength(absPath));
}
二者只是返回类型不同 返回值相同
在eclipse环境中，如果写的是一个相对路径,返回工程的根目录
File file = new File(“src”);
File absolute =file.absoluteFile();
Syso absolute 结果是/Users/fatah/eclipse-workspace/Thread/srcFile getParentFile()获取父路径 返回File对象
String getParent()获取父路径 返回String对象
2.5、File类中的判断功能
boolean exists()
判断File构造方法中封装路径是否存在
存在返回true,不存在返回falseboolean isDirectory()
判断File构造方法中封装的路径是不是文件夹
如果是文件夹,返回true,不是文件夹,返回falseboolean isFile()——文件夹也返回false
判断File构造方法中封装的路径是不是文件
如果是文件,返回true,不是文件,返回falseFile类中的list获取功能 相当于遍历文件夹
Sring[] list() 返回只有文件名 //newFile.txt等文件名
File[] listFiles() 返回全目录径或者文件的绝对路径 /Users/fatah/Desktop/abc/newFile.txt等全路径名
Static File[] listRoots() 返回系统中所有根目录(盘符) 静态方法直接类名调用
2.6、File文件过滤器
遍历目录的时候，可以根据需要,只需要满足条件的文件
遍历目录方法 listFiles()重载形式
list(FileFilter filter)不能传递接口类型
则传递FileFilter接口实现类
查API发现FileFilter没有实现类
则需要自定义FileFilter接口实现类,重写抽象方法
接口实现类对象传递到遍历方法listFilesFile[] fileArr = file.listFiles(new MyFilter());
这里的listFiles()有两层作用:在遍历目录的同时,获取到了文件名全路径,调用过滤器的方法accpet,将获取到的路径传递给accept方法的参数pathname
package cn.itcats.thread.countdownlatch;
import java.io.File;
import java.io.FileFilter;
//自定义规则类
public class MyFileFilter implements FileFilter{
//方法体申明过滤什么格式的,过滤掉的文件格式返回false即可
//如 我们过滤后缀名为.java的文件
public boolean accept(File pathname) {
if(pathname.getName().endsWith(".java")) return true;
return false;
}
}
package cn.itcats.Files;
import java.io.File;
import java.io.IOException;
/**
* 使用原始方法执行几行数相加
*
* @author fatah
*
*/
public class Files {
public static void main(String[] args) throws IOException {
File file = new File("/Users/fatah/Desktop/abc");
File[] files = file.listFiles(new MyFileFilter());
for(File f : files) {
System.out.println(f);
}
}
}
//遍历结果为含.java为后缀的文件
3、字节输入流(java.io.OutputStream)
- OutputStream是所有字节输出的超类(abstract)
- ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据
- ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流
3.1、输入流write()方法
作用：从Java程序写出文件
字节： 这样流 每次只操作文件中的一个字节
可以写任意文件
方法都是写入文件的方法void write(int p) 写入一个字节
void write(byte [] b)写入一个字节数组
void write(byte[] b,int,int)写入字节数组, 第一个int 开始写入的索引 后一个int 写几个索引
close()关闭流对象,并释放与次流相关的资源流对象 操作文件的时候,自己不做 都依赖操作系统 所以用完流之后一定要close()
FileOutputStream 是OutputStream的子类
写入数据文件,学习父类方法,使用子类对象
FileOutputStream构造器注意：此构造器(默认不续写)，若已存在此文件,原文件内容会丢失，如需续写则看3.2章节
FileOutputStream fos =new FileOutputStream("/Users/fatah/Desktop/abc/a.txt"); 会在指定目录下创建一个a.txt文件
//流对象的方法write写数据
//写一个字节
fos.write(97); a.txt内写的是a 因为文件产生的瞬间会查ASCII编码表
//写字节数组
byte[] bytes ={65,66,67,68}; //ABCD
fos.write(bytes);
//写字节数组的一部分，开始索引，长度
fos.write(bytes,1,2); //BC
//最后一定要关闭资源
fos.close();
3.2、FileOutputStream文件的续写
FileOutputStream构造方法不但可以写String也可以写File
File file =new File(“c:\\d.txt”);
FileOutputStream fos = new FileOutputStream(file,true);
//构造方法末尾加入true则实现文件的续写
fos.write(“hello”.getBytes());
3.3、FileOutputStream文件的换行
在文件中，写入换行，符号换行\r\n
\r\n 可以写在上一行的末尾,也可以写在下一行的开头
fos.write(“hello\r\n”.getByte());
fos.write(“world”.getByte());
fos.close();
输出的结果为：
hello
world
4、字节输入流(java.io.InputStream)
- InputStream是所有字节输入流的超类 (abstract)
- ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据
- ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。
作用:读取任意文件，每次只读取一个字节
读取的方法 read()
int read() 读取一个字节
int read(byte [] b)读取一定量的字节,存储到数组中
4.1、FileInputStream读取文件
构造方法:为这个输入流对象绑定数据源
参数 File类型对象 String类型对象 都是其数据源
输入流读取文件的步骤
1.创建字节输入流的子类对象
2.调用读取方法read读取
3.关闭资源read()方法
read()执行一次,就会自动读取下一个字节(所以不能出现两个read() ，可以用一个变量len去接收read() )
返回值,返回的是读取到的字节,读取到结尾返回-1
输入流读取字节数组的步骤读取方法 int read(byte[] b) 读取字节数组
数组作用 : 缓冲的作用,提高效率,但设置太高消耗内存,一般设置为1024或者是1024整数倍
read返回int,表示什么含义呢? 答:读取到多少个有效的字节数
具体代码实现：
package cn.itcats.thread.countdownlatch;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
* 使用int read(byte [] b)输入流方法读取文件
* @author fatah
*/
public class ByteFileInputStream {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream(new File("/Users/fatah/Desktop/abc/newFile.txt"));
byte [] b =new byte [1024];
int len = 0;
while((len = fis.read(b)) != -1) {
/*这里多说一句
* new String(byte[] bytes, int offset, int length, Charset charset)
通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。
*/
System.out.println(new String(b,0,len,"UTF-8"));
}
fis.close();
}
}
4.2、字节流复制文件读取字节数组
package cn.itcats.thread.countdownlatch;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 使用字节流完成文件的复制(采取字节一读一写)
* @author fatah
*
*/
public class CopyFileStream {
public static void main(String[] args) throws IOException {
//创建字节输入流(读)
FileInputStream fis = new FileInputStream(new File("/Users/fatah/Desktop/apache-tomcat-9.0.8.tar.gz"));
//创建字节输出流(写)
FileOutputStream fos = new FileOutputStream(new File("/Users/fatah/Desktop/abc/apache-tomcat-9.0.8.tar.gz"));
byte [] b = new byte[1024];
int len = 0 ;
while((len = fis.read(b))!=-1) {
fos.write(b, 0, len);
}
if(fis != null) fis.close();
if(fos != null) fos.close();
}
}
5、字符流Reader
- Reader和Writer分别是字符输入流的超类和字符输出流的超类 (都是abstract)
- CharReader、StringReader 是两种基本的介质流，它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。
- BufferedReader是一个装饰器，它和其子类负责装饰其它Reader 对象。
- FilterReader是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号。
- InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。后面会有Reader 与InputStream 的对应关系。
专门读取文本文件
读取方法 read()
int read() 读取一个字符
int read(char[] c) 读取字符数组
子类对象FileReader
构造方法 : 绑定数据源
参数: File 类型对象
String 文件名
读取文本文件，具体代码实现：
package cn.itcats.reader;
import java.io.FileReader;
import java.io.IOException;
/**
* 使用字符输入流读取文本文件
* @author fatah
*/
public class MyReader {
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("/Users/fatah/Desktop/abc/newFile.txt");
char [] c =new char [1024];
int len = 0;
while( (len = reader.read(c) ) != -1) {
System.out.println(new String(c,0,len));
}
reader.close();
}
}
6、字符流Writer
- Writer 是所有的字符输出流的父类，它是一个抽象类。
- CharArrayWriter、StringWriter 是两种基本的介质流，它们分别向Char 数组、String中写入数据。PipedWriter是向与其它线程共用的管道中写入数据，
- BufferedWriter 是一个装饰器为Writer 提供缓冲功能。
- PrintWriter 和PrintStream 极其类似，功能和使用也非常相似。
- OutputStreamWriter 是OutputStream 到Writer 转换的桥梁，它的子类FileWriter 其实就是一个实现此功能的具体类。
构造方法:写入的数据目的
File 类型对象
String类型对象
字符输出流写数据的时候,必须要运行一个功能.刷新功能flush()
6.1、Writer和Reader综合运用
使用字符流复制文本文件,必须文本文件
具体代码实现：
package cn.itcats.copy;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* 字符流复制文本文件,必须文本文件
字符流查询本机默认的编码表,简体中文GBK
FileReader 读取数据源
FileWriter 写入数据目的
* @author fatah
*/
public class CopyCharFile {
public static void main(String[] args) throws IOException {
//数据源
File source = new File("/Users/fatah/Desktop/abc/newFile.txt");
//数据目标
File target = new File("/Users/fatah/Desktop/newFile.txt");
//创建字符输入流
FileReader fr = new FileReader(source);
//创建字符输出流
FileWriter fw = new FileWriter(target);
char [] c = new char [1024];
int len = 0 ;
while((len = fr.read(c))!=-1) {
fw.write(c, 0, len);
fw.flush(); //Writer务必要flush
}
fr.close();
fw.close();
}
}
7、转换流(字符流与字节流相互转换)
7.1、java.io.OutputStreamWriter 继承Writer类
就是一个字符输出流写文本文件
write() 字符 字符数组 字符串字符通向字节的桥梁，字符流转换为字节流
OutputStreamWriter使用方法
构造方法:
OutputStreamWriter(OutputStream out)接收所有字节输出流OutputStreamWriter(OutputStream out,charsetName)
其中charsetName传递编码表名字 GBK UTF-8 不区分大小写OutputStreamWriter只有有一个子类 (可以指定编码表)
FileWriter(不能指定编码表)
代码演示：
package cn.itcats.transform;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
//字符流转换为字节流
public class OutputStreamWriterTest {
public static void main(String[] args) throws IOException {
FileOutputStream fs = new FileOutputStream("/Users/fatah/Desktop/abc/osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fs, "utf-8");
osw.write("你好");
osw.flush(); //writer务必要flush
osw.close();
}
}
7.2、java.io.InputStreamReader 继承Reader
字符输入流 读取文本文件
字节流向字符的桥梁,将字节转化为字符
读取方法
read() 读取一个字符,字符数组
OutputStreamWriter(OutputStream out)所有字节输出流
InputStreamReader(InputStream in)接收所有字节输入流
可以传递字节输入流 FileIntputStream
InputStreamReader(InputStream in,String charsetName)接收所有字节输入流
具体实现同上，不做演示了。
7.3、转换流和子类的区别
OutputStreamWriter 字符—>字节
———FileWriter
InputStreamReader 字节—>字符
———FileReader
8、缓冲区流
8.1、字节缓冲输出流(java.io.BufferedOutputStream)
作用:提高原有输出流的写入效率
BufferedOutputStream 继承 OutputStream
方法 写入write 字节,字节数组构造方法:
BufferedOutputStream(OutputStream out)
可以传递任意的字节输出流,传递的是哪个字节流,就对哪个字节流提高效率
package cn.itcats.io.buffer;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedOutputStreamTest {
public static void main(String[] args) throws IOException {
File target = new File("/Users/fatah/Desktop/abc/bos.txt");
FileOutputStream fos = new FileOutputStream(target);
//提高了FileOutputStream效率
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("测试BufferedOutputStream".getBytes("utf-8"));
bos.close();
fos.close();
}
}
8.2、字节缓冲输入流(java.io.BufferedInputStream)
继承InputStream,标准的字节输入流
读取方法 read() 单个字节, 字节数组构造方法:
BufferdInputStream(InputStream in)
可以传递任意的字节输入流,传递是谁,就提高谁的效率
可以传递的字符输入流 FileinputStream
实现代码：
package cn.itcats.io.buffer;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamTest {
public static void main(String[] args) throws IOException {
File target = new File("/Users/fatah/Desktop/abc/bos.txt");
FileInputStream fis = new FileInputStream(target);
//提高了FileInputStream效率
BufferedInputStream bis = new BufferedInputStream(fis);
byte [] b =new byte[1024];
int len = 0;
while((len = bis.read(b) )!= -1) {
System.out.println(new String(b,0,len));
}
bis.close();
fis.close();
}
}
8.3、字符输出流缓冲区流(java.io.BufferedWriter)
java.io.BufferedWriter 继承Writer
写入方法write() 单个字符，字符数组，字符串构造方法
BufferedWriter(Writer w)传递任意字符输出流
传递谁,就高效谁
能传递的字符输出流有 FileWriter,OutputStreamWriter等
另外 BufferedWriter 具有自己的特有方法
void newLine() 写换行
newLine()文本中换行,方法具有平台无关性 \r\n也是文本换行
Windows \r\n
Linux \n
newLine()运行结果和操作系统是相关的
JVM:安装的是Windows版本,newLine()写的是\r\n
安装的是Linux版本,newLine()写的是\n
具体代码演示：
package cn.itcats.io.buffer;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterTest {
public static void main(String[] args) throws IOException {
File target = new File("/Users/fatah/Desktop/abc/bos.txt");
FileWriter fw = new FileWriter(target,true);
BufferedWriter bw = new BufferedWriter(fw);
bw.write("测试BufferedWriter".toCharArray()); //写入字符数组
//BufferedWriter特有方法 newLine() 换行
bw.newLine();
bw.flush(); //Writer一定要flush否则报Stream closed错误
bw.write("写入String");
bw.newLine();
bw.flush(); //Writer一定要flush否则报Stream closed错误
fw.close();
bw.close();
}
}
8.4、字符输入流缓冲流(java.io.BufferedReader)
java.io.BufferedReader
继承Reader
读取功能 read() 单个字符,字符数组
构造方法:
BufferedReader(Reader r)
可以任意的字符输入流
FileReader InputStreamReaderBufferedReader 自己的功能
String readLine() 读取文本行 依靠的是\r\n 来确定行结束
方法读取到末尾，返回null
8.5、使用缓冲区流对象,复制文本文件
数据源 BufferedReader+FileReader 读取
数据目的 BufferedWriter+FileWriter 写入
读取文本行,读一行,写一行,换一行
具体代码实现
package cn.itcats.io.buffer;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
使用缓冲区流对象,复制文本文件
数据源 BufferedReader+FileReader 读取
数据目的 BufferedWriter+FileWriter 写入
读取文本行,读一行,写一行,换一行
*/
public class Copy {
public static void main(String[] args) throws IOException {
File source = new File("/Users/fatah/Desktop/abc/bos.txt");
File target = new File("/Users/fatah/Desktop/bos.txt");
//输入流
FileReader fr = new FileReader(source);
BufferedReader br = new BufferedReader(fr);
//输出流
FileWriter fw = new FileWriter(target);
BufferedWriter bw = new BufferedWriter(fw);
String s = null;
//readLine是BuffedReader的特有方法，方法读取到末尾，返回null 注意！！！
while(( s = br.readLine() )!=null) {
bw.write(s);
bw.newLine();
bw.flush();
}
//关闭资源
fr.close(); br.close(); fw.close(); bw.close();
}
}
9、ProPerties类
表示一个持久的属性集。Properties可保存在流中或从流中加载。属性列表中每个键及其对应的值都是一个字符串。
特点:
1、Hashtable的子类,map集合中的方法都可以用
2、该集合没有泛型。键值都是字符串
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备
4、有流技术相结合的方法使用Properties集合,存储键值对
setProperty等同于Map接口中的put
setProperty(String key,String value) Properties类中不存在泛型
通过键获取值,getProperty(String key)Properties集合特有方法 load
load(InputStream in)
load(Reader r)
传递任意字节或者字符的输入流
流对象读取文件中的键值对,保存到集合把文件中的键值对加载到集合中
注销pro.properties中的某一键值对 只需要在此键值对之前添加#即可Properties类中的特有方法
store(OutputStream out,String comments)
store(Writer w,String comments)
接收所有的字节或者字符的输出流,将集合中的键值对,写回文件中保存
读取文件中的键值对
pro.txt文件内容 ：
A=a
B=b
C=c
package cn.itcats.io.buffer;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.util.Properties;
public class PropertiesTest {
public static void main(String[] args) throws IOException {
Properties pro = new Properties();
FileReader fr = new FileReader(new File("/Users/fatah/Desktop/abc/pro.txt"));
//流对象读取文件中的键值对,保存到集合
pro.load(new BufferedReader(fr));
String value = pro.getProperty("A");
fr.close();
}
}打印结果：a
同样Properties集合类中的store()方法是将集合中的键值对通过输出流输出到文件保存，此处就不演示了。
10.ObjectOutputStream/ObjectInputStream
ObjectOutputStream/ObjectInputStream 对象的序列化与反序列化
IO流对象,实现对象Person序列化和反序列化
ObjectOutputStream 写对象,实现序列化
ObjectInputStream 读取对象,实现反序列化
ObjectOutputStream
构造方法:ObjectOutputStream(OutputStream out)
传递任意的字节输出流
void writeObject(Object obj) 写出对象的方法
对象所在类(Person类)需要 implements Serializable
ObjectInputStream
构造方法: ObjectInputStream(InputStream in)
传递任意的字节输入流,输入流封装文件,必须是序列化文件
Object readObject() 读取对象
11、打印流(PrintStream/PrintWriter)
PrintWriter() 构造方法————还接收字符输出流Writer
打印流的特点
1.此流不负责数据源，只负责数据目的
2.为其他输出流，添加功能
3.永远不会抛出IOException
但是,可能抛出别的异常两个打印流的方法，完全一致
但是构造方法不太一致(构造方法就是打印流的输出目的端)
PrintStream
——构造方法 就收File类型，接收字符串文件名，接收字节输出流OutputStream
PrintWriter
——构造方法 接收File类型，接收字符串文件名，接受字节输出流OutputStream,
同时还接收字符输出流Writer方法print println 原样输出
而write方法走码表当且仅当输出语句是char数组，打印结果是数组内元素，而不是内存地址
打印流的自动刷新功能
满足两个条件:
1.输出的数据目的必须是流对象
OutputStream,Writer
2.必须调用println,printf,format三个方法中的一种,启动自动刷新功能
12、对文件操作的第三方API支持(Apache)
FilenameUtils类
获取文件的后缀名 static String getExtension(String filename)
获取文件名 static String getName(String filename)
判断文件名是否以extension结束 static boolean isExtension(String filename , String extension)FileUtils类
static String readFiletoString(File src)读取文本返回字符串
static void writeStringToFile(File src,String data) 写data到指定的文本文件中
static void copyFile(File src,File dest) 将数据源的文件拷贝到数据目的
static void copyDirectoryToDirectory(File src,File dest) 拷贝文件夹
扫一扫
217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
