JavaIO框架

最新推荐文章于 2023-08-13 19:29:53 发布
最新推荐文章于 2023-08-13 19:29:53 发布
阅读量177 收藏 1
点赞数
分类专栏： Javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59916297/article/details/120416854
版权

IO框架

流

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

数据借助流传输。

分类：

流向：

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

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

单位：

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

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

功能：

节点流：具有实际传输数据的流。

过滤流：在节点流的基础上增强功能。

字节流的抽象类

InputStreanm：字节输入流

FileInputStreanm：文件字节输入流
package demo07;

import java.io.FileInputStream;

public class TestFileInputStream {
    public static void main(String[] args) throws Exception{
        //1.创建
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2.读取文件
        //fis.read();一个字节
//        int  c=0;
//        while((c= fis.read())!=-1){
//            System.out.print((char) c);
//        }
        //2.1,3个3个的读取
        //这里char字符全部被编写成阿斯科编码
        byte  []   count= new byte[1024];
        int date =0;
        while((date=fis.read(count))!=-1){
            System.out.println(new String(count,0,date));

        }

//3.关闭
            fis.close();
        System.out.println();
        System.out.println("执行完毕");

    }
}

OutputStream：字节输出流

FileOutputStream：文件字节输出流
package demo07;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;

/**
 * 写入文件

 */
public class TestFileOutputStream {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);

        String name="helloworld";
        fos.write(name.getBytes());

        fos.close();
        System.out.println("执行完毕");
    }
}

test：

package demo07;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo02 {
    public static void main(String[] args) throws IndexOutOfBoundsException,Exception{
        FileInputStream  fis=new FileInputStream("d:\\001.png");
        FileOutputStream fos=new FileOutputStream("d:\\002.png");

        //复制图片
        byte[] buf = new byte[1024];
        int count=0;

int i=0;
        while((count=fis.read(buf))!=0){
            i++;
            fos.write(buf,0,count);
            System.out.println(i);
        }

        fis.close();
        fos.close();
        System.out.println("复制完毕");

    }

}

问题：抛出Exception一场之后还会继续报异常？

字节缓冲流

BufferedInputStream
package demo07;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class Test01 {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");

        BufferedInputStream stream = new BufferedInputStream(fis);


        int date=0;
        while ((date=stream.read())!=-1){
            System.out.print((char)date);
        }

    stream.close();

    }
}

BufferedOutputStream

package demo07;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

public class Test02 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);


        for (int i = 0; i < 10; i++) {
            bos.write("helloworld\r\n".getBytes());
            bos.flush();
        }
       bos.close();
    }
}

对象流

  • ObjectoutputStream/ObjectinputStream
    • 增强了缓冲区功能
    • 增强了读写8中基本数据类型和字符串功能
    • 增强了读写对象的功能
  • 使用流传输对象的过程称为序列化和反序列化

序列化ObjectOutputStream

要求序列化的类必须要实现Serializable接口

package demo07;

import java.io.FileOutputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class Test03 {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos=new FileOutputStream("d:\\liu");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

Student  s1=new Student("张三",21);
    oos.writeObject(s1);


    oos.close();
        System.out.println("序列化完成");


    }
}

反序列化ObjectInputStream

package demo07;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class Test04 {
    public static void main(String[] args) throws Exception{

        FileInputStream fis = new FileInputStream("d:\\liu");
        ObjectInputStream ois = new ObjectInputStream(fis);

        Student s1=(Student) ois.readObject();
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s1.toString());
    }
}

注意事项

  • 序列化必须要实现Serializable接口
  • 序列化类中对象属性要求实现Serializable接口
  • 序列化版本号ID SerializableUID，保证序列化的类和反序列化的类是同一个类
  • 使用transient（瞬间的）修饰属性，这个属性不能序列化
  • 静态属性不能序列化
  • 序列化多个对象，可以借助集合实现

字符编码

  • ISO-8859-1收录除ASCII外，还包括西欧，希腊语，泰语，阿拉伯语，希伯来语对应的文字符号
  • UTF-8 针对Unicode码表的可变长度字符编码
  • GB2312 简体中文
  • GBK简体中文、扩充
  • BIG5 台湾、繁体中文

当编码方式和解码方式不一样时，会出现乱码。

文件字符流

Reader、Writer

//FileReader
package demo07;

import java.io.File;
import java.io.FileReader;

public class TestFileReader {
    public static void main(String[] args) throws Exception{

        FileReader  fd=new FileReader("d:\\aaa.txt");
//读取单个字节
//        int date=0;
//       while((date=fd.read())!=-1){
//           System.out.println((char) date);
//       }

       //多个字符读取
        char  []  buf=new char[1024] ;
       int count=0;
       while((count= fd.read(buf))!=-1){
           System.out.println(new String(buf,0,count));
       }

fd.close();

    }
}


//FileWriter
package demo07;

import java.io.FileWriter;

public class TestFileWriter {
    public static void main(String[] args) throws Exception{
        FileWriter fw = new FileWriter("d:\\bbb.txt",true);


        for (int i = 0; i < 10; i++) {
            fw.write("Tx傻逼\r\n");
        }
       fw.close();
    }
}
  • 注意：不能使用字符流复制图片或者二进制文件
  • 字节流可以复制任意文件
//复制
package demo07;

import java.io.FileReader;
import java.io.FileWriter;

public class Test {
    public static void main(String[] args) throws Exception{
        FileReader fd=new FileReader("d:\\bbb.txt");
        FileWriter fw=new FileWriter("d:\\ccc.txt");
        //存储数据
        int count=0;
        while ((count=fd.read())!=-1){
            fw.write(count);
            fw.flush();
        }
//关闭
        fd.close();
        fw.close();
        System.out.println("复制完毕");

    }
}

字符缓冲流

BufferedReader

package demo07;

import java.io.BufferedReader;
import java.io.FileReader;

public class TestBufferedReader {
    public static void main(String[] args) throws Exception{
        //创建对象
        FileReader fw=new FileReader("d:\\ccc.txt");
        BufferedReader br=new BufferedReader(fw);
        //读取
        //2.1
//        char [] buf=new char[1024];
//        int count=0;
//        while((count= br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //2.2一行一行的读取
        String s=null;
        while ((s= br.readLine())!=null){
            System.out.println(s);
        }
        System.out.println("执行完毕");
        br.close();
    }
}

BufferedWriter

package demo07;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class Test05 {
    public static void main(String[] args)throws Exception{


        FileWriter fw=new FileWriter("d:\\ddd.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        for (int i = 0; i <10 ; i++) {

            bw.write("TXsb"+"");
            bw.newLine();
        }
        System.out.println("执行完毕");
    bw.close();
    }
}

PrintStream

package demo07;

import java.io.PrintStream;

public class Demo03 {
    public static void main(String[] args) throws Exception{
        PrintStream ps = new PrintStream("d:\\print.txt");
        ps.println(91);
        ps.println("aabdoas");
        ps.println('a');
        ps.println(3.15);
        System.out.println("打印完毕");
        ps.close();
    }
}

转换流

桥转换流：InputStreamReader/OutputStreamReader

  • 可以将字节流转换为字符流
  • 可设置字符的编码方式

InputStreamReader

package demo07;

import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Demo04 {
    public static void main(String[] args) throws Exception{
        FileInputStream  fis=new FileInputStream("d:\\ddd.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");


        int count=0;
        while((count= isr.read())!=-1){
            System.out.println((char)count);
        }
        System.out.println("执行完毕");
        isr.close();
    }
}

OutPutStreamReader

package demo07;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class Demo05 {

    public static void main(String[] args) throws Exception{
        FileOutputStream fos=new FileOutputStream("d:\\txsb.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        for (int i = 0; i <10 ; i++) {
            osw.write("TXSB\r\n");
        }
        osw.close();

    }
}

File类

  • 概念：代表物理盘符中的一个文件或者文件夹
  • 方法

文件操作：

package demo07;

import java.io.File;
import java.util.Date;

public class Demo06 {
    public static void main(String[] args) throws Exception{
        separator();
        fileOpe();
    }

//分隔符
    public static void separator(){
        System.out.println("路径分隔符："+ File.pathSeparator);
        System.out.println("名称分隔符："+File.separator);
    }
//文件操作
    public static  void fileOpe()throws Exception{
File  file=new File("d:\\file.txt");
        //1创建文件

      if(!(file.exists())){
        file.createNewFile();
          System.out.println("创建成功");
      }
        //2删除文件
        if(file.exists()){
         //   file.delete();
         // Thread.sleep(5000);
           // System.out.println("删除成功");
        }

        //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());

    }

}

文件夹操作：

package demo07;

import java.io.File;
import java.util.Date;

public class Demo07 {
    public static void main(String[] args) {
fileOpe();
    }
    public static  void fileOpe(){
        File file=new File("d:\\aaa\\bbb\\ccc");
        //1创建
        if(!file.exists()){
            //file.mkdir();//单级目录
            System.out.println("创建结果："+file.mkdirs());//多级目录
        }
        //2删除
//        if (file.exists()){
//            //file.delete();//直接删除
//           file.deleteOnExit();//jvm删除
//        }
        //3获取信息
        System.out.println("获取绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件夹名称："+file.getName());
        System.out.println("获取文件创建时间："+new Date(file.lastModified()).toLocaleString());
        //4判断
        System.out.println("是否是文件夹："+file.isDirectory());
        System.out.println("是否是隐藏："+ file.isHidden());
        //5遍历
        File file1=new File("d:\\JAVA");
        String[] list1 = file1.list();
        for ( String s:list1){
         System.out.println(s);
       }


    }
}

FileFilter接口

过滤器

package demo07;

import java.io.File;
import java.io.FileFilter;

public class Demo08 {
    public static void main(String[] args) throws Exception{
    fileOpe();
    }
    public static  void fileOpe()throws Exception{
        File file=new File("d:");
      File [] files=  file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".txt")){
                    return true;
                }
                return false;
            }
        });
        for (File file1:files) {
            System.out.println(file1);
        }
    }
}

递归遍历和递归删除

package demo07;

import java.io.File;

public class Demo09 {
    public static void main(String[] args) {
      // fileOpe(new File("d:\\我的坚果云"));
        deleteDir(new File("d:\\WeGameApps"));
    }
    public static void fileOpe(File dir){
        File [] files=dir.listFiles();
        System.out.println(dir.getAbsolutePath());
       if (files!=null&&files.length>0){
        for (File file:files){
            if (file.isDirectory()){
                fileOpe(file);//递归
            }else{
                System.out.println(file.toString());
            }
        }
       }


    }


    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集合：属性集合
  • 特点：
      1. 存储属性名和属性值
      2. 属性名和属性值都是字符串类型
      3. 没有泛型
      4. 和流有关
package demo07;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Demo10 {
    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        properties.put("username","zhangsan");
        properties.put("age","20");

        //遍历
//        for (Object keySet :properties.keySet()) {
//            System.out.println(keySet+"----------------"+properties.get(keySet));
//        }
//        for (Map.Entry entry:properties.entrySet()){
//            System.out.println(entry+"=========="+entry.getValue());
//        }
        Set<String> strings = properties.stringPropertyNames();
        for (String s:strings){
            System.out.println(s+"=========="+properties.getProperty(s));
        }
//list方法
//        PrintWriter pw=new PrintWriter("d:\\print01.txt");
//        properties.list(pw);
//        pw.close();


        //保存store
//        FileOutputStream fos=new FileOutputStream("d:\\store.properties");
//        properties.store(fos,"注释");
//        fos.close();


        //load加载
Properties properties1=new Properties();
        FileInputStream fis=new FileInputStream("d:\\store.properties");
        properties1.load(fis);

        fis.close();
        System.out.println(properties1.toString());
    }
}
And the life
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java IO流学习笔记
m764395448的博客
10-07 206
I/O 框架 1 流的概念 内存与存储设备之间传输数据的通道 2 流的分类 2.1 按方向【重点】 输入流：将<存储设备>中的内容读到<内存>中 输出流：将<内存>中的内容写到<存储设备>中 2.2 按单位 字节流：以字节为单位，可以读写所有数据 字符流：以字符为单位，只能读写文本数据 2.3 按功能 节点流：具有实际传输数据的读写功能 过滤流：在节点流的基础之上增强功能 3 字节流 下面两个为字节流的父类（抽象类） //InputStream
java IO 框架图
05-20
详细描述了包java.io中类之间的继承关系
java decorator模式_学习：java设计模式—Decorator模式
weixin_35782250的博客
02-15 126
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝可从IO的类层次，IO框架的设计模式来论述。总体来说，IO可以分为字节流和字符流，不同在于字符流由字节流包装而来，在IO读入之后经过JVM处理，把字节流转换成字符流。而字符流的字符采用哪种字符编码实现由JVM默认编码决定。而每个流都分输入和输出，所以，总体来说，IO有四个顶层类：InputStreamOutputStreamRe...
JavaIO框架​​​​
qq_57216731的博客
12-05 394
流 字节流抽象类
Java中的IO框架
qq_44719987的博客
10-10 356
什么是流？ 内存与存储设备之间传输数据的通道 流的分类 输入流：将<存储设备>中的内容读入到<内存> 输出流：将<内存>中的内容写入到<存储设备>中 字节流：以字节为单位，可以读写所有数据 字符流：以字符为单位，只能读写文本数据 节点流：具有实际传输数据的读写功能 过滤流：在节点流的基础之上增强功能 ...
Java之 IO框架
Ifeng_iPhone的博客
08-31 665
把使用字节输入流读取到的字节，写入到指定文件中，边读取边写入，达到一个复制的效果。OutputStream 字节输出流使用来写入文件，一次写入一个字节。InputStream 字节输入流使用来读取文件，一次读取一个字节。内部做了优化，减少了和磁盘的交互，提高了字节读取的效率。内部做了优化，减少了和磁盘的交互，提高了字节读取的效率。缓冲字符输出流和字符输出流的用法是一样的。字符输入流读取数据，每次读取一个字符。字符输出流写入数据，每次写入一个字符。一次读取一个字节，字节流 byte。...
java-IO框架图
03-25
例如，javaio.bmp和javaio2.bmp可能是两张展示IO框架图的图片，其中详细描绘了不同类之间的继承关系和使用场景，帮助开发者更好地理解和掌握Java IO系统。 总结一下，Java IO框架是Java平台不可或缺的一部分，它为...
JAVA_IO流整理思维导图.emmx
06-04
JAVA_IO流整理思维导图.
Java IO_NIO
11-23
Java IO（Input/Output）是Java编程语言中用于处理输入输出操作的基础框架，它提供了丰富的类库，使得程序能够与各种设备、文件、网络进行数据交互。然而，传统的IO模型在处理大量并发连接时表现出效率较低的问题，...
scalable io in java
07-03
Doug Lea在书中探讨了Java的NIO（New IO）框架，它是对传统IO的一个重大改进。NIO引入了非阻塞IO和选择器（Selector），允许一个线程同时管理多个通道（Channel），极大地提高了系统在处理并发IO请求时的效率。通过...
Io框架与类图
01-06
延续上次的内容（IO）
Java I/O框架
只是个人笔记，请见谅
01-11 596
Java I/O框架什么是流流的分类字节流FileInputStreamFileOutputStream案例--文件流复制字节缓冲流BufferedInputStreamBufferedOutPutStream对象流序列化反序列化序列化和反序列化注意事项常见字符编码字符流抽象类FilereaderFileWriter案例--实现文件复制字符缓冲流BufferReaderBufferWriter打印流转换流InputStreamReaderOutputStreamWriterFile类文件的操作分隔符创建文件
javaIO框架
yunteng0923的博客
05-13 302
IO框架介绍 IO（Input/Output）是计算机输入/输出的接口。java的核心库java.io提供了全方面的IO接口，包括：文件系统的操作，文件读写，标准设备输出等等 File类及其使用 1.一个File类的对象，表示了磁盘上的文件或者目录 2.File类提供了与平台无关的方法来对磁盘上的文件或目录进行操作 3.File类直接处理文件和文件系统。比如删除文件，获取文件长度大小
JAVA IO框架
ForgetSky的博客
12-02 167
IO简介 数据流是一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。 流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此，Java中的流分为两种： 1) 字节流：数据流中最小的数据单元是字节 2) 字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。 Java.io包中最重要的就是5个类和一个接口。 5个类指的是File、OutputStream、InputStream、Writer、R
Java IO框架
最新发布
m0_56925275的博客
08-13 142
此篇博客介绍了Java IO框架的基本概念和用法。它详细解释了输入流和输出流的作用以及读取和写入数据案例。此外，该博客还讨论了常见的IO类和接口，例如File类和BufferedWriter类，以及NIO和AIO。通过阅读这篇博客，读者将对Java IO框架有一个清晰的了解，并能够更有效地处理文件和数据的输入输出操作。
java io框架
swjtufei的专栏
10-11 171
待补充···
java IO框架
西瓜
09-25 349
https://blog.csdn.net/github_38841849/article/details/79686757 https://blog.csdn.net/qq_27093465/article/details/53233273
IO框架Java
King Gigi的博客
03-16 103
IO流 1.什么是流 概念：内存与存储设备之间传输数据的通道。 存储设备<---->内存<--->存储设备 2.流的分类 按方向： 输入流：将存储设备中的内容读取到内存中 输出流：将内存中的内容写入到存储设备中 按单位： 字节流：以字节为单位，可以读写所有数据 字符流：以字符为单位，只能读写文本数据 按功能： 节点流：具有实际传输数据的读写功能 过
Java IO框架详解：File类与流的概念
本文档介绍了Java中的IO框架，特别是关于流的概念和分类，以及File类的使用。 在Java中，IO框架是用于处理输入和输出操作的重要部分，它允许程序与各种类型的输入源（如硬盘、网络、内存等）进行数据交换。流是这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值