Java IO

最新推荐文章于 2022-08-31 20:55:44 发布
最新推荐文章于 2022-08-31 20:55:44 发布
阅读量75 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yonghumingyibeizhan8/article/details/113885970
版权
本文详细解析了IO框架中的流概念，包括输入流、输出流、字节流与字符流的区别，以及FileInputStream、FileOutputStream、BufferedInputStream/OutputStream等关键类的使用示例。此外，还介绍了序列化与反序列化、字符缓冲流、PrintWriter以及转换流如InputStreamReader/OutputStreamWriter的应用。
摘要由CSDN通过智能技术生成

IO框架

什么是流

  • 概念：内存与存储设备之间传输数据的通道。

img

按方向（重点）

  • 输入流：将<存储设备>中的内容读取到<内存>中。

  • 输出流：将<内存>中的内容写入到<存储设备>中。

按单位：

  • 字节流：以字节为单位，可以读写所有数据。

  • 字符流：以字符为单位，只能读写文本数据。

按功能

  • 节点流：具有实际传输数据的读写功能。

  • 过滤流：字节流的基础上增强的功能。

字节流

InputStream

 

OutputStream

文件字节流

FileInputStream

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

/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class FileInputStreamTest {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("e:\\aaa.txt");
        //2.读取文件
       // fis.read();
        //2.1.单个字节读取
        //int data = 0;
      //  while ((data = fis.read())!=-1){
       //     System.out.print((char) data);
       // }
​
        //2.2一次读取多个字节
        byte[] bytes = new byte[1024];
        int count = 0;
        while ((count = fis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,count));
        }
        fis.close();
        System.out.println("读取结束");
    }
}

FileOutputStream

  • public void write(byte[] b) //-次写多个字节，将b数组中所有字节，写入输出流。

/**
 * 演示FileOutputStream的使用
 * 文件字节输出流
 */
public class FileOutputStreamTest {
    public static void main(String[] args) throws Exception {
        FileOutputStream outputStream = new FileOutputStream("e:\\bbb.txt", true);
        String s = "我爱你中国，亲爱的母亲，我为你流泪，也为你自豪。";
        outputStream.write(s.getBytes());
        //关闭
        outputStream.close();
        System.out.println("执行完毕");
    }
}

实现文件复制

/**
 * 使用文件字节流实现文件复制
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //创建文件输入流与输出流
        FileInputStream fis = new FileInputStream("C:\\Users\\Lenovo\\Pictures\\壁纸\\4.jpg");
        FileOutputStream fos = new FileOutputStream("C:\\Users\\Lenovo\\Pictures\\壁纸\\40.jpg");
        //2.一边读，一边写
        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("执行完毕");
​
    }
}

字节缓冲流

缓冲流: BufferedInputStream/ Buffered0utputStream

  • 提高I0效率，减少访问磁盘的次数;

  • 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close.

/**
 * 使用字节缓冲流读取
 * BufferedInputStream的使用
 */
public class BufferedInputStreamTest {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("e:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);//文件缓冲流
        //2.读取,用缓冲流读取
        //int data = 0;
        //while ((data = bis.read())!=-1) {
        //    System.out.println((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；
    }
}
/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 */
public class BufferedOutputStreamTest {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲区
        FileOutputStream fos = new FileOutputStream("e:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入
        int i= 0;
        while (i<10){
            bos.write("helloBuffer!\r\n".getBytes());//写入8K缓冲区
            bos.flush();
            i++;
        }
        //3。关闭
        bos.close();
    }
}

序列化

/**
 * 使用ObjectOutputstream实现对象的序列化
 * 将对象写到硬盘上
 * 要求：(1)实现Serializable接口
 * (2)序列化中对象属性要求实现Serializable接口
 * (3)序列化版本号ID，保证序列化和反序列化的类是同一个类。
 * (4)使用transient（瞬间的）修饰属性，这个属性不能序列化
 * (5)静态属性不能被序列化
 * (6)序列化多个对象可以借助集合
 */ 
public class ObjectOutputstreamTest {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("e:\\ccc.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化，即写入操作
        Student s1 = new Student("李白",19);
        oos.writeObject(s1);
        //3。关闭
        oos.close();
        System.out.println("序列化完毕！"); //NotSerializableException不能序列化，得实现接口
    }
}

反序列化

/**
 * 使用ObjectInputStream实现反序列化（读取）
 */
public class ObjectInputStreamTest {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileInputStream fis = new FileInputStream("e:\\ccc.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.反序列化，即读取操作
        Student s = (Student) ois.readObject();
        //3.关闭
        ois.close();
        System.out.println("反序列化完毕！");
        System.out.println(s.toString());
    }
}

字符流

 

文件字符流

  • FileReader:

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

    /**
 * 使用FileReader读取文件
 */
public class FileReaderTest {
    public static void main(String[] args)  throws Exception{
        //1.创建FileReader 文件字符输入流
        FileReader fr = new FileReader("e:\\hanzi.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();
    }
}
​

     

  • FileWriter:

    • public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。

/**
 * 使用FileWriter写入文件
 */
public class FileWriterTest {
    public static void main(String[] args) throws Exception{
        //1.创建FileWriter对象
        FileWriter fw = new FileWriter("e:\\hanzi.txt");
        //2.写入
        for (int i = 0; i < 10; i++) {
            fw.write("我爱你中国，亲爱的母亲，我为你流泪，也为你自豪！\r\n");
            fw.flush();
        }
        //3.关闭
        fw.close();
        System.out.println("执行完毕！");
    }
}

字符缓冲流

缓冲流：BufferedReader/BufferedWriter

  • 高效读写

  • 支持换行符

  • 可一次写一行、读一行。

/**
 * 使用字符缓冲流BufferedReader读取文件
 */
public class BufferedReaderTest {
    public static void main(String[] args) throws Exception{
        //1.创建缓冲流
        FileReader fr = new FileReader("e:\\wai.txt");
        BufferedReader br = new BufferedReader(fr);
        //2.读取
        //2.1第一种读取方式
        //int count = 0;
        //char[] buf = new char[1024];
        //while ((count = br.read(buf)) != -1){
        //    System.out.println(new String(buf,0,count));
        //}
        //2.2第二种方式
        String line = null;
        while ((line = br.readLine())!= null){
            System.out.println(line);
        }
        //3.关闭
        br.close();
    }
}

BufferedWriter

/**
 * 使用BufferedReader写入文件
 */
public class BufferedWriterTest {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedReader对象
        FileWriter fw = new FileWriter("e:\\wai.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2.写入
        for (int i = 0; i < 10; i++) {
            bw.write("什么时候会有那么一天呢？");
            bw.newLine();
            bw.write("好难好难");
            bw.flush();
        }
        //3.关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

PrintWriter

/**
 * 使用PrintWriter写入数据
 */
public class PrintWriterTest {
    public static void main(String[] args) throws Exception{
        //1.创建PrintWriter对象
        PrintWriter pw = new PrintWriter("e:\\print.txt");
        //2.写入数据
        pw.println("我爱你中国");
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3.关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

转换流

桥转换流：InputStreamReader/OutputStreamWriter

  • 可将字节流转换为字符流

  • 可以设置字符的编码方式

/**
 * 使用InputStreamReader读取文件，指定使用的编码
 */
public class InputStreamReaderTest {
    public static void main(String[] args) throws Exception{
        //1.创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("e:\\writer.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();
    }
}
/**
 * 使用OutputStreamWriter写入文件，并指定编码
 */
public class OutputStreamWriterTest {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWriter对象
        FileOutputStream fos = new FileOutputStream("e:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("埋骨何须桑梓地，人生何处不青山");
            osw.flush();
        }
        //3.关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

file类

概念：代表物理磁盘上的一个文件或者文件夹。

方法：

  • createNewFile()//创建一个新文件

  • mkdir()//创建一个新目录

  • delete()//删除文件或空目录

  • exists()//判断File对象所对象所代表的对象是否存在

  • getAbsolutePath() //获取文件的绝对路径

  • getName ()//取得名字

  • getParent ()//获取文件/目录所在的目录

  • isDirectory()//是否是目录

  • isFile()//是否是文件

  • length()//获待文件的长度

  • listFiles()//列出目录中的所有内容

  • renameTo()//修改文件名为

     

/**
 * file类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作
 */
public class FileTest {
    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{
        //1.创建文件createNewFile()
        File file = new File("e:\\create.txt");
        //System.out.println(file.toString());
        if(!(file.exists())){
            boolean newFile = file.createNewFile();
            System.out.println("创建结果"+newFile);
        }
        //2.删除文件
        //2.1直接删除
       // System.out.println("删除结果"+file.delete());
        //2.2使用jvm退出时删除
        //file.deleteOnExit();
        //Thread.sleep(5000);
        //3.获取文件信息
        System.out.println("获取文件绝对路径"+file.getAbsolutePath());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取文件名"+file.getName());
        System.out.println("获取父目录"+file.getParent());
        System.out.println("获取创建时间"+new Date(file.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }
    //文件夹操作
    public static void directoryOpe()throws Exception{
        //1.创建文件夹
        File dir = new File("e:\\aa\\bb\\cc");
       // System.out.println(dir.toString());
        if(!dir.exists()){
            //dir.mkdir();//只能创建单级目录
            dir.mkdirs();//创建多级目录
        }
        //2。删除文件
        //2.1直接删除
       // 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("C:\\Users\\Lenovo\\Pictures\\壁纸");
        String[] files = dir2.list();
        System.out.println("====================");
        for (String s : files) {
            System.out.println(s);
        }
        System.out.println("=========listFiles()的使用===============");
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".jpg")){
                    return true;
                }
                return false;
            }
        });
        for (File f : files2) {
            System.out.println(f.getName());
        }
    }
}

FileFilter接口

  • public interface FileFilter

  • boolean accept(File pathname)

  • 当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件才可以出现在listFiles()的返回值中。

System.out.println("=========listFiles()的使用===============");
File[] files2 = dir2.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        if(pathname.getName().endsWith(".jpg")){
            return true;
        }
        return false;
    }
});
for (File f : files2) {
    System.out.println(f.getName());
}
小姚游
关注
Java 新I/O
03-19
NULL 博文链接：https://xace.iteye.com/blog/706935
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
I/O框架
执妄
11-18 150
流的概念：内存与存储设备之间传输数据的通道 流的分类 按流向 输入流：将存储设备中的内容读入到内存 输出流：将内存中的内容写入到存储设备 按单位 字节流：以字节为单位，可以读写所有数据 字符流：以字符为单位，只能读写文本文件 按功能 节点流：具有实际传输数据的读写功能 过滤流：在节点流的基础上增强功能 一、文件字节流 FileInputStream: public int read(byte[] b) //从流中读取多个字节，将读取到的内容存入b..
java decorator模式_学习：java设计模式—Decorator模式
weixin_35782250的博客
02-15 156
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝可从IO的类层次，IO框架的设计模式来论述。总体来说，IO可以分为字节流和字符流，不同在于字符流由字节流包装而来，在IO读入之后经过JVM处理，把字节流转换成字符流。而字符流的字符采用哪种字符编码实现由JVM默认编码决定。而每个流都分输入和输出，所以，总体来说，IO有四个顶层类：InputStreamOutputStreamRe...
Java IO框架
随风的专栏
05-18 7272
可从IO的类层次，IO框架的设计模式来论述。 总体来说，IO可以分为字节流和字符流，不同在于字符流由字节流包装而来，在IO读入之后经过JVM处理，把字节流转换成字符流。而字符流的字符采用哪种字符编码实现由JVM默认编码决定。 而每个流都分输入和输出，所以，总体来说，IO有四个顶层类： InputStream OutputStream Reader Writer 而作为机器级别于机器直接交互的则是字
Java中的IO框架
qq_44719987的博客
10-10 393
什么是流？ 内存与存储设备之间传输数据的通道 流的分类 输入流：将<存储设备>中的内容读入到<内存> 输出流：将<内存>中的内容写入到<存储设备>中 字节流：以字节为单位，可以读写所有数据 字符流：以字符为单位，只能读写文本数据 节点流：具有实际传输数据的读写功能 过滤流：在节点流的基础之上增强功能 ...
java-io-guide:Java中的Java IO（输入和输出流）指南
04-29
这是Java中文件处理的完整指南。 本指南的源代码在我们的本地开发环境中经过了很好的测试，并使用了静态代码分析器工具SonatLint ， PMD等对代码进行了分析。本指南的源代码无缺陷，并使用JDK 8进行编译和执行。 ...
JavaIO总结
05-08
有关Java输入输出流的总结有关Java输入输出流的总结有关Java输入输出流的总结
java IO教程，java IO教程，java IO教程
04-07
java IO教程，java IO教程，java IO教程，java IO教程java IO教程java IO教程java IO教程java IO教程，java IO教程java IO教程java IO教程java IO教程java IO教程，java IO教程，java IO教程，java IO教程，java IO...
JavaIO文件复制优化-JavaIO优化详解（下载可用）
最新发布
05-30
JavaIO文件复制优化——JavaIO优化详解（下载可用）。个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。...
java IO框架
西瓜
09-25 360
https://blog.csdn.net/github_38841849/article/details/79686757 https://blog.csdn.net/qq_27093465/article/details/53233273
java io框架
swjtufei的专栏
10-11 186
待补充···
Java之 IO框架
Ifeng_iPhone的博客
08-31 696
把使用字节输入流读取到的字节，写入到指定文件中，边读取边写入，达到一个复制的效果。OutputStream 字节输出流使用来写入文件，一次写入一个字节。InputStream 字节输入流使用来读取文件，一次读取一个字节。内部做了优化，减少了和磁盘的交互，提高了字节读取的效率。内部做了优化，减少了和磁盘的交互，提高了字节读取的效率。缓冲字符输出流和字符输出流的用法是一样的。字符输入流读取数据，每次读取一个字符。字符输出流写入数据，每次写入一个字符。一次读取一个字节，字节流 byte。...
Java IO 框架整理
jianjifei的专栏
03-18 171
可从IO的类层次，IO框架的设计模式来论述。 总体来说，IO可以分为字节流和字符流，不同在于字符流由字节流包装而来，在IO读入之后经过JVM处理，把字节流转换成字符流。而字符流的字符采用哪种字符编码实现由JVM默认编码决定。 而每个流都分输入和输出，所以，总体来说，IO有四个顶层类： InputStream OutputStream Reader Writer 而作为机器级别...
JavaIO框架​​​​
qq_57216731的博客
12-05 430
流 字节流抽象类
Java基础之IO框架
weixin_34111790的博客
06-27 78
一：串流设计的概念 Java 将输入/输出抽象化为串流，数据有来源及目的地，衔接两者的是串流对象。比喻来说，数据就好比水，串流好比水管，通过水管的衔接，水由一端流向另一端。 在不使用 InputStream 与 OutputStream 时，必须使用 close() 方法关闭串流。 二：串流继承架构 1.InputStream 的常用类继承架构： 2.OutputStrea...
Java I/O框架
只是个人笔记，请见谅
01-11 609
Java I/O框架什么是流流的分类字节流FileInputStreamFileOutputStream案例--文件流复制字节缓冲流BufferedInputStreamBufferedOutPutStream对象流序列化反序列化序列化和反序列化注意事项常见字符编码字符流抽象类FilereaderFileWriter案例--实现文件复制字符缓冲流BufferReaderBufferWriter打印流转换流InputStreamReaderOutputStreamWriterFile类文件的操作分隔符创建文件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值