java中常见的IO流

已于 2022-07-27 14:44:38 修改
阅读量480 收藏 3
点赞数
文章标签： 学习
于 2022-07-27 14:19:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43185247/article/details/126012837
版权

IO流

IO流：Input 和 Output

IO流分类

按读取方式分类：
字节流：InputStram,OutputStream (”以 Stream 结尾)
字符流：Reader/Writer (“ Reader/Writer ”结尾)

JAVA常用的流

FileInputStream 
public class FileInputStreamTest {
    public static void main(String[] args) throws FileNotFoundException {

        //FileInputStream   Stream都是字节流  FileInputStream是可以读取任何文件的
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("src/test.txt");

            // 开始读，采用byte数组，一次读取多个字节。最多读取“数组.length”个字节。
            byte[] bytes=new byte[1024];// 准备一个1024个长度的byte数组，一次最多读取1024个字节。

            int readCount = 0;
            // 这个方法的返回值是：读取到的字节数量。（不是字节本身）;1个字节都没有读取到返回-1(文件读到末尾)
            while((readCount = fis.read(bytes)) != -1) {
                // 不应该全部都转换，应该是读取了多少个字节，转换多少个。
                System.out.print(new String(bytes, 0, readCount));
            }

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

            // 在finally语句块当中确保流一定关闭。
            if (fis != null) {// 避免空指针异常！
                // 关闭流的前提是：流不是空。流是null的时候没必要关闭。
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
}
FileOutputStream 
public class FileOutputStreamTest {
    public static void main(String[] args) {


        FileOutputStream fos = null;
        try {
            // myfile文件不存在的时候会自动新建！
            // 这种方式谨慎使用，这种方式会先将原文件清空，然后重新写入。
            //fos = new FileOutputStream("myfile");

            // 以追加的方式在文件末尾写入。不会清空原文件内容。
            fos = new FileOutputStream("src/test01.txt", true);
            // 开始写。
            byte[] bytes = {97, 98, 99, 100};
            // 将byte数组全部写出！
            fos.write(bytes); // abcd
            // 将byte数组的一部分写出！
            fos.write(bytes, 0, 2); // 再写出ab

            // 字符串
            String s = "我是一个中国人，我骄傲！！！";
            // 将字符串转换成byte数组。
            byte[] bs = s.getBytes();
            // 写
            fos.write(bs);

            // 写完之后，最后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
         catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}
FileReader 
public class FileReaderTest {
    public static void main(String[] args) throws FileNotFoundException {

        //FileReader 文件字符输入流，只能读取普通文本。读取文本内容时，比较方便，快捷
        FileReader reader = null;
        try {
            // 创建文件字符输入流
            reader = new FileReader("src/test01.txt");

            // 开始读
            char[] chars = new char[4]; // 一次读取4个字符
            int readCount = 0;
            while((readCount = reader.read(chars)) != -1) {
                System.out.print(new String(chars,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
FileWriter 
public class FileWriterTest {
    public static void main(String[] args) {

        //FileWriter文件字符输出流。写。只能输出普通文本。
        FileWriter out = null;
        try {
            // 创建文件字符输出流对象
            //out = new FileWriter("file");
            out = new FileWriter("src/test01.txt", true);

            // 开始写。
            char[] chars = {'你','是','中','国','人','吗'};
            out.write(chars);
            out.write(chars, 2, 3);  // 中国人

            out.write("我是一名java软件工程师！");
            // 写出一个换行符。
            out.write("\n");
            out.write("hello world!");

            // 刷新
            out.flush();

        } catch (  Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}
BufferedReader
InputStreamReader 
package com.example.IO;

import java.io.*;

public class BufferReaderTest {

    public static void main(String[] args) throws IOException {

        FileReader reader = new FileReader("src/test.txt");
        // 当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。
        // 外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流。
        // 像当前这个程序来说：FileReader就是一个节点流。BufferedReader就是包装流/处理流。
        BufferedReader br = new BufferedReader(reader);
		
		//BufferedReader br = new BufferedReader(  new FileReader("src/test.txt") );
        // br.readLine()方法读取一个文本行，但不带换行符。
        String s = null;
        while((s = br.readLine()) != null){
            System.out.println(s);
        }

        // 关闭流
        // 对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭。（可以看源代码。）
        br.close();




       /*
        // 字节流
        FileInputStream in = new FileInputStream("src/test.txt");

        // 通过转换流转换（InputStreamReader将字节流转换成字符流。）
        // in是节点流。reader01是包装流。
        InputStreamReader reader01 = new InputStreamReader(in);

        // 这个构造方法只能传一个字符流。不能传字节流。
        // reader是节点流。br是包装流。
        BufferedReader br01 = new BufferedReader(reader01);

        */

        // 合并
        BufferedReader br01 = new BufferedReader(new InputStreamReader(new FileInputStream("src/test.txt")));

        String line = null;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }

        // 关闭最外层
        br.close();






    }
}
BufferedWriter
OutputStreamWriter 
package com.example.IO;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;

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

        //BufferedWriter
        BufferedWriter bw=new BufferedWriter( new FileWriter("src/test01.txt"));

        bw.write("111");
        bw.write("\n");
        bw.write("00000000");

        bw.flush();
        bw.close();


        //OutputStreamWriter  字节流转换成字符流
        // 带有缓冲区的字符输出流
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("src/test01.txt", true)));
        // 开始写。
        out.write("hello world!");
        out.write("\n");
        out.write("hello kitty!");
        // 刷新
        out.flush();
        // 关闭最外层
        out.close();



    }

}
BufferedInputStream
BufferedOutputStream 
package com.example.IO;

import java.io.*;

public class BufferedInOutputStreamTest {
    public static void main(String[] args) {

        String srcFilePath = "d:\\111\\boluo.jpg";
        String destFilePath = "d:\\111\\ld.jpg";

        //创建BufferedInputStream和BufferedOutputStream对象
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            bis = new BufferedInputStream(new FileInputStream(srcFilePath));
            bos = new BufferedOutputStream(new FileOutputStream(destFilePath));

            //循环的读取文件，并写入到
            byte[] buff = new byte[1024];

            int readLen = 0;
            //当返回 -1时，就表示文件读取完毕
            while((readLen = bis.read(buff)) != -1){
                bos.write(buff,0,readLen);
            }
            System.out.println("文件拷贝完成~~~");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭外层的处理流即可,底层去关闭节点流
            try {
                if (bis != null){
                    bis.close();
                }
                if(bos != null){
                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}
File 
class FileTest{
    public static void main(String[] args) {

        //创建文件
        File f1 = new File("D:/IO/File1.txt");
        if (!f1.exists()){
            try {
                f1.createNewFile();//创建文件

            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        //创建文件夹
        File f2 = new File("D:/IO/File2");
        if (!f2.exists()){
            f2.mkdir();//创建文件夹
        }

        //创建多重文件夹
        File f3 = new File("D:/IO/File3/a/b/c/d/e/f/g/h/i");
        if (!f3.exists()){
            f3.mkdirs();//创建多重文件夹
        }

        File f5 = new File("D:\\IO\\FileDelete");
        f5.delete();

        File f4 = new File("D:\\Data\\新建文件夹");
        String s1 = f4.getName();//新建文件夹
        System.out.println(s1);

        String s2 = f4.getParent();//D:\Data
        System.out.println(s2);

        String s3 = f4.getPath();//D:\Data\新建文件夹
        System.out.println(s3);

        String s4 = f4.getAbsolutePath();//D:\Data\新建文件夹
        System.out.println(s4);

        File asf = f4.getAbsoluteFile();
        System.out.println(asf.getAbsolutePath());//D:\Data\新建文件夹

        File pf = f4.getParentFile();
        System.out.println(pf.getAbsolutePath());//D:\Data

        System.out.println(f4.isDirectory());//true

        System.out.println(f4.isFile());//false

        System.out.println(f4.isHidden());//false

        System.out.println(f4.isAbsolute());//true

        File f6 = new File("D:\\IO\\Day24.java");
        System.out.println(f6.length());//5743字节




    }
}
是胡不是华
关注
Java 常见的 IO流
流楚丶格念的博客
11-04 1275
其中，节点流可以直接从/向一个特定的IO设备读/写数据，也称为低级流。流是Java对不同输入源输出源的抽象，代表了从起源到接收的有序数据，有了它程序就可以采用统一的方式来访问不同的输入源和输出源了。java.io.OutputStreamWriter （字符字节输出流，将字节输出流转换为字符输出流）java.io.InputStreamReader （字符字节输入流，将字节输入流转换为字符输入流）其中，字节流操作的数据单元是byte（字节），而字符流操作的数据单元是char（16位的字符）。
Java常见的IO流
qq_38056518的博客
09-13 152
Java常见的IO流 1、IO流 其中InputStream、OutputStream、Reader、Writer都是抽象类，后面跟着都是其实现，下面使用这些实现完成文件的复制操作并且比较其速率。 2、字节流 2.1、基类 （1）InputStream 字节输入流的父类，常用方法 abstract int read() 从输入流中读取数据的下一个字节，返回是一个整形，读到文件末尾返回-1，-1也表示文件的结尾 int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储到缓存数组b中
Java中常见的IO流及其使用
热门推荐
孙群
07-09 1万+
Java中常见的IO流的介绍及使用： ByteArrayInputStream & ByteArrayOutputStream FileInputStream & FileOutputStream PipedInputStream & PipedOutputStream ObjectInputStream & ObjectOutputStream SequenceInputStream ...
Java-IO流
最新发布
2201_75456927的博客
07-27 1013
将数据写到文件中，实现数据永久化存储把文件中的数据读取到内存中(Java程序)I 表示intput ，是数据从硬盘进内存的过程，称之为读数据O 表示output ，是数据从内存到硬盘的过程。称之为写数据java.io.FileOutputStream类是OutputStream类的子类,用来表示是 文件输出流，用于将数据写出到文件。java.io.FileInputStream 类是InputStream类的子类 , 用来表示文件 输入流，从文件中读取字节。
java中常用IO流
weixin_46672808的博客
01-18 292
java中IO输入输出流 java中IO字符输入输出流 java文件缓冲流 Java打印流的使用 java中的对象流 java中的字节数组流 Java数据流 java中的字符串流
JAVA中常用的IO流
qq_45654167的博客
08-07 327
一、什么是IO流？ I：Input O：Output 通过IO可以完成对硬盘文件的读和写，Java中使用流的概念来加快I/O操作的速度。 java.io软件包包含输入和输出操作所需的所有类。 二、什么是流？ Stream是数据序列。在Java中，流由字节组成。之所以称其为流，是因为它就像不断流动的水流一样。 三、IO流的分类？ 输入流、输出流、字节流、字符流 在java中只要“类名...
Java 中常用的IO流
LX_1234567的博客
07-17 1424
java常用Io流
Java中文件IO流.pdf
07-11
Java 中文件 IO 流 Java 中文件 IO 流是指 Java 语言中对文件的输入输出操作，通过定义文件流来实现文件的读写操作。文件流是指在程序中用于文件输入输出的对象， Java 中提供了多种文件流类型，包括 InputStream ...
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
关于Java中的IO流总结(推荐)
08-30
Java 中的 IO 流总结 Java 中的 IO 流是一种基本的数据输入/输出机制，它允许程序从外部设备、文件或网络中读取数据或将数据写入外部设备、文件或网络中。下面是 Java 中 IO 流的总结： 一、流的继承关系 Java 中...
Java中的IO流
12-22
一、 什么是IO流 一般情况下是按照当前程序使用的内存为参照物来考虑数据的走向问题。 以文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取数据到内存 input 看视频，缓冲 使用缓冲可以让用户体验提高，相对...
JAVA常用IO流
u013733643的博客
04-03 395
Java 常用IO流操作详解 1.基本概念 IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。 2.IO流的分类 图示：（主要IO流） 3.字节流 （1）.字节流基类 1）.InputStream InputStream：字节输入流基类，抽象类是表示字节输入流的所有类的超类。 常用方法： // 从输入流中读取数据的下一个字节 abstract int read() ..
java 常用IO流梳理，持续更新...
bo_wei的博客
05-08 446
java 常用IO流梳理，持续更新...
JAVA 常用IO流
qq_32363305的博客
09-13 136
1.什么是IO流 IO：Input Output a.介绍 1.Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中； 2.流是干什么的？ 为了永久性的保存数据 根据数据流向的不同分为输入流和输出流； 根据处理数据类型的不同分为字符流和字节流； 3.InputStream(字节输入流)和Reader(字符输入流...
Java 中常用的 IO 流
qq_45914985的博客
06-01 231
什么是流: 在 Java 中所有数据都是使用流来读写的. 流是对数据传输的总称和抽象. 即数据在两个设备间的传输称为流, 流的本质是数据传输, 根据数据传输的特性, 将流抽象为各种类. 为什么需要缓冲流: 当我们 read() 读取文件的时候, 每读取一个字节都会访问一次硬盘, 效率非常低, 当文件过大的时候尤为显著, 因此需要使用 buffered 缓冲流, 当创建 buffered 对象的时候, 会创建一个缓冲区数组, 此时读文件的时候, 会先从硬盘读到缓冲区, 然后直接从缓冲区输出. 注
java常用io流_Java常用工具_IO流
weixin_31613423的博客
02-13 123
1. 异常1.1 异常的概述image.png1.2 异常的处理方式Java中异常的顶层父类是Throwablefinally中的语句一定会执行，即使catch中有return，finally里的代码也会执行，这就是加不加finally的区别。image.pngimage.pngpackage cn.case5;public class Test4 {public static void main...
JAVA——常用IO流类
u010028461的专栏
12-28 871
常用IO流类关系图 字节流:用来操作字节数据,字节流可以用来拷贝所有的数据,文件读和写,但是字节流读取中文有可能造成乱码。 字符流:字符流读取中文不会造成乱码,字符流可以用来拷贝(文件读和写)纯文本的数据,非纯文本的不能用字符流来拷贝,只能用字节流 常用流的用法例子 普通纯文本复制粘贴方法 public boolean copyValueOfText(String url) thro
java常用IO流操作
一名小码农的博客
04-24 686
一、概述 1. 流的分类 2. 常用流的继承关系 二、File类 1. 构造方法 2. 实例方法 3. 静态方法 4. 一些例子 三、InputStream及其子类 1. InputStream 2. FileInputStream 3. BufferedInputStream 4. DataInputStream 5. ObjectInputStream 四、OutputStream及其子类
Java中的IO流：缓冲流详解
"本文主要介绍了Java中的IO流，特别是如何过滤和使用缓冲流。Java的I/O流系统是建立在java.io包中的类层次结构上，涵盖了字节流和字符流，提供了处理输入和输出的强大功能。对于字节流，我们关注了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值