JavaSE:IO框架
文章目录
前言
即使再小的帆也能远航
一、IO框架课程目标
- 流的概念
- 流的分类
- 字节流
- 编码方式
- 字符流
- File类
二、什么是流
- 概念:
- 内存与存储设备(硬盘)之间传输数据的通道
三、流的分类
- 按流的方向【重点】:
- 输入流(input):将<存储设备>中的内容读入到<内存>中
- 输出流(output):将<内存>中的内容写入到<存储设备>中
文件----输入流---->程序
- 按存储单位:
- 字节流:以字节为单位,可以读写所有数据
- 字符流:以字符为单位,只能读写文本数据
- 按功能:
- 节点流:具有实际传输数据的读写功能
- 过滤流:在节点流的基础之上增强功能
四、字节流
1. 字节流的父类(抽象类):
- InputStream:字节输入流
- public int read(){}
- public int read(byte[] b){}
- public int read(byte[] b,int off,int len){}
- OutputStream:字节输出流
- public int write(){}
- public int write(byte[] b){}
- public int write(byte[] b,int off,int len){}
2. 文件字节流(字节流抽象类的子类):
- FileInputStream:
- public void read(byte[] b) //从流中读取多个字节,将读到内容存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1
- FileOutputStream:
- public void write(byte[] b) //一次写多个字节,将b数组中所有字节,写入输出流
import java.io.FileInputStream;
/**
* FileInputStream的使用
* 文件字节输入流
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1. 创建
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//2. 读取文件
//2.1 单个字节读取
// int data = 0;
// while((data = fis.read())!=-1){
// System.out.println((char) data);
// }
// System.out.println("========");
//2.2 一次读取多个字节
// byte[] buf = new byte[3];
// int count = fis.read(buf);
// System.out.println(new String(buf));
// System.out.println(count);
// int count2 = fis.read(buf);
// System.out.println(new String(buf));
// System.out.println(count2);
// int count3 = fis.read(buf);
// System.out.println(new String(buf));
// System.out.println(count3);
// int count4 = fis.read(buf);
// System.out.println(new String(buf));
// System.out.println(count4);
byte[] buf = new byte[3];
int count = 0;
while((count=fis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3. 关闭
fis.close();
System.out.println("执行关闭");
}
}
import java.io.FileOutputStream;
/**
* FileOutputStream文件字节输出流的使用
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//1. 创建
FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
//append添加方法 有true就接着往下写,没有true就执行覆盖添加
//2. 写入文件
//2.1 单个单个字节写入
fos.write(97);
fos.write('b');
fos.write('c');
fos.write('\n');
//2.2 多个字节一次写入
String string = "helloworld";
fos.write(string.getBytes());
fos.write('\n');
//3. 关闭
fos.close();
System.out.println("执行完毕");
}
}
3. 字节流复制文件
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 使用文件字节流实现文件的复制
* (复制一次等于输入一次加输出一次)
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
//1. 创建流
//1.1 文件字节输入流
FileInputStream fis = new FileInputStream("d:\\001.png");
//1.2 文件字节输出流
FileOutputStream fos = new FileOutputStream("d:\\002.jpg");
//2. 一边读,一边写
byte[] buf = new byte[1024];
int count = 0;
while((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
}
//3. 关闭
fis.close();
fos.close();
System.out.println("复制完毕");
}
}
4. 字节缓冲流
- 缓冲流:BufferedInputStream/BufferedOutputStream
- 提高IO效率,减少访问磁盘的次数
- 数据存储在缓冲区中,flush是将缓存区的内容写入文件中,也可以直接close
- BufferedInputStream:字节输入缓冲流
- BufferedOutputStream;字节输出缓冲流
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
* BufferedInputStream使用字节缓冲流读取
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
//1. 创建
FileInputStream fis = new FileInputStream("d:\\aaa.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//2. 读取
//先读取到数组,再从数组里读取单个字节来输出
// int data = 0;
// while ((data = bis.read())!=-1){
// System.out.print((char)data);
// }
//
byte[] buf = new byte[1024];
int count = 0;
while ((count = bis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3. 关闭
bis.close();
//关闭bis默认fis一起关闭
}
}
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/**
* BufferedOutputStream使用字节缓冲流写入文件
*/
public class Demo05 {
public static void main(String[] args) throws Exception{
//1. 创建
FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//2. 写入文件
for (int i = 0; i < 10; i++) {
bos.write("helloworld\r\n".getBytes()); //先写入了8k的缓冲区内
bos.flush();//刷新硬盘
}
//3. 关闭(内部默认一起调用flush方法)
bos.close();
}
}
5. 对象流
- 对象流:ObjectInputStream/ObjectOutputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能
- readObject() 从流中读取一个对象
- writeObject(Object obj) 向流中写入一个对象
- 使用流传输对象的过程称为序列化、反序列化
- 从内存中写入文件到硬盘中的过程称之为序列化,反之为反序列化
1. 序列化
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/**
* 使用ObjectOutputStream实现对象的序列化(写入文件)
* 要求:序列化类名必须要实现Serializable接口
*/
public class Demo06 {
public static void main(String[] args) throws Exception{
//1. 创建
FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2. 序列化(写入操作)
Student zhangsan = new Student("张三",20);
oos.writeObject(zhangsan);
//3. 关闭
oos.close();
System.out.println("序列化完毕");
}
}
import java.io.Serializable;
public class Student implements Serializable {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
2. 反序列化
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
* 使用ObjectInputStream实现反序列化(读取重构成对象)
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
//1. 创建
FileInputStream fis = new FileInputStream("d:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//2. 读取文件(反序列化)
Student s = (Student) ois.readObject();
//3. 关闭
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());
}
}
3. 序列化和反序列化 注意事项
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
/**
* 使用ObjectOutputStream实现对象的序列化(写入文件)
* 要求:
* (1)序列化类名必须要实现Serializable接口
* (2)序列化类中的对象属性(内部类)要求也要实现Serializable接口
* (3)序列化版本号ID,即serialVersionUID,保证序列化的类和反序列化的类是同一个类
* (4)使用transient(瞬间的)修饰属性,这个属性就不能被序列化
* (5)静态属性不能被序列化
* (6)序列化多个对象,可以借助集合实现
*/
public class Demo06 {
public static void main(String[] args) throws Exception{
//1. 创建
FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2. 序列化(写入操作)
Student zhangsan = new Student("张三",20);
Student lisi = new Student("李四",22);
// oos.writeObject(zhangsan);
// oos.writeObject(lisi);
ArrayList<Student> list = new ArrayList<>();
list.add(zhangsan);
list.add(lisi);
oos.writeObject(list);
//3. 关闭
oos.close();
System.out.println("序列化完毕");
}
}
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
/**
* 使用ObjectInputStream实现反序列化(读取重构成对象)
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
//1. 创建
FileInputStream fis = new FileInputStream("d:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//2. 读取文件(反序列化)
// Student s = (Student) ois.readObject();
// Student s2 = (Student) ois.readObject();
ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
//3. 关闭
ois.close();
System.out.println("执行完毕");
// System.out.println(s.toString());
// System.out.println(s2.toString());
System.out.println(list.toString());
}
}
import java.io.Serializable;
public class Student implements Serializable {
/**
* serialVersionUID:序列号版本ID
*/
private static final long serialVersionUID = 100L;
private String name;
private transient int age;
public static String country = "中国";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
五、常见字符编码
-
ISO-8859-1 收录除ASCII外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
-
UTF-8 针对Unicode码表的可变长度字符编码
-
GB2312 简体中文,95年前
-
GBK 简体中文、扩充,95年后
-
BIG5 台湾,繁体中文
当编码方式和解码方式不一致时,会出现乱码
六、字符流
1. 字符流的父类(抽象类)
- Reader:字符输入流
- Writer:字符输出流
import java.io.FileInputStream;
/**
* 字符流:
* 一个汉字是三个字节
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1. 创建
FileInputStream fis = new FileInputStream("d:\\hello.txt");
//2. 读取文件
//2.1 单个字节读取
// int data = 0;
// while((data = fis.read())!=-1){ //12个字节(4个汉字)
// System.out.println((char) data);
// }
// System.out.println("========");
//2.2 一次读取多个字节
byte[] buf = new byte[3];
int count = 0;
while((count=fis.read(buf))!=-1){
System.out.print(new String(buf,0,count));
}
//3. 关闭
fis.close();
System.out.println("\n执行关闭");
}
}
2. 文件字符流
- FileReader:
public int read(char[] c) //从流中读取多个字符,将读到内容存入c数组,返回实际读到的字符数;如果达到文件的尾部,则返回-1 - FileWriter:
- public void write(String str) //一次写多个字符,将b数组中所有字符,写入输出流
import java.io.FileReader;
/**
* 使用FileReader读取文件
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//1. 创建
FileReader fr = new FileReader("d:\\hello.txt");
//2. 读取
//2.1 单个字符读取
// int data = 0;
// while((data=fr.read())!=-1){ //读取一个字符
// System.out.print((char)data);
// }
//2.2 多个字符读取
char[] buf = new char[1024];
int count = 0;
while((count = fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
//3. 关闭
fr.close();
}
}
import java.io.FileWriter;
/**
* 使用FileWriter写入文件
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
//1. 创建
FileWriter fw= new FileWriter("d:\\write.txt");
//2. 写入
for (int i = 0; i < 10; i++) {
fw.write("java是世界上最好的语言\r\n");
fw.flush();
}
//3. 关闭
fw.close();
System.out.println("执行关闭");
}
}
3. 字符流复制文件
import java.io.FileReader;
import java.io.FileWriter;
/**
* 使用FileReader和FileWriter复制文本文件,不能复制图片或二进制文件
* 使用字节流可以复制任意文件
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
//1. 创建
FileReader fr = new FileReader("d:\\write.txt");
FileWriter fw = new FileWriter("d:\\write2.txt");
//2. 读写
int data = 0;
while((data=fr.read())!=-1){
fw.write(data);
fw.flush();
}
//3. 关闭
fr.close();
fw.close();
System.out.println("复制完毕");
}
}
4. 字符缓冲流
- 缓冲流:BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行、读一行
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 使用字符缓冲流读取文件
* BufferedReader
*/
public class Demo05 {
public static void main(String[] args) throws Exception{
//1. 创建
FileReader fr = new FileReader("d:\\write.txt");
BufferedReader br = new BufferedReader(fr);
//2. 读取
//2.1 单个单个读
// char[] buf = new char[1024];
// int count = 0;
// while((count=br.read(buf))!=-1){
// System.out.print(new String(buf,0,count));
// }
//2.2 一行一行读
String line = null;
while((line=br.readLine())!=null){
System.out.println(line);
}
//3. 关闭
br.close();
}
}
import java.io.BufferedWriter;
import java.io.FileWriter;
/**
* BufferedWriter的使用
*/
public class Demo06 {
public static void main(String[] args) throws Exception{
//1. 创建
FileWriter fw = new FileWriter("d:\\buffer.txt");
BufferedWriter bw = new BufferedWriter(fw);
//2. 写入
for (int i = 0; i < 10; i++) {
bw.write("好好学习,天天向上");
bw.newLine(); //写入一个换行符 windows \r\n Linux \n
bw.flush();
}
//3. 关闭
bw.close();
System.out.println("执行完毕");
}
}
5. 打印流
- PrintWriter:
- 封装了print() / println() 方法,支持写入后换行
- 支持数据原样打印
/**
* PrintWriter的使用
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
//1. 创建
PrintWriter pw = new PrintWriter("d:\\print.txt");
//2. 打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
pw.println("无语");
//3. 关闭
pw.close();
System.out.println("执行完毕");
}
}
6. 转换流
- 桥转换流:InputStreamReader / OutputStreamReader
- 可将字节流转换为字符流
- 可设置字符的编码方式
- InputStreamReader:字节流(硬盘)通向字符流(内存)的桥梁
- OutputStreamReader:字符流(内存)通向字节流(硬盘)的桥梁
import java.io.FileInputStream;
import java.io.InputStreamReader;
/**
* 使用InputStreamReader读取文件,指定使用的编码
*/
public class Demo08 {
public static void main(String[] args) throws Exception{
//1. 创建
FileInputStream fis = new FileInputStream("d:\\write.txt");
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
//必须保证文件的编码和指定的编码是一致的,否则会出现乱码
//2. 读取
int data = 0;
while((data=isr.read())!=-1){
System.out.print((char)data);
}
//3. 关闭
isr.close();
}
}
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/**
* 使用OutputStreamWriter写入文件,使用指定的编码
*/
public class Demo09 {
public static void main(String[] args) throws Exception{
//1. 创建
FileOutputStream fos = new FileOutputStream("d:\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
//2. 写入
for (int i = 0; i < 10; i++) {
osw.write("我爱北京,我爱故乡!\r\n");
osw.flush();
}
//3. 关闭
osw.close();
System.out.println("执行成功");
}
}
七、File类
1.File类
- 概念:代表物理盘符中的一个文件或者文件夹
- 方法:
- createNewFile() //创建一个新文件
- mkdir() //创建一个新目录
- delete() //删除文件或空目录
- exists() //判断File对象所代表的对象是否存在
- getAbsolutePath() //获取文件的绝对路径
- getName() //获取文件的绝对路径
- getParent() //获取文件/目录所在的目录 (父目)
- isDirectory() //是否是目录
- isFile() //是否是文件
- length() //获取文件的长度
- listFiles() //列出目录中的所有内容
- renameTo() //修改文件名为
2. 文件操作
import java.io.File;
import java.util.Date;
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
// separator();
fileOperator();
}
//(1)分隔符
public static void separator(){
System.out.println("路径分隔符:"+ File.pathSeparator);
System.out.println("名称分隔符:"+File.separator);
}
//
public static void fileOperator() throws Exception{
//1. 创建文件
File file = new File("d:\\file.txt");
// File file = new File("file.txt");
//System.out.println(file);
if(!file.exists()) {
boolean b = file.createNewFile();
System.out.println("创建结果:" + b);
}
//2. 删除文件
//2.1 直接删除
// System.out.println("删除结果:"+file.delete());
//2.2 使用JVM退出时删除
// file.deleteOnExit();
// Thread.sleep(5000); //休眠(等待)5秒钟
//3. 获取文件信息
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("文件创建时间:"+new Date(file.lastModified()).toLocaleString());
//4. 判断
System.out.println("是否可写:"+file.canWrite()); //属性-->只读
System.out.println("是否是文件:"+file.isFile());
System.out.println("是否隐藏:"+file.isHidden()); //属性-->隐藏
}
}
3. 文件夹
import java.io.File;
import java.util.Date;
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
// separator();
// fileOperator();
directoryOper();
}
//(3)文件夹操作
public static void directoryOper() throws Exception{
//1. 创建文件夹
File dir = new File("d:\\aaa\\bbb\\ccc");
System.out.println(dir.toString());
if(!dir.exists()){
// dir.mkdir(); //只能创建单级目录
System.out.println("创建结果:"+dir.mkdirs()); //创建多级目录
}
//2. 删除文件夹
//2.1 直接删除(空目录,且只删除最后一级)
// System.out.println("删除结果:"+dir.delete());
//2.2 使用JVM删除
// dir.deleteOnExit();
// Thread.sleep(5000);
//3. 获取文件夹信息
System.out.println("获取绝对路径:"+dir.getAbsolutePath());
System.out.println("获取路径:"+dir.getPath());
System.out.println("获取文件夹名称"+dir.getName());
System.out.println("获取父目录:"+dir.getParent());
System.out.println("文件创建时间:"+new Date(dir.lastModified()).toLocaleString());
//4. 判断
System.out.println("是否是文件夹:"+dir.isDirectory());
System.out.println("是否隐藏:"+dir.isHidden()); //属性-->隐藏
//5. 遍历文件夹
File dir2 = new File("d:\\图片");
String[] files = dir2.list(); //list()返回一个字符串数组 //listFiles()返回一个file数组
System.out.println("========");
for (String file : files) {
System.out.println(file);
}
}
}
4. FileFilter接口
- public interface FileFilter
- boolean accept(File pathname)
- 当调用File类中的listFiles()方法时,支持传入FileFilter接口接口实现类,对获取文件进行过滤,只有满足条件的文件才可出现在listFiles()的返回值中
import java.io.File;
import java.io.FileFilter;
import java.util.Date;
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
// separator();
// fileOperator();
directoryOper();
}
//(3)文件夹操作
public static void directoryOper() throws Exception{
//5. 遍历文件夹
File dir2 = new File("d:\\图片");
String[] files = dir2.list(); //list()返回一个字符串数组 //listFiles()返回一个file数组
System.out.println("========");
for (String string : files) {
System.out.println(string);
}
//6. FileFilter接口的使用
System.out.println("========");
File[] files2 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".jpg")) {
return true;
}
return false;
//返回值为true,则返回所有文件
}
});
for (File file : files2) {
System.out.println(file.getName());
}
}
}
5. 递归遍历和递归删除
import java.io.File;
/**
* 案例1:递归遍历文件夹
* 案例2:递归删除文件夹
*/
public class ListDemo {
public static void main(String[] args) {
// listDir(new File("d:\\图片"));
deleteDir(new File("d:\\图片"));
}
//案例1:递归遍历文件夹
public static void listDir(File dir){
File[] files = dir.listFiles();
System.out.println("文件夹:\n"+dir.getName()+"\n"+dir.getAbsolutePath());
if(files!=null&&files.length>0){
for (File file : files) {
if(file.isDirectory()){
listDir(file);
}else{
System.out.println("文件名:\n"+file.getName()+"\n"+file.getAbsolutePath());
}
}
}
}
//案例2:递归删除文件夹
public static void deleteDir(File dir){
File[] files = dir.listFiles();
if(files!=null&&files.length>0){
for (File file : files) {
if(file.isDirectory()){
deleteDir(file); //递归
}else{
System.out.println("文件名:\n"+file.getName()+"\n"+file.getAbsolutePath()+"\n删除了"+file.delete());
}
}
System.out.println("文件夹:\n"+dir.getName()+dir.getAbsolutePath()+"\n删除了"+dir.delete());
}
}
}
八、Properties
- Properties:属性集合
- 特点:
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
- 使用:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;
/**
* Properties集合的使用
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//1. 创建集合
Properties properties = new Properties();
//2. 添加数据
properties.setProperty("username","zhangsan");
properties.setProperty("age","20");
System.out.println(properties.toString());
//3. 遍历
//3.1 keySet
//3.2 entrySet
//3.3 StringPropertyNames()
// Set<String> pronames = properties.stringPropertyNames();
// for (String pro : pronames) {
// System.out.println(pro+"===="+properties.getProperty(pro));
// }
//4. 和流有关的方法
//4.1 list方法
// PrintWriter pw = new PrintWriter("d:\\print.txt");
// properties.list(pw);
// pw.close();
// System.out.println("执行完毕");
//4.2 store方法 保存
// FileOutputStream fos = new FileOutputStream("d:\\store.properties");
FileOutputStream fos = new FileOutputStream("d:\\printOut.txt");
// properties.store(fos,"注释");
// fos.close();
// System.out.println("执行完毕2");
//4.3 load方法 加载
Properties properties2 = new Properties();
FileInputStream fis = new FileInputStream("d:\\store.properties");
properties2.load(fis);
fis.close();
System.out.println(properties2.toString());
}
}
总结
即使再小的帆也能远航