关于Java的IO流

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量188 收藏
点赞数
文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45595142/article/details/106752048
版权

一.字节流

字节流分为 输入字节流和输出字节流，其中输入字节流对应着read，读取文件内容，字节输出流对应着write，向文件中写入，这里可以比喻成读书，知识就进入了脑海，所以是InputStream，写字是将脑海中的知识写出，所以是OutputStream。
在使用字节流时，不能直接使用，通常要经过处理流（这里涉及到装饰者模式）
装饰者模式：

在这里插入图片描述
演示：


/**
 * 一切都可以是字节流(inputStream,outputStream);
 * 还有字符流（read,write）,字符流也可以看为是字节流
 * 字符流一般处理字符集的文件,而字节流所有都可以处理
 * 字节流需要处理流才有用（比如FileInputStream）*/
public class IOTest {
    public static void main(String[] args) throws IOException {

        InputStream is =null;
        //第一步选择源
        File file = new File("test.txt");
        try {
            //第二步选择流
            is= new FileInputStream(file);
            //第三步操作
            byte[] bytes=new byte[1024];//1k1k的进行读取
            int len=-1;
            //这里会将读取的长度赋值给len并将读取的元素赋值给
            // bytes,当没有元素的时候读到的是-1
            while ((len=is.read(bytes))!=-1){
               String s=new String(bytes,0,len);
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //第四步释放资源
            if(is!=null){
                is.close();
            }
        }

    }
}


public class OSTest {
    public static void main(String[] args) throws IOException {
        //第一步寻找源
        File file=new File("test.txt");
        FileOutputStream os =null;

        try {
            //第二步选择流,后面的append是选择是否在原有的基础上追加内容
            os=new FileOutputStream(file,true);
            //第三步操作
            String s="hell world";
            byte[] bytes=s.getBytes();//字符串转化成byte类型的数组
            os.write(bytes,0,s.length());
            os.flush();//每次写完刷新一下
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //第四步释放资源
            if(os!=null) os.close();
        }
    }
}

除了字节流，还有字符流，字符流适用于直接读取文本内容，更方便快捷：操作上有一点的小差异

public class ReaderTest {
    public static void main(String[] args) throws IOException {
        File file = new File("test.txt");
        FileReader re =null;
        try {
            re= new FileReader(file);
            char[] chars=new char[1024];
            int len=-1;
            while((len=re.read(chars))!=-1){
                String s=new String(chars,0,len);
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(re!=null) re.close();
        }
    }
}


public class WriteTest {
    public static void main(String[] args) {
        File file = new File("test.txt");
        Writer wr =null;
        try {
           wr=new FileWriter(file,true);
           String s="我一路向北";
            /*第一种写法
            char[] chars = s.toCharArray();字符串转化为字符数组
            wr.write(chars,0,chars.length);
            */
          /*  //第二种写法直接写入
            wr.write(s);
            wr.flush();*/
          /*第三种写法*/
            wr.append("xij").append("xasda");
            wr.flush();//必须要刷新,不然会操作失败
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲流：用于提高效率，直接将原来的处理流套上即可，操作没什么改变：

/**
 * 字节输入缓冲流,只要将字节输出流放进构造里即可,操作还是和原来一样
 * 知识效率变高*/
public class BufferIS {
    public static void main(String[] args) {
        File file = new File("test.txt");
        FileInputStream is =null;
        try {
          is=new FileInputStream(file);
            BufferedInputStream BufferIS = new BufferedInputStream(is);
            int len=-1;
            byte[] bytes = new byte[1024];
            while((len=BufferIS.read(bytes))!=-1){
                String s=new String(bytes,0,len);
                System.out.println(s);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

缓冲字节输出流：

/**
 * 字节输出缓冲流,只要将字节输出流放进构造里即可,操作还是和原来一样
 * 知识效率变高*/
public class BufferOS {
    public static void main(String[] args) throws IOException {
        File file = new File("test.txt");
        FileOutputStream os =null;
        BufferedOutputStream BufferOS =null;
        try {
          os= new FileOutputStream(file);
            BufferOS=  new BufferedOutputStream(os);
            String s="woyiluxiangbei";
            byte[] bytes = s.getBytes();
            BufferOS.write(bytes,0,s.length());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            BufferOS.close();
        }
    }
}

还有字符缓冲流，但是在原有的基础上提供了更加便利的方法，使操作更加简便：
在使用时候一定要注意不能使用多态！！！！

BufferReader提供了readLine（）方法可以整行读取，不用再像原来那样麻烦

/**
 * 字符缓冲流,只要在原有的基础上套一层,就可以提高性能,
 * 操作一样*/
public class BReader {
    public static void main(String[] args) throws IOException {
      /*  第一种写法,只是普普通通的加上缓冲,但没有用新方法
        File file = new File("test.txt");
        Reader reader = new BufferedReader(new FileReader(file));
        int len =-1;
        char[] chars = new char[1024];
        while((len=reader.read(chars))!=-1){
            String s = new String(chars, 0, len);
            System.out.println(s);
        }*/
      //第二种采用新方法
        File file = new File("test.txt");
        //不能使用多态,即不能使用Reader reader=null
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String s=null;
        while ((s=reader.readLine())!=null){
            System.out.println(s);
        }
    }
}

而BufferedWriter则提供了newLine（）进行换行

/**
 * 字符缓冲流,提高效率*/
public class BWriter {
    public static void main(String[] args) throws IOException {
     /* 第一种写法：没有用到新方法,只是在原有的基础上加缓冲流
        File file = new File("test.txt");
        Writer writer = new BufferedWriter(new FileWriter(file));
        String s="World";
        writer.write(s);
        writer.flush();*/
     //第二种写法,注意不能使用多态,即不能使用Writer w=null
        File file = new File("test.txt");
        BufferedWriter writer = new BufferedWriter(new FileWriter(file));
        writer.append("Hello");
        writer.newLine();//新方法,无需在用/r/n进行换行,这个就代表换行
        writer.append("World");
        writer.flush();
    }
}

还有转化流：InputStreamReader，可以提供字符集

public class Inreader {
    public static void main(String[] args) {
        //InputStreamReader将字节流转化为字符流操作
        InputStreamReader isr = new InputStreamReader(System.in);
        //加入缓冲
        BufferedReader reader = new BufferedReader(isr);
        OutputStreamWriter osw = new OutputStreamWriter(System.out);
        //加入缓冲
        BufferedWriter writer = new BufferedWriter(osw);
        try{
            String msg="";
            while (!msg.equals("exit")){
                msg=reader.readLine();
                writer.write(msg);
                writer.newLine();
                writer.flush();
            }
            }catch (Exception e){

        }
    }
}

OutputStreamWriter：

public class OutWriter {
    public static void main(String[] args) throws IOException {
        File file = new File("test.txt");
        FileOutputStream osm =null;
        OutputStreamWriter osw =null;
        BufferedWriter writer =null;
        try {
          osm= new FileOutputStream(file);
          //将字节流转化为字符流并指定字符集
           osw= new OutputStreamWriter(osm,"UTF-8");
           writer= new BufferedWriter(osw);
           String s="我一路向北";
           writer.write(s);
           writer.flush();//记住要刷新
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(writer!=null) writer.close();
            if(osw!=null) osw.close();
            if(osm!=null) osm.close();
        }
    }
}

打印流：

/**
 * 打印流*/
public class PWriter {
    public static void main(String[] args) throws FileNotFoundException {
        PrintStream ps=System.out;
        ps.println("xx");
       ps=new PrintStream(new BufferedOutputStream(new FileOutputStream("test.txt")),true);
       ps.println("Hello jay");
       ps.flush();//可以设置自动刷新

        //第二个打印流
        PrintWriter pw=new PrintWriter(new BufferedOutputStream(new FileOutputStream("test.txt")),true);
        pw.print("asfka");
        pw.flush();
    }
}

字节数组流:在网络编程的时候有需要

在这里插入图片描述
在这里插入图片描述

数据流：专门操作基本数据类型，字符串的

在这里插入图片描述

对象流：不仅可以操作基本数据类型，还可以操作对象，操作的对象必须序列化

/**
 * 操作对象的流,除了可以操作基本数据类型,还可以操作对象,其构造函数需要一个字节流*/
public class ObjectISOS {
    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeInt(1);//对象数组流同样可以操作基本数据类型
        person person = new person("jr",2);
        oos.writeObject(person);//写入对象
        oos.flush();
        byte[] bytes = bos.toByteArray();

        //读取
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(bis);
        int i = ois.readInt();//同样按照上面写入的顺序读取
        person o = (TestISOS.person) ois.readObject();
        System.out.println(o.getName()+"==>"+i);

    }
}
class person implements Serializable{
    private transient String name;//transient关键字修饰的属性不会被序列化
    private int age;

    public person(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;
    }
}
风中小白
关注
关于Java中的IO部分介绍
weixin_43201538的博客
05-04 258
Java 的IO 任何编程语言都要和文件打交道，都要有输入输出的操作。 基于此，我们有字节、字符的输入、输出流的概念。 输入输出的概念是相对的，一般我们都是站在编写的程序下的角度看的。 我们还有 字节、字符的概念。 字节： 计算机存储东西，一般都是基于字节来存储的，也就是我们看到的五彩斑斓的电脑世界（比如说视频、图像、音频啊等等的），他们在内存中，在磁盘中，都是以 字节 的形式来存储的。（或...
java中的io流知识总结_关于java中的io流知识总结详解
weixin_34587189的博客
02-12 400
一、Java io的开始：文件1. 我们主要讲的是流，流的本质也是对文件的处理，我们循序渐进一步一步从文件将到流去。2. java 处理文件的类 File，java提供了十分详细的文件处理方法，举了其中几个例子，其余的可以去packagecom.hxw.io; importjava.io.*; publicclassFileExample{publicstaTIcvoidmain(String［］...
Java的IO流
security
05-14 287
Java目录IO流IO流的操作规律总结IO流体系 IO流 输入流、输出流 字节流、字符流 为了处理文字数据方便而出现的对象。(其实这些对象的内部使用的还是字节流(因为文字最终也是字节数据，只不过，通过字节流读取了相对应的字节数，没有对这些字节直接操作，而是去查了指定的(本机默认的)编码表，获取到了对应的文字.）) 字符流就是 ： 字节流+编码表。 缓冲区 提高效率的，提高谁的效率？提高流的操作数据的效率。 所以创建缓冲区之前必须先有流。 缓冲区的基本思想：其实就是定义容器将数据进行临时存
java创建本地文件_Java学习 第五章 java本地文件操作
weixin_28958239的博客
02-13 77
importjava.io.BufferedReader;importjava.io.BufferedWriter;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
javaIO流详解
weixin_46676497的博客
01-27 2820
java常用io流介绍
Java io流 详解
m0_68987535的博客
06-11 4832
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
JavaIO流：模型
栗筝i的博客
11-24 3826
IO 的字面意思是读/写数据，IO 模型是读/写数据的方式。常用到的读/写数据方式有：同步阻塞 IO、同步非阻塞 IO、IO 多路复用、信号驱动、异步 IO 本篇内容包括：Java IO 与 IO 模型、五种 IO 模型、三种 Java IO 模型。
IO笔记.zip关于javaIO流部分的详细笔记
10-01
Java IO流是Java平台中处理输入输出操作的核心组件，它为数据传输提供了强大的支持。本笔记将深入探讨Java IO流的各个方面，从基础的节点流到功能强大的装饰缓冲流，帮助开发者更好地理解和应用这一关键概念。 一、...
关于java IO 流的知识
06-22
关于java IO 流的知识.
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
java 图片io流_关于JavaIO流的图片读取
weixin_32757449的博客
02-16 1091
关于JavaIO流的图片读取自我介绍一下大家好，新的一年,新的一个学期…我是一个大二的学生，我姓林。最近Java刚刚学到IO流这一板块知识。在此，发表一下关于IO流的图片读取总结的心得还有思路…简单介绍一下IO板块中有输出流还有输入流，后面还有缓冲流等等 ，现在简单介绍输出流还有输入流在Java的IO这一板块中,有输入流InPutStream(当然，这是输入流的父类也是抽象类)它的子类是FileI...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 556
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1052
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 698
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 417
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 220
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
JavaScript的第十一天
全栈学习ing
10-31 773
在使用offset系列时需注意该属性为css属性，一般用于和javascript结合使用来获取信息，所以在使用该属性时只能获取值而不能改变值。最近的具有定位属性的祖先元素顶部边缘左侧边缘。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值