I/O框架

于 2021-03-20 16:22:20 发布
阅读量172 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NaRuToMo/article/details/115029849
版权
本文详细介绍了Java的I/O框架，包括流的概念和分类，如字节流、字符流、对象流及其缓冲流的使用。重点讲解了FileInputStream、FileOutputStream、FileReader、FileWriter的用法，以及如何进行文件复制。同时，还涵盖了序列化、反序列化的基本操作，以及File类的方法和Properties类的应用。
摘要由CSDN通过智能技术生成

I/O框架

流

  • 概念:内存与存储设备之间传输数据的通道，数据借助流传输。
  • 分类：
  • 流向分：
    • 输入流:将<存储设备>中的内容读入到<内存>中。（文件到程序）
    • 输出流:将<内存>中的内容写入到<存储设备>中。（程序到文件）
  • 按单位:
    • 字节流:以字节为单位，可以读写所有数据。
    • 字符流:以字符为单位，只能读写文本数据。
  • 按功能：
    • 节点流:具有实际传输数据的读写功能。
    • 过滤流:在节点流的基础之上增强功能。

字节流

  • 字节流的父类（抽象类）：
    • InputStream：字节输入流
      • public int read(){}
      • public int read(byte[] b){}
      • public int read(byte[] b, int off, int len){}
    • OutputStream：字节输出流
      • public void write(int n){}
      • public void write(byte[] b){}
      • public void write(byte[] b,int off,int len){}
文件字节流

  • FileInputStream:

  • public int read(byte[] b)//从流中读取多个字节，将读到内容存入b数组**，返回实际读到的字节数**;如果达到文件的尾部，则返回-1。

  • FileOutputStream:

    • public void write(byte[] b)//一次写多个字节，将b数组中所有字节，写入输出流。
FileInputStream的使用
  1. 创建
FileInputstream fis=new FileInputstream( "d:\\ aaa.txt");
  1. 读取文件
//2.1单个字节读取int data=0;
while((data=fis.read( ))!=-1){
   system.out. print( (char)data);
}
//2.2一次读取多个字节 
byte[] buf=new byte[3];
int count=0;
while((count=fis.read(buf)) !=-1){
    system.out.println(new string(buf,e,count);
}
  1. 关闭
fis.close();
FileOutputStream:

  1. 创建

    Fileoutputstream fos=new Fileoutputstream("d: \\bbb.txt");

  2. 写入文件

    fos.write(97);
fos.write('b');
fos.write("c');
string string="helloworld"";
fos.write(string.getBytes());

  3. 关闭

    fos.close();
文件字节流复制文件
public static vo1d main(String[]args )throws Exception{
    //创建流
    //1.1文件字节输入新
    Fileinputstream fis=new FileInputstream("d:\\ 001.jpg");
    //1.2文件字节输出流
    Fileoutputstream fos=new  Fileoutputstream("d:\\002.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.print1n("复制完毕");    
}
字节缓冲流
  • 缓冲流:BufferedInputStream/BufferedOutputStream
    • 提高IO效率，减少访问磁盘的次数;
    • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

使用字节缓冲流读取文件

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=e;
while((count=bis.read(buf))!=-1) {
    system.out.print1n(new string(buf,e,count));
}

使用字节缓冲流写入文件

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".getBytes());//写入8K缓冲区
        bos.flush() ;//刷新到硬盘
    }
    //3.关闭（内部调用flush()方法)
    bos.close();
}

对象流

  • 对象流:0bjectOutputStream/ObjectInputStream
    • 增强了缓冲区功能
    • 增强了读写8种基本数据类型和字符串功能
    • 增强了读写对象的功能:
      • readObject()从流中读取一个对象
      • write0bject(Object obj)向流中写入一个对象

使用流传输对象的过程称为序列化(内存写到文件)、反序列化（文件读取对象）。

序列化
//要序列化的类，必须实现一个借口implements Serializable
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.print1n("序列化完毕");
)
反序列化
public static void main(string[] args) throws Exception{
    //创建对象流
    FileInputstream fis=new FileInputstream("d: \\stu.bin");                                     objectinputstream ois=new objectInputstream(fis);
    //2读取文件(反序列化)
    student s=( student)ois.readobject();
    //3关闭
    ois.close();
    system.out.println(""执行完毕");
}
序列化和反序列化注意事项
  • 序列化类必须要实现Senializable接口
  • 序列化类中对象属性要求实现Serializable接口
  • 序列化版本号ID,保证序列化的类和反序列化的类是同一个类
  • 使用transient（瞬间的）修饰属性。这个属性不能序列化
  • 静态属性不能序列化
  • 序列化多个对象，可以借助集合实现

字符流

字符编码
  • ISO-8859-1收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
  • UTF-8 针对Unicode码表的可变长度字符编码 1,2,3字节表示
  • GB2312 简体中文 1,2字节表示
  • GBK 简体中文、扩充 1,2字节表示
  • BIG5 台湾，繁体中文
字符流的父类(抽象类):
  • Reader:字符输入流
  • public int read() {}
  • public int read(char[]c){}
  • public int read(char[] b, int off, int len){}
  • Writer:字符输出流
    • public void write(int n){}
    • public void write(String str){}
    • public void write(char[] c){}
文件字符流
  • FileReader:
    • public int read(char[] c)//从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数;如果达到文件的尾部，则返回-1。
  • FileWriter:
    • public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。
使用FileReader读取文件
package IO;

import java.io.FileReader;

public class FileRE {
    public static void main(String[] args) throws Exception{
        FileReader fr=new FileReader("d:\\c.txt");
        //单个读取
//        int data=0;
//        while ((data=fr.read())!=-1){//读取一个字符
//            System.out.print((char)data);
//        }
        char []buf=new char[1024];
        int count=0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        fr.close();
    }
}
FileWriter的使用
public static void main(String[ ] args) throws Exception {
    //1创建Filewriter对象
    Filelwriter fw=new Filewriter("d:\\ write.txt");
    //2写入  
    for(int i=e;i<10;i++) {
        fiw.werite("java是世界上最好的语言\r\n");
        fw.flush();
    }
    fw.close();
}
补充
  • 使用FileReader和Filewriter复制文本文件,不能复制图片或二进制文件
  • 使用字节流复制任意文件
字符缓冲流
  • 缓冲流:BufferedReader/BufferedWriter。
    • 高效读写
    • 支持输入换行符。
    • 可一次写一行、读一行。
BufferedReader的使用
FileReader fr=new FileReader("d:\\write.txt");
BufferedReader br=new BufferedReader(fr);
//读取
//2.1第一种方式
char[]buf=new char[1024];
int count=3;
while((count=br.read(buf))!=-1){
    system. out. print(new String( buf,e,count))
}
//2.2第二种方式。一行一行的读取
String line=null;
while((line=br.readLine( ))!=null){
    system.out.print1nline;
}
br.close();
BufferedWriter的使用
//1刨建Bufferedwriter对象
Filewriter fw=new Filewriter("d:\\buffer.txt");
Bufferedwriter bw=new Bufferedwriter(fw );
//2写入
for(int i=e;i<10;i++){
    bw.write(""好好学习.天天问上");
    bw.newLine();//写入一个换行符         
    bw.flush();
}
//3关闭  
bw.c1ose();

打印流

  • PrintWriter:
    • 封装了print() / println()方法，支持写入后换行。
    • 支持数据原样打印
//创建
printwriter pw=new Printwriter("d:\\iprint.txt" );
//2打印
pw. println(97);
pw.println(true) ;
pw.println( 3.14);
pw .println( "a');
//3关闭
pw.close();

转换流

  • 桥转换流:InputStreamReader(字节流通向字符流)/OutputStreamWriter(字符流通向字节流)。
    • 可将字节流转换为字符流。
    • 可设置字符的编码方式。
InputStreamReader的使用
//创建InputstreamReader对象
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);
}
isr.close( );
OutputStreamWriter的使用
//1创建OutputStreamiwriter
Fileoutputstream fos=new Fileoutputstream( "d : \linfo.txt");
outputstreamvriter osw=new outputstreamMriter(fos，"gbk");
//2写入
for(int i=e;i<10;i++) {
    osw.write(”我爱北京。我爱故乡\r\n");
    osw.flusho;
}
osw.close(();

File类

  • 概念:代表物理盘符中的一个文件或者文件夹。
  • 方法：
    • createNewFile()//创建一个新文件.
    • mkdir()//创建一个新目录
    • delete()//删除文件或空目录
    • exists()//判断File对象所对象所代表的对象是否存在
    • getAbsolutePath()//获取文件的绝对路径
    • getName()//取得名字
    • getParent)F/获取文件/目录所在的目录
    • isDirectory ()//是否是目录
    • isFile()//是否是文件
    • length()//获得文件的长度
    • listFiles()//列出目录中的所有内容
    • renameTo()//修改文件名为

File类的使用

//File类的使用(1)分隔符(2)文件操作(3)文件夹操作
//1分隔符
public static void separator(){
system.out.print1n("路径分隔符“+File.pathseparator);
system.out.print1n("名称分隔符"+File.separator);
}
//文件操作
public static void fileope( )throws Exception{
    //1.创建文件
    File file=new File("d://file.txt");               System.out.printin(file.tostring(o);
    if(!file.exists( ){
        boolean b=fiie.createNewFile();
        system.out.println("创建站果:"+b);
} 
     //2.删除文件  
     //2.1直接删除
     file.delete();
     //2.2使用jvm退出时删除
     file.deleteOnExit();
     
     //3获取文件信息
     file.getAbsolutePath.();//绝对路径
     file.getpath();//获取路径
     file.getName();//获取文件名称
     file.getParent();//获取父目录
     file.length();//获取文件长度
     file().lastModified();//文件创建时间
       
     //4判断
     file.canWrite();//是否可写
     file.isFile();//是否是文件
     file.isHidden();//是否隐藏

       
//文件夹操作
//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.1直接删除《汪意剽除空目录)
System.out.println("删除结果:"+dir.delete());
//2.2使目jvm删除
dir.deleteonExit();
Thread.sleep(5000);
//3获取文件夹信息
system.out.print1n("获取绝对路径:"+dir.getAbsolutepath());
System.out.print1n("获取路径: "+dir-getPath());
system.out.print1n("获取文件火名称:"+dir-getName());
system.out.print1n("”获取父目录:"+dir.getParent()); system.out. print1n("获取创建时间 ; "+new Date(dir.lastNodified() ).toLocalestring()); 
//4判断
system.out.println("是否时文件火:"+dir.isDirectory());
system.out. println("是香时隐藏:"+dir.isHidden( )); //5.遍历文件夹                      
File dir2=new File("d//图片");
string[] files=dir2.list();
system.out.print1t("----------");
for (string' string : files) {
     system.out.print1n(string);
 }

FileFilter接口

  • public interface FileFilter
    • boolean accept(File pathname)
  • 当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中。
File[] files2=dir2.listFiles(new FileFilter(){
    public boolean accept(File pathname){
        if(pathname-getiame( ).endswith(--jpg")){
                    return true;                   }
return false;
    }
});
           
for (File file : files2) {
    system.out.println(file.getName());
}

递归遍历文件夹

public class ListDemo{
    public class ListDemo{
        public static void main(string[] args) {
            listDir(new File( "d:\\myfiles"));
        }
     public static void listDir(File dir){
         File[] files=dir.listFiles();
         system.out.print1n(dir.getAbsolutepath( ));
         if(files !=nu11&&fiies.length>e) {
             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!=nu11&&files.length>0){
        for (File file : files){
            if(file.isDirectory()){
                deleteDir(file);//递归
            }else{
//删除文件   
                system.out.println(file.getAbsolutePath()+"删除:"+file.delete());
            }
        }
    }
    system.out.print1n(dir.getAbsolutepath( )+"删除:"+dir.delete());
}

Properties

  • Properties:属性集合。
  • 特点
    • 存储属性名和属性值
    • 属性名和属性值都是字符串类型.
    • 没有泛型
    • 和流有关

Properties的使用

//1创建集合
Properties properties=new Properties();
//2添加数据
properties.setproperty ( "username","zhangsan");
properties.setProperty("age", "20");
System.out.print1n(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和流有关的方法
// - - --------list方法---- ---- -打印
Printwriter_pw=new Printwriter(d:\\print.txt");
properties.list(pw);
pw.close( );
//----------2store方法-----------保存
Fileoutputstream fos=new Fileoutputstream( "d: \\store.properties");
properties.store(fos,"注释");
fos.close();
//----------3load方法-----------加载   
Properties properties2=new Properties();
FileInputstream fis=new FileInputstream("d:\ \store.properties");
properties2.load(fis); 
fis.close();
NaRuToMo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值