I/O框架
流的概念
- 概念:内存与存储设备之间传输数据的通道
流的分类
- 按方向
- 输入流:将存储设备中的内容读入到内存中
- 输出流:将内存中的内容写入到存储设备中
- 按单位
- 字节流:以字节为单位,可以读写所有数据
- 字符流:以字符为单位,只能读写文本数据
- 按功能
- 节点流:具有实际传输数据的读写功能
- 过滤流:在节点流的基础上增加功能
字节流
- 字节流的父类(抽象类):
- InputStream:字节输入流
- OutputStream:字节输出流
文件字节流
- FileInputStream
package ioframe;
import java.io.FileInputStream;
public class Demo01 {
public static void main(String[] args) throws Exception{
//创建FileInputStream,指定文件路径
FileInputStream file = new FileInputStream("e:\\aaa.txt");
//读取文件
//单个字节读取,file.read();
/*
int data = 0;
while((data=file.read())!=-1){
System.out.print((char)data);
}
*/
//读取多个字节
byte[] buf = new byte[1024];
int count = 0;
while ((count= file.read(buf))!= -1){
System.out.println(new String(buf,0,count));
}
//关闭
file.close();
System.out.println();
System.out.println("执行完毕");
}
}
- FileOutputStream
package ioframe;
import java.io.FileOutputStream;
/**
* 文件字节输出流
* FileOutputStream
*/
public class Demo02 {
public static void main(String[] args) throws Exception {
//创建文件字节输出流
FileOutputStream fos = new FileOutputStream("e:\\aaa.txt");
//写入文件
//单个字符
fos.write(97);
fos.write('b');
fos.write('c');
//字符串
String str = "hello world";
fos.write(str.getBytes());
//关闭
fos.close();
System.out.println("执行完毕");
}
}
字节流复制文件
package ioframe;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 使用文件字节流实现文件复制
*/
public class Demo03 {
public static void main(String[] args) throws Exception {
//创建流
//文件字节输入流
FileInputStream fis = new FileInputStream("e:\\111.jpg");
//文件字节输出流
FileOutputStream fos = new FileOutputStream("e:\\222.jpg");
//一边读一边写
byte[] buf =new byte[1024];
int count =0;
while ((count = fis.read(buf))!=-1){
fos.write(buf,0,count);
}
fis.close();
fos.close();
System.out.println("复制完毕");
}
//关闭
fos.close();
System.out.println("执行完毕");
}
字节缓冲流
- 提高IO效率,减少访问磁盘的次数
- 数据存储在缓冲区中,flush是将缓冲区的内容写入文件中,也可以直接close
- 内部维护一个8K的缓冲区
BufferedInputStream
private static int DEFAULT_BUFFER_SIZE = 8192;
package ioframe;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
* 使用字节缓冲流读取
* BufferedInputStream
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
//创建BufferedInputStream
FileInputStream fis = new FileInputStream("e:\\aaa.txt");
BufferedInputStream bis =new BufferedInputStream(fis);
//读取
int data =0;
while ((data=bis.read())!=-1){
System.out.print((char)data);
}
}
}
BufferedOutputStream
package ioframe;
/**
* 使用字节缓冲流写入文件
* BufferedOutputStream
*/
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
public class Demo05 {
public static void main(String[] args) throws Exception{
//创建字节输出缓冲流
FileOutputStream fos =new FileOutputStream("e:\\buffer.txt");
BufferedOutputStream bos =new BufferedOutputStream(fos);
//写入文件
for (int i = 0; i <10 ; i++) {
//没超过8K,写入缓冲区
String str ="helloworld\r\n";
bos.write(str.getBytes());
//刷新到硬盘
bos.flush();
}
System.out.println("写入完毕");
//关闭(默认内部调用flush方法)
bos.close();
}
}
对象流
-
ObjectInputStream/ObjectOutputStream
-
增强了缓冲区功能
-
增强了读写8种基本数据类型和字符串功能
-
增强了读写对象的功能
- readObject( ) 从流中读取一个对象
- writeObject(Object obj) 向流中写入一个对象
序列化
package ioframe;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/**
* 使用ObjectOutputStream实现对象的序列化(写入)
* 要求:
* 序列化的类必须要实现Serializable接口
* 序列化类中的对象属性也要求实现Serializable接口
* 序列化版本号ID:保证序列化反序列化一致性
* 使用transient(瞬间的)修饰属性,则不可被序列化
*/
public class Demo06 {
public static void main(String[] args) throws Exception{
//创建对象流
FileOutputStream fos = new FileOutputStream("e:\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//序列化(写入操作)
//声明学生类Serializable
Student zhangsan = new Student("张三",20);
oos.writeObject(zhangsan);
//关闭
oos.close();
System.out.println("序列化完毕");
}
}
反序列化
package ioframe;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
* 使用ObjectInputStream实现反序列化(读取重构成对象)
*/
public class Demo07 {
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();
//关闭
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());
}
}
编码方式
- ISO-8859-1
- UTF-8
- GB2312 简体中文
- GBK 简体中文、扩充
- BIG5 台湾,繁体中文
字符流
字符流抽象类
- Reader:字符输入流
- Writer:字符输出流
文件字符流
- FileReader
package ioframe;
import java.io.FileReader;
public class Demo08 {
public static void main(String[] args) throws Exception{
//创建FileReader文件字符输入流
FileReader fr = new FileReader("e:\\hello.txt");
//读取
//读取单个字符
int data = 0;
while ((data=fr.read())!=-1){
System.out.print((char)data);
}
/*
char[] buf = new char[2];
int count = 0;
while ((count = fr.read(buf))!=-1){
System.out.println(new String(buf,0,count));
*/
}
}
}
- FileWriter
package ioframe;
import java.io.FileReader;
import java.io.FileWriter;
public class Demo08 {
public static void main(String[] args) throws Exception{
//创建FileWriter
FileWriter fw =new FileWriter("e:\\writer.txt");
//写入
for (int i = 0; i <10 ; i++) {
fw.write("java是最好的语言\r\n");
fw.flush();
}
//关闭
fw.close();
System.out.println("执行完毕");
}
}
字符流复制文件
package ioframe;
import java.io.FileReader;
import java.io.FileWriter;
/**
* 使用FileReader和FileWriter复制文本,不能复制图片或者二进制文件
*/
public class Demo08 {
public static void main(String[] args) throws Exception {
//创建FileReader和FileWriter
FileReader fr = new FileReader("e:\\writer.txt");
FileWriter fw = new FileWriter("e:\\writer01.txt");
//读写
int data =0;
while ((data=fr.read())!=-1){
fw.write(data);
fw.flush();
}
//关闭
fr.close();
fw.close();
System.out.println("复制完毕");
}
}
字符缓冲流
- 高效读写
- 支持换行符
- 可一次写一行或者读一行
BufferReader
package ioframe01;
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 使用字符缓冲流读取文件
* BufferedReader
*
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//创建缓冲流
FileReader fr = new FileReader("e:\\writer.txt");
BufferedReader br =new BufferedReader(fr);
//读取文件
/*
char[] buf =new char[1024];
int count=0;
while ((count=br.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
*/
//按行读取
br.readLine();
//关闭
br.close();
System.out.println("读取完毕");
}
}
BufferWriter
package ioframe01;
import java.io.BufferedWriter;
import java.io.FileWriter;
/**
* BufferedWriter的使用
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//创建BufferedWriter对象
FileWriter fw = new FileWriter("e:\\buffer.txt");
BufferedWriter bw = new BufferedWriter(fw);
//写入
for (int i = 0; i <10 ; i++) {
bw.write("好好学习,天天向上\r\n");
bw.flush();
}
//写入完毕
System.out.println("写入完毕");
//关闭
bw.close();
}
}
打印流
PrintWriter
- 封装了print( )/println( )方法,支持写入后换行
- 支持数据原样打印·
package ioframe01;
import java.io.PrintWriter;
/**
* PrintWriter的使用
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
//创建打印流
PrintWriter pw =new PrintWriter("e:\\print.txt");
//打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
//关闭
pw.close();
System.out.println("执行完毕");
}
}
转换流
- 桥转换流:InputStreamReader/OutputStreamWriter
- 可将字节流转换为字符流(内存字符与硬盘字节之间)
- 可设置字符的编码方式
InputStreamReader
package ioframe01;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/**
* 使用InputStreamReader读取文件,指定使用的字符编码
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
//创建
FileInputStream fis =new FileInputStream("e:\\writer.txt");
InputStreamReader isr=new InputStreamReader(fis,"utf-8");
//读取文件
int data=0;
while ((data=isr.read())!=-1){
System.out.print((char)data);
}
//关闭
System.out.println("写入完毕");
isr.close();
}
}
OutputStreamWriter
package ioframe01;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/**
* 使用OutputStreamWriter的使用,使用指定的编码
*/
public class Demo05 {
public static void main(String[] args) throws Exception{
//创建
FileOutputStream fos=new FileOutputStream("e:\\info.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");
//写入
for (int i = 0; i <10 ; i++) {
osw.write("你好\r\n");
osw.flush();
}
//关闭
osw.close();
System.out.println("执行成功");
}
}
File类
- 概念:代表物理符盘中的一个文件或者文件夹
- 提供许多文件操作方法
文件操作
package ioframe01;
import java.io.File;
import java.io.IOException;
import java.util.Date;
/**
* File类的使用
* 1.分隔符
* 2.文件操作
* 3.文件夹操作
*/
public class Demo06 {
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 IOException {
//创建文件
File file = new File("file.txt");
System.out.println(file.toString());
boolean b = file.createNewFile();
System.out.println("创建结果:"+b);
//删除文件
//直接删除
//file.delete();
System.out.println("是否存在"+file.exists());
//使用JVM退出时删除
//file.deleteOnExit();
//获取文件信息
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());
//判断
System.out.println("是否可写"+file.canWrite());
System.out.println("是否是文件"+file.isFile());
System.out.println("是否隐藏"+file.isHidden());
System.out.println("是否是目录"+file.isDirectory());
}
//文件夹操作
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());//创建多级目录
}
//删除文件夹
//直接删除
System.out.println("删除结果"+dir.delete());//只删除单级子空目录
//使用JVM删除
dir.deleteOnExit();
//获取文件夹信息
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());
//判断
System.out.println("是否是文件夹"+dir.isDirectory());
System.out.println("是否是隐藏"+dir.isHidden());
//遍历文件夹
File dir2 = new File("e:\\图片");
String[] files = dir2.list();
for (String str:files
) {
System.out.println(str);
}
}
}
FileFilter接口
- 当调用File类中的listFiles( )方法时,支持传入FileFilter接口实现类,对获取文件进行过滤,只有满足条件的文件才可以出现在listFiles( )的返回值中
File[] file2=dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
//只获取以“.jpg“结尾的文件
if (pathname.getName().endsWith(".jpg")){
return true;//满足要求
}
return false;//不满足要求
}
});
for (File file:file2
) {
System.out.println(file.getName());
}
实例
- 递归遍历文件夹
package ioframe01;
import java.io.File;
/**
* 案例1
* 递归遍历文件夹
*/
public class ListDemo {
public static void main(String[] args) {
listDir(new File("e:\\myfiles"));
}
public static void listDir(File dir){
File[] files = dir.listFiles();
System.out.println(dir.getAbsolutePath());
if (files!=null&&files.length>0){
for (File file:files
) {
if (file.isDirectory()){
listDir(file);
}else {
System.out.println(file.getAbsolutePath());
}
}
}
}
}
- 递归删除文件夹
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(file.getAbsolutePath()+"删除:"+file.delete());
}
}
}
System.out.println(dir.getAbsolutePath()+"删除:"+dir.delete());
}
补充:Properties
- Properties属性集合
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;
public class Demo01 {
public static void main(String[] args) throws Exception {
//创建集合
Properties properties = new Properties();
//添加数据
properties.setProperty("username","zhangsan");
properties.setProperty("age","20");
System.out.println(properties.toString());
//遍历
//keyset、entryset遍历
//StringPropertyNames()
Set<String> pronames = properties.stringPropertyNames();
for (String pro:pronames
) {
System.out.println(pro+"======="+properties.getProperty(pro));
}
//和流有关的方法
//list方法 打印
PrintWriter pw = new PrintWriter("e:\\print.txt");
properties.list(pw);
pw.close();
//store方法 保存
FileOutputStream fos = new FileOutputStream("e:\\store.properties");
properties.store(fos,"注释");
fos.close();
//load方法 加载
Properties properties1 = new Properties();
FileInputStream fis =new FileInputStream("e:\\store.properties");
properties1.load(fis);
fis.close();
}
}