I/O框架
1、流的概念
- 内存与存储设备之间传输数据的通道
2、流的分类
按方向【重点】：
- 输入流：将《存储设备》中的内容读到《内存》中
- 输出流：将《内存》中的内容写入到《存储设备》中
按单位
- 字节流：以字节为单位，可以读取所有数据
- 字符流：以字符为单位，只能读取文本数据
按功能
- 节点流：具有实际传输数据的读写功能
- 过滤流：在节点流的基础之上增强功能
3、字节流
3.1、字节流的父类（抽象类）:
InputStream： 字节输入流
- public int read() {}
- public intread (byte[] b) {}
- public int read (byte[] b, int off, int len) {}
已知直接子类：
AudioInputstream , ByteArrayInputstream, FileInputstream
FilterInputstream, Inputstream , objectInputstream, PipedInputstream
SequenceInputstream , StringBufferInputstream
public abstract class InputStream
extends Object
implements Closeable这个抽象类是表示输入字节流的所有类的超类。
需要定义InputStream子类的应用InputStream必须始终提供一种返回输入的下一个字节的方法。
OutputStream： 字节输出流
- public void write (int n) {}
- public void write (byte[] b){}
- public void write(byte[]b,int off, int len) {}
已知直接子类：
ByteArrayOutputstream , FileOutputstream , FilterOutputstream
obiectoutputstream, Outputstream , PipedOutputstream
public abstract class OutputStream
extends Object
implements Closeable, Flushable这个抽象类是表示字节输出流的所有类的超类。 输出流接收输出字节并将其发送到某个接收器。
需要定义OutputStream子类的应用OutputStream必须至少提供一个写入一个字节输出的方法。
3.2、文件字节流-File
FileInputStream：
-
方法：
int read() 从该输入流读取下一个数据字节。 int read(byte[] b) 从该输入流读取最多 byte.length个字节的数据到字节数组。 int read(byte[] b, int off, int len) 从该输入流读取最多 len字节的数据到字节数组。 int available() 返回从该输入流中可以读取（或跳过）的字节数的估计，而不会被下一个调用者阻塞该输入流的方法。 void close() 关闭此输入流并释放与流相关联的任何系统资源。 void mark(int readlimit) 标记此输入流中的当前位置。 boolean markSupported() 测试这个输入流是否支持 mark和 reset方法。 void reset() 将此流重新定位到上次在此输入流上调用 mark方法时的位置。 long skip(long n) 跳过并从输入流中丢弃 n个字节的数据。 -
构造方法
FileInputStream(File file)
通过打开与实际文件的连接创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name)
通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
FileInputStream(FileDescriptor fdObj)
创建 FileInputStream通过使用文件描述符 fdObj ，其表示在文件系统中的现有连接到一个实际的文件。
FileOutPutStream：
- 方法
void write(byte[] b)
将 b.length个字节写入此输出流。
void write(byte[] b, int off, int len)
将 len字节从位于偏移量 off的指定 byte阵列写入此输出流。
void write(int b)
写入指定 byte此输出流。
void close()
关闭此输出流并释放与流相关联的任何系统资源。
void flush()
刷新此输出流，并强制将任何缓冲的输出字节写入流。
3.3、案例-复制文件
public static void main (String[] args) throws Exception{
//字节输入流
FileInputStream inputStream = new FileInputStream("e:\\aaa\\001.png");
//字节输出流
FileOutputStream outputStream = new FileOutputStream("e:\\aaa\\002.png");
//复制，一边读一边写
byte[] buf = new byte[1024];
int count = 0;
while ( ( count = inputStream.read(buf) ) !=-1 ){
outputStream.write(buf,0,count);
}
//关闭
inputStream.close();
outputStream.close();
}
3.4、字节缓冲流-Buffered
缓冲流: BufferedInputStream/BufferedoutputStream
- 提高IO效率,减少访问磁盘的次数;
- 数据存储在缓冲区中, flash是将缓存区的内容写入文件中,也可以直接close.
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("e:\\aaa\\aaa.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//读取
int data = 0;
while ((data = bis.read())!=-1){
System.out.print((char) data);
}
//关闭
bis.close();
}
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("e:\\aaa\\ccc.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
for (int i = 0; i < 10; i++) {
//写入8k的缓存区
bos.write("helloworld\r\n".getBytes(StandardCharsets.UTF_8));
bos.flush();//刷新到硬盘
}
//3 关闭，内部调用flush方法
bos.close();
3.5、对象流-Object
- 对象流: Object0utputStream/0bjectInputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能
- readobject()从流中读取一个对象
- writeobject(0bject obj)向流中写入一个对象
使用流传输对象的过程称为序列化、反序列化
/**
*ObjectOutputStream实现对象的序列化
* 要求：
* 1 序列化类必须要实现Serializable接口（标记能序列化作用）
* 2 序列化类中对象属性要求实现Serializable接口
* 3 serialVersionUID序列化版本ID.作用：保证序列化的类和反序列化的类是同一个类（相当于一个版本号）
* 4 使用transient修饰属性，这个属性不能序列化
* 5 静态属性不能序列化
* 6 序列化多个对象，可以借助集合
*/
public static void main(String[] args) throws Exception{
FileOutputStream fos = new FileOutputStream("e:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//序列化，写入操作
Student zs = new Student("张三",20);
Student ls = new Student("李四",20);
// oos.writeObject(zs);
// oos.writeObject(ls);
ArrayList<Student> arr = new ArrayList<>();
arr.add(zs);
arr.add(ls);
oos.writeObject(arr);
//关闭
oos.close();
System.out.println("系列化成功");
}
/**
*ObjectInputStream实现对象的反序列化
* 要求：
* 1 序列化类必须要实现Serializable接口（标记能序列化作用）
* 2 序列化类中对象属性要求实现Serializable接口
*/
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("e:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//读取文件（反序列化）
// Student s= (Student) ois.readObject();
// Student s2 = (Student) ois.readObject();
ArrayList<Student> arrlist = (ArrayList<Student>) ois.readObject();
ois.close();
System.out.println(arrlist.toString());
// System.out.println(s.toString());
// System.out.println(s2.toString());
}
//student
//没有警告可以到setting中搜索并勾选 Serializable class without serialVersionUID
public class Student implements Serializable {
//序列化版本ID.
private static final long serialVersionUID = 5792432913810162435L;
private String name;
private int age;
}
4、编码方式
字符编码
- IS0-8859-1 收录除ASCII外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
- UTF-8 针对Unicode码表的可变长度字符编码
- GB2312 简体中文
- GBK 简体中文、扩充
- BIG5 台湾,繁体中文
- 编码方式和解码方式不一致时，会出现乱码
5、字符流
5.1、字符流的父类（抽象类）
- Reader: 字符输入流
- public int read() {}
- public int read (char[] c){}
- public int read(char[] b, int off, int 1en){}
- Writer:字符输出流
- public void write(int n) {}
- public void write(String str){}
- public void write (char[] c){}
5.2、文件字符流（子类）
FileReader:
- public int read (char[] c) //从流中读取多个字符,将读到内容存入数组,返回实际读到的字符数;如果达到文件的尾部,则返回-1
FileWriter:
- public void write (String str) //一次写多个字符,将b数组中所有字符,写入输出流。
public static void main(String[] args) throws IOException {
//只能复制文本(有字符编码的)
FileReader fr = new FileReader("E:\\aaa\\write.txt");
FileWriter fw = new FileWriter("E:\\aaa\\write1.txt");
int data = 0;
while ((data = fr.read())!=-1){
fw.write(data);
fw.flush();
}
fr.close();
fw.close();
}
5.3、字符缓冲流-buffered
- 缓冲流: Bufferedeader/BufferedWriter
- 高效读写
- 支持输入换行符。
- 可一次写一行、读一行。
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("e:\\aaa\\3.txt");
BufferedReader br = new BufferedReader(fr);
//读取
// char[] buf = new char[1024];
// int con = 0;
// while ((con = br.read(buf))!=-1){
// System.out.println(new String(buf,0,con));
// }
//读一行
String line=null;
while ((line = br.readLine())!= null){
System.out.println(line);
}
br.close();
}
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("e:\\aaa\\3.txt");
BufferedWriter bw = new BufferedWriter(fw);
// 写入
for (int i = 0; i < 10; i++) {
bw.write("java-" + i );
bw.newLine();//换行
bw.flush();
}
bw.close();
}
5.4、打印流PrintWriter
- PrintWriter:
- 封装了print () / printIn()方法,支持写入后换行。
- 支持数据原样打印
public static void main(String[] args) throws FileNotFoundException {
PrintWriter pw = new PrintWriter("E:\\aaa\\aaa.txt");
pw.println(97);//写入原样
pw.println(true);
pw.println(3.14);
pw.println('a');
pw.close();
}
5.5、转换流
- 桥转换流: InputStreamReader/0utputStreamWriter
- 可将字节流转换为字符流。
- 可设置字符的编码方式。
public static void main(String[] args) throws Exception {
FileInputStream fs = new FileInputStream("e:\\aaa\\aaa.txt");
FileOutputStream fos = new FileOutputStream("e:\\aaa\\aaa.txt");
InputStreamReader isr = new InputStreamReader(fs,"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
}
6、File类
- 概念: 代表物理盘符中的一个文件或者文件夹。
- 方法:
- createNewFile()//创建一个新文件
- mkdir()//创建一个新目录
- delete () //删除文件或空目录
- exists 按类型屏蔽
- e象所代表的对象是否存在
- getAbsolutePath ()//获取文件的绝对路径
- getName ()//取得名字
- getParent 0)//获取文件/目录所在的目录
- isDirectory()//是否是目录
- isFile )//是否是文件
- length()//获得文件的长度
- listFiles 0/列出目录中的所有内容
- renameTo()/修改文件名为
//分隔符
public static void separator(){
System.out.println("路径："+ File.pathSeparator);
System.out.println("名称："+ File.separator);
}
//文件操作
public static void fileOpe() throws Exception {
//1创建文件
File file = new File("e:\\aaa\\file.txt");
if(!file.exists()){
boolean b = file.createNewFile();
System.out.println("创建"+b);
}
//2 删除文件
// //直接删除
// System.out.println("删除："+file.delete());
// //jvm退出时删除
// file.deleteOnExit();
// Thread.sleep(6);
//3 获取文件信息
System.out.println("绝对路径"+file.getAbsolutePath());
System.out.println("路径"+file.getPath());
System.out.println("父目录"+file.getParent());
System.out.println("文件长度"+file.length());
System.out.println("文件创建时间"+new Date(file.lastModified()).toLocaleString());
//4 判断
System.out.println("是否可读"+file.canRead());
System.out.println("是否可写"+file.canWrite());
System.out.println("是否是文件"+file.isFile());
System.out.println("是否隐藏"+file.isHidden());
}
//文件夹操作
public static void directoryOpe(){
File dir = new File("e:\\aaa\\bbb\\ccc");
System.out.println("创建目录："+dir.toString());
if (!dir.exists()){
// dir.mkdir();//创建单级目录
System.out.println(dir.mkdirs());//创建多级目录
}
//2直接删除
// System.out.println(dir.delete());//只能删除空目录
//2 jvm删除
//jvm退出时删除
// file.deleteOnExit();
// Thread.sleep(6);
//3获取文件夹信息,和文件一样
//4判断。
System.out.println("是否文件夹"+dir.isDirectory());
//5遍历文件夹
File dir2 = new File("e:\\aaa");
String[] str = dir2.list();
for (String s : str) {
System.out.println(s);
}
}
6.1、FileFilter接口
- public interface FileFilter
- boolean accept (File pathname)
- 当调用File类中的1istFiles()方法时,支持传入FileFilter接口接口实现类,对获取文件进行过滤,只有满足条件的文件的才可出现在listFiles()的返回值中。
//FileFilter使用
File[] files2 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".png")){
return true;
}
return false;
}
});
for (File file : files2) {
System.out.println(file.getName());
}
}
6.2、递归遍历和删除文件
public static void main(String[] args) {
// getFileName(new File("E:\\ccc"));
delDir(new File("E:\\ccc"));
}
//递归遍历文件
public static void getFileName(File file){
File[] files = file.listFiles();
if (files!=null && files.length>0){
for (File file1 : files) {
if (file1.isDirectory()){
getFileName(file1);
}else{
System.out.println(file1.getAbsolutePath());
}
}
}
}
//递归删除文件夹和文件
public static void delDir(File dir){
File[] files = dir.listFiles();
if (files!=null && files.length>0){
for (File file : files) {
if (file.isDirectory()){
delDir(file);
}else{
// 删除文件
System.out.println(file.getAbsolutePath()+"删除："+file.delete());
}
}
}
System.out.println(dir.getAbsolutePath()+"删除："+dir.delete());
}
7、Properties集合
- Properties:属性集合
- 特点
- 1存储属性名和属性值
- 2属性名和属性值都是字符串类型
- 3没有泛型
- 4和流有关
public static void main(String[] args) throws IOException {
//1 创建集合
Properties properties = new Properties();
//2 添加数据
properties.setProperty("name","zhangsan");
properties.setProperty("age","20");
System.out.println(properties.toString());
//遍历
//keySet
//entrySet
//stringPropertyNames
Set<String> strings = properties.stringPropertyNames();
for (String string : strings) {
System.out.println(string+"-"+properties.getProperty(string));
}
System.out.println("__________4______________");
//4 流相关方法
//4.1 list 写入
PrintWriter pw = new PrintWriter("e:\\aaa\\print.txt");
properties.list(pw);
pw.close();
// 4.2 store 写入
FileOutputStream fos = new FileOutputStream("e:\\aaa\\store.properties");
properties.store(fos,"注释" );
fos.close();
//4.3 load 加载
Properties properties2 = new Properties();
FileInputStream fis = new FileInputStream("e:\\aaa\\store.properties");
properties2.load(fis);
fis.close();
System.out.println(properties2.toString());
}
总结
- 流的概念:
- 内存与存储设备之间传输数据的通道。
- 流的分类：
- 输入流、输出流；字节流、字符流；节点流、过滤流；
- 序列化、反序列化:
- 将对象通过流写入到文件,或将对象通过流读取到内存,必须实现Serializable接口。
- File对象:
- 代表物理盘符中的一个文件或者文件夹。
168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
