Java-IO流学习
2020-05-18 16:29:45来源:博客园 阅读 ()
Java-IO流学习
IO流学习
流的分类
- 根据操作单位不同分为字节流和字符流
- 根据流向不同分为输入流和输出流
- 根据角色不同分为节点流和处理流
以下四个类是IO流中最基础的类,都是抽象类。其他流都是继承他们的。
分类 | 字节流 | 字符流 |
---|---|---|
输入流 | InputStream | Reader |
输出流 | OutputStream | Writer |
字节流:操作的对象是字节数组
字符流:操作的对象是字符数组
节点流:作用在文件上的流,直接对文件进行读写操作
处理流:作用在节点流上的流,可以加速流的传输
输入流和输入流是相对的,主要看你站在那个角度来看待,如果站在程序的角度,读入数据较输入流,写出数据较输出流。
IO流体系结构
分类 | 字节输入流 | 字节输出流 | 字符输入流 | 字符输出流 |
---|---|---|---|---|
抽象基类 | InputStream | OutputStream | Reader | Writer |
访问文件 | FileInputStream | FileOutputStream | FileReader | FileWriter |
访问数组 | ByteArrayInputStream | ByteArrayOutputStream | CharArrayReader | CharArayWriter |
访问管道 | PipedInputStream | PipedOutputStream | PipedReader | PipedWriter |
访问字符串 | StringReader | StringWriter | ||
缓冲流 | BufferedInputStream | BufferedOutputStream | BufferedReader | BufferedWriter |
转换流 | InputStreamReader | OutputStreamWriter | ||
对象流 | ObjectInputStream | ObjectOutputStream | ||
过滤流 | FilterInputStream | FileOutputStream | FilterReader | FileWriter |
打印流 | PrintStream | PrintWriter | ||
推回输入流 | PushbackInputStream | PushbackReader | ||
特殊流 | DataInputStream | DataOutputStream |
访问文件的流都是节点流,其他除了抽象基类外都是处理流
File类
想要进行IO操作,肯定离不来文件,所以学习IO流的前提就是要学会File类的操作。
File类的介绍
File是用来操作文件或目录的,但是不能对文件的内容进行操作,主要是用于文件和目录的创建、文件的删除、文件的查找。
File类构造方法
File类表示的是硬盘中实际存在的目录或文件,可以通过以下三种方式创建一个File类的对象。
File(String pathname)//通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 常用
File(File parent, String child) //从父抽象路径名和子路径名字符串创建新的 File实例。常用
File(String parent, String child) //从父路径名字符串和子路径名字符串创建新的 File实例。 常用
File(URI uri) //通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。
代码举例:
@Test
public void test(){
//根据路径创建
String path = "d:\\file.txt";
File file = new File(path);
//根据父文件和子类路径创建
File parentFile = new File( "d:\\io");
File file1 = new File(parentFile,"file1.txt");
//根据父路径和子路径创建
String parentPath = "d:\\io";
String childPath = "file2.txt";
File file2 = new File(parentPath,childPath);
}
注意:在Windows中路径分割使用‘\’,在Linux中使用‘/’,为了方便区分在File类中有一个separator 属性,可以用来代替分隔符。
在Java中 \ 是用来转义的,所以这里需要使用两个 \ 字符
路径问题
相对路径:相对于当前的项目路径,不带盘符。如: "hello.txt"
绝对路径:相对于硬盘的物理路径,是一个带有盘符的完整路径。如:"d:\hi.txt"
如代码所示,目前文件只是存在于内存中,还没有在硬盘上创建实际的文件,需要使用一些方法来创建,下面介绍File类中的常用方法。
File类常用方法
1、获取的方法
public String getAbsolutePath() //绝对路径名字符串。
public String getPath() //将此抽象路径名转换为路径名字符串。
public String getName() //返回由此抽象路径名表示的文件或目录的名称。
public String getParent() //返回上层文件目录路径,没有则返回null。
public long length() //返回由此抽象路径名表示的文件的长度。 长度指的是文件的字节数,不能获取目录的长度。
public String[] list() //获取指定目录下的所有文件或文件目录的名称数组
public File[] listFiles() //获取指定目录下的所有文件或文件目录的File数组
@Test
public void test3(){
File file = new File("f:\\io\\hello.txt");
System.out.println("绝对路径:"+file.getAbsolutePath());
System.out.println("路径:"+file.getPath());
System.out.println("名字:"+file.getName());
System.out.println("上层路径:"+file.getParent());
System.out.println("长度"+file.length());
System.out.println("文件目录:"+file.list());
System.out.println("文件目录"+file.listFiles());
}
/*
运行结果:
绝对路径:f:\io\hello.txt
路径:f:\io\hello.txt
名字:hello.txt
上层路径:f:\io
长度0 -->因为文件中没有内容,所以是0
文件目录:null --> 因为当前是一个文件,所以没有目录,如果是一个目录就会有
文件目录null --> 因为当前是一个文件,所以没有目录,如果是一个目录就会有
*/
进行判断的方法
public boolean exists()//判断文件或目录是否存在
public boolean isDirectory()//判断是否是目录
public boolean isFile()//判断是否是文件
@Test
public void test5(){
File file = new File("hello.txt");//该文件没建过
System.out.println("文件是否存在"+file.exists());//false
System.out.println("是否是目录"+file.isDirectory());//false
System.out.println("是否是文件"+file.isFile());//false,因为连文件都没有,所以是false
File file1 = new File("hello.txt");//该文件我已经创建过了
System.out.println("文件是否存在"+file1.exists());//true
System.out.println("是否是目录"+file1.isDirectory());//false
System.out.println("是否是文件"+file1.isFile());//true
}
进行创建的方法
public boolean createNewFile() //如果文件不存在则创建一个新的空文件返回true,如果存在,不创建,返回false;
public boolean mkdir()//创建文件目录,如果文件目录存在,不创建,如果文件的上层目录不存在,也不创建;
public boolean mkdirs()//创建文件目录,如果上层文件目录不存在,也一起创建
@Test
public void test4() throws IOException {
File file = new File("test.txt");
System.out.println(file.createNewFile());//true
File file1 = new File("f:\\test\\hello");
file1.mkdir();//test和hello目录都不存在,不会创建
File file2 = new File("f:\\test\\hello\\java");
file2.mkdirs();//test和hello目录都不存在,会全部创建
}
进行删除的方法
public boolean delete()//删除文件或目录
File类练习
打印指定文件目录下的所有文件-递归实现
//递归打印文件
@Test
public void test6(){
File file = new File("f:\\io");
printFile(file);
}
public void printFile(File file){
File[] files = file.listFiles();
for (File f : files) {
if(f.isDirectory()) printFile(f);
System.out.println(f.getName());
}
}
字符流
纯文本文件都用字符流来处理
字符输入流
FileReader
1、构造方法
FileReader(File file) //根据file创建一个对象
FileReader(String fileName)//根据文件目录创建一个对象
2、常用方法
public int read()//从文件中读取一个字符,如果文件中没有字符了返回-1
public int read(char[] cbuf)//从文件中读取多个字符,如果文件中没有字符了返回-1,如果有返回读了多少个字符
public void close();//关闭流
使用FileReader读取hello.txt中的内容
hello.txt
@Test
public void test1() {
FileReader reader = null;
try {
File file = new File("hello.txt");
reader = new FileReader(file);
char[] cbuf = new char[5];
int len = 0;
// 方式一,每次读一个字符
while((len = reader.read()) != -1){//每次读一个字符
System.out.print((char)len);
}
/*方式二,每次读多个字符
while ((len = reader.read(cbuf)) != -1){
for (int i = 0; i < len; i++) {//这里不能使用cbuf.length;因为在最后可能字符不够5个,所以使用len
System.out.print(cbuf[i]);
}
}
*/
} catch (IOException e) {
e.printStackTrace();
} finally {
if(reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
运行结果:
hellojava
*/
使用IO流都有可能会出现异常,所以在这里需要使用try\catch\finally来处理异常
字符输出流
FileWriter
1、构造方法
FileWriter(File file) //根据file创建一个对象
FileWriter(File file, boolean append) // 根据file创建一个对象,并根据append判断在多次写入数据是否覆盖,默认false,选择覆盖
FileWriter(String fileName) // 根据字符串创建一个对象
FileWriter(String fileName, boolean append) //同上,true表示不覆盖,false表示覆盖,默认false
2、常用方法
public void wirte(int c)//写入一个字符
public void wirte(char[] cbuf)//写入多个字符
public void wirte(char[] cbuf, int off, int len)//写入字符的长度由len决定,off表示从那开始。
public void wirte(String str)//写入字符串
public void wirte(String str, int off, int len)//写入部分字符串,有off和len决定,off表示开始的下标,len表示长度
public void flush()//刷新缓存区,如果没有关闭流则数据不会写入文件
public void close()//关闭流,关闭流之后会自动刷新缓存
使用FileWriter向hello.txt中写入数据
@Test
public void test8(){
FileWriter fw = null;
try {
File file = new File("hello.txt");
fw = new FileWriter(file);
String str = "i love java";
fw.write(str);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fw != null) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
结果:
注意:字符流不能处理非文本的数据
字节流
非纯文本文件使用字节流来处理
字节输入流
FileInputStream
1、构造方法
FileInputStream(File file)//根据file创建一个字节输入流对象
FileInputStream(String name)//根据文件路径创建一个字节输入流对象
2、常用方法
public int read()//从文件中读取一个字节,如果文件中没有字节了返回-1
public int read(b[] b)//从文件中读取多个字节,如果文件中没有字节了返回-1,如果有返回读了多少个字节
public void close();//关闭流
使用FileInputStream读取hello.txt中的内容
@Test
public void test9(){
FileInputStream fis = null;
try {
File file = new File("hello.txt");
fis = new FileInputStream(file);
int len;
while((len = fis.read()) != -1){//每次读一个字节
System.out.print((char)len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字节输出流
FileOutputStream
1、构造方法
FileOutputStream(File file)//根据file创建一个字节输出流对象
FileOutputStream(File file, boolean append)//通过append判断是否覆盖,默认为false,覆盖,true为不覆盖
FileOutputStream(String name) //根据文件路径创建一个字节输出流对象
FileOutputStream(String name, boolean append)//同上
2、常用方法
public void wirte(int c)//写入一个字节
public void wirte(byte[] b)//写入多个字节
public void wirte([] b, int off, int len)//写入字节的长度由len决定,off表示从那开始。
public void close()//关闭流,
使用FileOutputStream向hello.txt中写入数据
@Test
public void test10(){
FileOutputStream fos = null;
try {
fos = new FileOutputStream(new File("hello.txt"));
String str = "hellojava";
fos.write(str.getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果:
因为我都选择默认不append,所以每次都是将之前的覆盖掉
缓冲流
缓冲流的主要目的就是提高之前的流的读取或写入的速度。
缓冲流的使用方法和字符流或字节流一样。这里就介绍一下如何声明一个缓冲流。
字符缓冲流
1、构造方法
BufferedReader(Reader in)
BufferedWriter(Writer out)
注意:构造方法的参数是一个抽象类,在传参的时候应该传该抽象类的实现类
使用
BufferedReader br = new BufferedReader(new FileReader(new File("hello.txt")));
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("hello.txt")));
2、特有方法
public String readLine()//读一行
public void newLine()//换行
字节缓冲流
1、构造方法
BufferedInputStream(InputStream in)
BufferedOutputStream(OutputStream out)
注意:构造方法的参数是一个抽象类,在传参的时候应该传该抽象类的实现类
使用
BuffededInputStream bis = new BufferedInputStream(new FileInputStream("hello.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileInputStream("hello.txt"));
转换流
转换流就是将字节流转换为字符流或将字符流转换为字节流。
InputStreamReader(将字节流转换为字符流)
1、构造方法
InputStreamReader(InputStream in) //创建一个默认字符集的转换流
InputStreamReader(InputStream in, String charsetName) //创建一个指定字符集的转换流
2、使用
@Test
public void test11(){
InputStreamReader isr = null;
InputStreamReader isr1 = null;
try {
isr = new InputStreamReader(new FileInputStream("hello.txt"));//默认字符集
isr1 = new InputStreamReader(new FileInputStream("hello.txt"),"GBK");//默认GBK字符集,会出现乱码
int len = 0;
while((len = isr.read()) != -1){
System.out.print((char)len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(isr != null) {
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
运行结果:
hellojava
*/
OutputStreamWriter(将字符流转换为字节流)
1、构造方法
OutputStreamWriter(OutputStream out)//创建一个默认字符集的转换流
OutputStreamWriter(OutputStream out, String charsetName) //创建一个指定字符集的转换流
2、使用
@Test
public void test12(){
OutputStreamWriter osw = null;
try {
osw = new OutputStreamWriter(new FileOutputStream("hello.txt",true));
String str = "hellojava";
osw.write(str);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(osw != null) {
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果:
序列化流
序列化流分为:序列化和反序列化
序列化:就是将自己写的一个对象持久化到硬盘上,
反序列化:将序列化到硬盘上的对象取出来
要求:序列化的类必须实现Serializable接口,而且这个类的属性也必须是可序列化的。8个基本类型是可序列化的。
序列化的类需要提供一个常量,用来表示序列版本号
如果没有这个版本号,会出错!!出什么错呢,比如你先序列化了一个对象到一个文件中,然后你对序列化的类进行了修改,然后从文件中吧对象反序列化出来就会出错。
因为在你实现了Serializable接口的时候,你当前类会有一个默认的序列版本号,你修改类的时候,你的序列版本号就有可能会修改,然后反序列化的时候就会找不到对象。
重点:被static和transient修饰的属性是不会被序列化的。
序列化-ObjectOutputStream
1、构造方法
ObjectOutputStream(OutputStream out) //参数是一个抽象类,需要传一个它的子类
2、使用
@Test
public void test13(){
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream("hello.txt"));
oos.writeObject(new User("Tom",3));
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos != null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果:
报错了,为什么呢?因为User类没有实现Serializable接口。当实现了接口后就能正常的序列化了。
ObjectInputStream-反序列化
1、构造方法
ObjectInputStream(InputStream in)
2、使用
@Test
public void test14(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("hello.txt"));
User user = (User) ois.readObject();
System.out.println(user);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if(ois != null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果:
反序列化后,得到了刚才序列化的内容。
写在最后
花了一天时间,总算是自己把IO的部分总结了一下,怎么说呢,总结的肯定是不够完整和细致的,以后在实践中慢慢的在完善吧!
自己还是太菜了。需要学习的地方还很多!不学习就找不到工作!!!!!
原文链接:https://www.cnblogs.com/Z-Dey/p/12907113.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
- 学习Java 8 Stream Api (4) - Stream 终端操作之 collect 2020-06-11
- java学习之第一天 2020-06-11
- Java学习之第二天 2020-06-11
- Spring WebFlux 学习笔记 - (一) 前传:学习Java 8 Stream Ap 2020-06-11
- Linux简单命令的学习 2020-06-10
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash