JavaIO流
一、流的概念
内存与存储设备之间传输数据的通道。例如在内存中的程序，想要读取硬盘中的文件，必须借助流；在水库中的水流入家庭中（存储设备到内存）
二、流的分类
按方向：
输入流：将存储设备中的内容读入到内存中
输出流：将内存中的内容写入到存储设备中
流入程序的时输入流，流出程序的是输出流
按单位：
字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据
按功能：
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能
三、字节流
1、字节流的父类（抽象类）
InputStream 字节输入流（读）
OutputStream 字节输出流（写）
2、文件字节流
FileInputStream
public int read(byte[] b) 从流中读取多个字节，将督导的内容存在b数组，返回实际读到的字节数；如果达到文件的1尾部，则返回-1
FileOutputStream
一次写多个字节，将b数组中所有字节，写入输出流
FileInputStream的使用
package com.an;
import java.io.FileInputStream;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建FileInputStram,并指明文件路径
FileInputStream fis = new FileInputStream("d:\\aaa.txt");//此处有异常，就将异常抛出
//读取文件路径，先提前创建好文件，并在文件输入内容abc
//fis.read();第一种方法，单个字节读取
//要将全部字节读出，先建一个循环
int data=0;
while((data=fis.read())!=-1){
System.out.println((char) data);//不想读出来是哈希码，就要进行强转换
}
//第二种方法，一次读取多个字节，前提要先创建一个数组
byte[] by=new byte[3];
int count=fis.read(by);
System.out.println(new String(by));
System.out.println("个数为："+count);
//第三种方法是数组有起点和长度
System.out.println(new String(by,0,count));
//关闭
fis.close();
System.out.println("执行完毕");
}
}
第二种和第三种方法换成此处代码会更有效率
byte[] by=new byte[3];
int count=0;
while((count=fis.read())!=-1){
System.out.println(new String(by,o,3));
}
FileOutputStream的使用
package com.an;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建FileOutputStream,并输出流对象
FileOutputStream fis = new FileOutputStream("d:\\aaa.txt",true);//如果在此处写true，那它会写入文件末尾
//写入文件
fis.write(1);
fis.write(3);
String string="Hello";
fis.write(string.getBytes());
//关闭
fis.close();
System.out.println("执行完毕");
}
}
3、字节流复制文件
一边读，一边写就是复制的过程
4、字节缓冲流
缓冲流：BufferedInputStream和BufferedOutputStream
特点：
提供IO效率，减少访问磁盘的次数
数据存储在缓冲区中，flush是将缓冲区的内容写入文件，也可以直接close
BufferedInputStream
package com.an;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建FileIntputStream,并输出流对象,然后在创建BufferedInputStream
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
BufferedInputStream dis = new BufferedInputStream(fis);//实例化
//读取，缓冲流中的字节
int data=0;
while((data=dis.read())!=-1){
System.out.println((char)data);
}
//也可以自己创建一个缓冲区
byte[] gis = new byte[10];
int count=0;
while((count=dis.read(gis))!=0){
System.out.println(new String(gis,0,count));
}
//关闭缓冲流
dis.close();
System.out.println("执行完毕");
}
}
BufferedOutputStream
package com.an;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.niocharset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建FileOutputStream,并输出流对象,然后在创建BufferedOutputStream
FileOutputStream fis = new FileOutputStream("d:\\aaa.txt");
BufferedOutputStream dis = new BufferedOutputStream(fis);
//写入文件
for(int i=0;i<10;i++){
dis.write("HelloWorld".getBytes());//这行写入了缓冲区，没写入文件中
dis.flush();//刷新到硬盘，写入文件
}
//关闭缓冲流，这里会调用flush方法，在上面调用的话会防止数据丢失
dis.close();
System.out.println("执行完毕");
}
}
3、对象流
ObjectOutputStream/ObjectInputStream
使用流传输对象的过程称为序列化和反序列化
特点：
增强了缓冲区功能
增强了读写8终基本数据类型和字符串功能
增强了读写对象的可能：readObject()从流中读取一个对象；writeObject(Object obj) 向流中写入一个对象
序列化
把对象转换为字节序列的过程称为对象的序列化。
要想序列化学生类要先继承接口Serializable
package com.an;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld Throws Exception{
public static void main(String[] args) throws Exception{
//创建FileOutputStream,并输出流对象,然后在创建对象流
FileOutputStream fis = new FileOutputStream("d:\\aaa.txt");
ObjectOutputStream dis = new ObjectOutputStream(fis);
//序列化，写入操作
Student s=new Student("张三",22);
dis.writeObject(dis);
/**Student s1=(Student).dis.ReadObject("李四",23);
ArrayList<student> list = new ArrayList<>();
list.add(zhangsan);//如果有多个对象，可以用集合的方式写入文件
list.add(lisi);
dis.WritwObject(list);*/
//关闭
dis.close();
System.out.println("执行完毕");
}
}
反序列化
把字节序列恢复为对象的过程称为对象的反序列化
package com.an;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建FileInputStream,并输出流对象,然后在创建对象流
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
ObjectInputStream dis = new ObjectInputStream(fis);
//反序列化，读操作
Student s=(Student).dis.ReadObject();
/**ArrayList<Student> list=(ArrayList<Student>)dis.readObject();
System.out.println(list.toString());//遇见读多个对象时，可以用集合的方式*、
//关闭
dis.close();
System.out.println("执行完毕");
System.out.println(s.toString());
}
}
序列化与反序列化注意事项
序列化版本ID：
- 序列化类必须要实现Serializable接口
- 序列化类中对象属性要求实现Serializable
- 序列化版本ID，保证序列化的类和反序列化的类是同一个类
- 使用transient(瞬间的，不持久)修饰属性，这个属性不能序列化
- 静态属性不能序列化
- 序列化多个对象时，可以借助集合实现
四、编码方式
编码方式和解码方式不一致时，会产生乱码
UTF—8读取文件时，一个汉字三个字节
五、字符流
1、字符流的父类(抽象类)
Reader:字符输入流
Writer:字符输出流
2、文件字符流（子类）
FileReader:
public int read(char[] c) 从流中读取多个字符，将读到内容存入C数组，返回实际读到的字符数；如果达到文件尾部，则返回-1
FileWriter:
public void write(String str) 一次写入多个字符，将b数组中所有字符，写入输出流
FileReader
package com.an;
import com.sun.org.apache.xpath. internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建FileReader,文件字符输入流
FileReader fis = new FileReader("d:\\aaa.txt");
//读取
//第一种方法单个字符读取
int data=0;
while((data= fis.read())!=-1){//读取一个字符=三个字节
System.out.println((char)data);
}
//第二种方法创建一个字符缓冲区
char[] dis = new char[1024];
int count=0;
while((count=fis.read(dis))!=-1){
System.out.println(new String(dis,0,count));
}
//关闭
fis.close();
dis.close();//有数组时只需关闭数组的即可
System.out.println("执行完毕");
System.out.println(s.toString());
}
}
FileWriter
package com.an;
import com.sun.org.apache.xpath. internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建FileWriter,文件字符输入流
FileWriter fis = new FileWriter("d:\\aaa.txt");
//写入
for(int i=0;i<10;i++){
fis.write("java是最好的语言\r\n");//\r\n表示换行
fis.flush();
}
//关闭
fis.close();
System.out.println("执行完毕");
}
}
3、字符流的文件复制
使用FileReader和FileWriter复制文本文件，不能复制图片或者二进制图片
package com.an;
import com.sun.org.apache.xpath. internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建文件字符输入流或者输出流
FileWriter fis = new FileWriter("d:\\aaa.txt");
FileReader dis = new FileReader("d:\\bbb.txt");
//一边读，一边写
int data=0;
while((data=dis.read())!=-1){
fis.write(data);
fis.flush();
}
//关闭
fis.close();
dis.close();
System.out.println("复制完毕");
}
}
4、字符缓冲流
BufferedReader/BufferWriter
特点：
高效读写
支持输入换行符
可一次写一行、读一行
BufferReader
package com.an;
import com.sun.org.apache.xpath. internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建缓冲流
FileReader dis = new FileReader("d:\\bbb.txt");
BufferedReader fis = new BufferedReader(dis);
//读取
//第一种方式
char[] s = new char[1024];
int data=0;
while((data=fis.read(s))!=-1){
System.out.println(new String(s,0,data));
}
//第二种方式，一行一行读
String Line=null;
while((Line=fis.readLine()!=null)){
System.out.println(Line);
}
//关闭
fis.close();
System.out.println("复制完毕");
}
}
BufferedWriter
package com.an;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建缓冲流
FileWriter dis = new FileWriter("d:\\bbb.txt");
BufferedWriter fis = new BufferedWriter(dis);
//写入
//第一种方式
for(int i=0;i<10;i++){
fis.write("你好");
fis.newLine();//换行符 windows用\r\n linux用\n
fis.flush();
}
//关闭
fis.close();
System.out.println("执行完毕");
}
}
5、打印流
PrintWriter:
封装了Print()/Println()方法
支持数据原样打印
package com.an;
import com.sun.org.apache.xpath. internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建打印流
PrintWriter pr = new PrintWriter("d:\\aaa.txt");
//打印
pr.print(3);
//关闭
pr.close();
System.out.println("执行完毕");
}
}
6、转换流
桥转换流：InputStreamReader/OutputStreamWriter
特点：
可将字节流转换成字符流
可设置字符的编码方式
InputStreamReader(可以指定使用的编码)
package com.an;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.;
import java.nio.charset.StandardCharsets;
import java.util.;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建InputStreamReader对象
FileInputStream fis = new FileInputStream("d:\aaa.txt");
InputStreamReader dis = new InputStreamReader(fis,"UTF-8");//这里要和文件的编码一样
//读取文件
int data=0;
while((data=dis.read())!=0){
System.out.println((char)data);
}
//关闭
dis.close();
System.out.println("执行完毕");
}
}
OutputStreamWriter
写入文件，使用指定的编码
package com.an;
import com.sun.org.apache.xpath. internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建OutputStreamReader对象
FileOutputStream fis = new FileOutputStream("d:\\aaa.txt");
OutputStreamWriter dis = new OutputStreamWriter(fis,"UTF-8");//这里要和文件的编码一样
//写入文件
for(int i=0;i<10;i++){
dis.write("你好");
dis.flush();
}
//关闭
dis.close();
System.out.println("执行完毕");
}
}
六、File类
代表物理盘符中的一个文件或者文件夹
1、文件的操作
File类的使用：
分隔符
文件操作
文件夹操作
package com.an;
import com.sun.org.apache.xpath. internal.operations.String;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) throws Exception{
separator();
fileOpe();
directoryOpe();
}
//分隔符
public static void separator(){
System.out.println("路径分隔符：" +File.pathSeparator);//路径分隔符为;，参考环境变量
System.out.println("名称分隔符："+File.separator);//名称分隔符为\，参考文件路径
}
//文件操作
public static void fileOpe() throws Exception {
//创建文件：首先要创建一个对象，并填入路径
File fi = new File("d:\\aaa.txt");
System.out.println(fi.toString());//然后在主方法调用fileOpe()，运行结果为d:\\aaa.txt
//此时已经创建好对象，但在文件夹中实际没有这个文件，所以要有判断这个文件是否存在的操作
if(!fi.exists()) {
boolean b = fi.createNewFile();
System.out.println("创建结果：" + b);
}//存在文件为true，返回值false，则创建文件
//删除文件，方法一
System.out.println("删除结果："+fi.delete());//返回值为true或者false
//删除文件，方法二：使用jvm删除
fi.deleteOnExit();
Thread.sleep(5000);//休眠5000后自动删除
//获取文件信息
System.out.println("获取绝对路径:"+fi.getAbsolutePath());
System.out.println("获取路径："+fi.getPath());//代码中写什么路径，就是什么
System.out.println("获取名称："+fi.getName());
System.out.println("获取父目录："+fi.getParent());
System.out.println("获取文件长度："+fi.length());
System.out.println("文件创建时间"+new Date(fi.lastModified()));
//判断
System.out.println("文件是否可读"+fi.canRead());
System.out.println("文件是否是隐藏"+fi.isHidden());
System.out.println("是否是文件"+fi.isFile());
}
public static void directoryOpe() throws Exception{
//创建文件夹
File di = new File("d:\\aaa\\bbb");
System.out.println(di.toString());//此处在main（）里调用directoryOpe()
if(!di.exists()){
System.out.println("创建结果为"+ di.mkdir());//只能创建单级目录
System.out.println("创建结果为"+di.mkdirs());//可以创建多级目录
}
//删除文件，方法一:直接删除，只能删除最低级的目录，且只能删除空目录
System.out.println("删除结果："+di.delete());//返回值为true或者false
//删除文件，方法二：使用jvm删除与直接删除一样
di.deleteOnExit();
Thread.sleep(5000);//休眠5000后自动删除
//获取文件信息
System.out.println("获取绝对路径:"+di.getAbsolutePath());
System.out.println("获取路径："+di.getPath());//代码中写什么路径，就是什么
System.out.println("获取名称："+di.getName());//只能获取最低级目录的名称
System.out.println("获取父目录："+di.getParent());//结果为d:\aaa
System.out.println("获取文件长度："+di.length());
System.out.println("文件创建时间"+new Date(di.lastModified()));
//判断
System.out.println("文件夹是否是隐藏"+di.isHidden());
System.out.println("是否是文件夹"+di.isDirectory());
//遍历文件夹，遍历一个文件夹bbb中的图片
File pi = new File("d:\\aaa\\bbb");
String[] files=pi.list();//获取当前的文件，返回值是一串数组
for(String string:files){//遍历一下
System.out.println(string);
}
}
}
2、FileFilter接口（文件过滤器）
public interface FileFilter
boolean accept(File pathname)
当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件才可以出现在listFiles()的返回值中
//获得bbb文件里jpg格式的图片
File pi = new File("d:\\aaa\\bbb");
Files[] files2=pi.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getname().endsWith(".jpg"))
return true;//符合jpg格式的返回true，否则为false
}
return false;
}
});
for(File file:files2){
System.out.println(file.getName());//遍历写出jpg图片名称
}
3、案例
递归遍历文件夹
package com.an;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.nio.file.Files;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) {
//一个文件夹myfiles里有两个文件和两个文件夹，文件夹里又有文件，要将myfiles里的文件全部显示出来
listDir(new File("d:\\myfiles"));//调用该方法将myfiles传给listDir()方法
}
public static void listDir(File dir) {
File[] files = dir.listFiles();//调用dir里的listFiles()方法，返回值是一个File数组
System.out.println(dir.getAbsoluteFile());
if(files!=null$$files.length>0){
for (File file : files) {//file是myfiles文件夹里的所有文件
if(file.isDirectory()){//如果file是文件夹的话再次调用该方法，实现递归
listDir(file);
}else{
System.out.println(file.getAbsoluteFile());//不是文件夹获取路径
}
}
}
}
}
递归删除文件夹
package com.an;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.*;
import java.nio.charset. StandardCharsets;
import java.nio.file.Files;
import java.util.*;
public class TestHelloWorld {
public static void main(String[] args) {
//一个文件夹myfiles里有两个文件和两个文件夹，文件夹里又有文件，要将myfiles里的文件全部显示出来
//想要删除myfiles文件夹，必须从最低级的那一级文件开始删除
deleteDir(new File("d:\\myfiles"));//调用该方法将myfiles传给listDir()方法
}
public static void deleteDir(File dir) {
File[] files = dir.listFiles();//调用dir里的listFiles()方法，返回值是一个File数组
System.out.println(dir.getAbsoluteFile());
if(files!=null$$files.length>0){
for (File file : files) {//file是myfiles文件夹里的所有文件
if(file.isDirectory()){//如果file是文件夹的话再次调用该方法，实现递归
deleteDir(file);
}else{
System.out.println(file.getAbsoluteFile()+"删除"+delete());//删除文件
}
}
}
System.out.println(dir.getAbsoluteFile()+"删除"+dir.delete());//把所有子文件删除后，最后要将myfiles文件删除
}
}
4、properties
是一个属性集合
特点：
-
存储属性名和属性值
-
属性名和属性值都是字符串类型
-
没有泛型（是一种参数化类型，数据类型被指定为一个参数，也就是不确定的数据类型）
-
和流有关
package com.an;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.;
import java.nio.charset. StandardCharsets;
import java.nio.file.Files;
import java.util.;public class TestHelloWorld {
public static void main(String[] args) {
//创建一个集合
Properties properties = new Properties();
//添加数据
properties.setProperty("username","张三");
properties.setProperty("age","22");
System.out.println(properties.toString());
//遍历：keyset、entrySet、StringPropertiesNames()
Set<java.lang.String> pronames = properties.stringPropertyNames();
for (java.lang.String pro : pronames) {
System.out.println(pro+"----"+properties.getProperty());
}
//和流有关的方法
PrintWriter pw=new PrintWriter("d:\:print.txt");
properties.list(pw);//将集合里的内容存入txt文件
pw.close();
//store()方法 保存
FileOutputStream fos = new FileOutputStream("d:\print.properties");
properties.store(fos,"注释");
fos.close();
//load() 加载
Properties properties2 = new Properties();
FileInputStream hi = new FileInputStream("d:\aaa.txt");
properties2.load(hi);
hi.close();
System.out.println(properties2.toString());}
}
七、总结
