java中IO流的操作

已于 2023-03-18 17:32:50 修改
阅读量514 收藏 1
点赞数
分类专栏： java 文章标签： java
于 2023-03-17 14:58:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JEREMY_GYJ/article/details/129615157
版权

对于java中io流的一些操作和类进行总结

io流的分类：

 字节流：用来处理二进制文件

字符流：用来处理文本数据

文件io流：

字节流：

InputStream的子类：

FileInputStream类:

读的方式：read

  • 一个字节的读取：
public class test_FileInputStream {

    public static void main(String[] args) {

    }
    @Test

     
    public void test_FileInputStream() throws IOException {

        String filepath="D:\\网盘文件\\hello.txt";
        FileInputStream fileInputStream=null;
        int read_data=0;//读取文件字节数
        try {
            fileInputStream=new FileInputStream(filepath);
            
            //read读取的字节数：如果读取失败的话就直接返回-1
            while ((read_data=fileInputStream.read())!=-1){
                System.out.print((char) read_data);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            fileInputStream.close();
        }
    }
}
  • 使用byte数组来读取：
public class test_FileInputStream02 {

    public static void main(String[] args) {

    }


    @Test
    public void test_FileInputStream02() throws IOException {

        String filepath="d:\\网盘文件\\hello.txt";

        byte[] buf=new byte[10];
        FileInputStream fileInputStream=null;
        int read_len=0;//读取文件字节数

        try {
            fileInputStream=new FileInputStream(filepath);
            //按位数组读取元素：
            while ((read_len=fileInputStream.read(buf))!=-1) {
                System.out.print(new String(buf,0,read_len));
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            fileInputStream.close();
        }
    }
}

OutputStream子类：

FileOuputStream类：

写入的方式：

  •  写入文件内容：
public class test_FileOutputStream {
    public static void main(String[] args) {

    }

    @Test
    public void fileOutputStream() throws IOException {

        String filename="D:\\网盘文件\\hello.txt";
        FileOutputStream fileOutputStream=null;
        //写入文件的内容：
        String str="hello world";

        try {
            //写入文件使用追加的方式：
            fileOutputStream=new FileOutputStream(filename,true);
            fileOutputStream.write(str.getBytes());
            System.out.println("写入文件成功！");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            fileOutputStream.close();
        }
        
    }
}

文件拷贝：

public class test_拷贝文件 {

    public static void main(String[] args) {

    }

    @Test
    public void copyfile(){

        String srcfile="d:\\file.txt";
        String desfile="d:\\网盘文件\\file.txt";
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        int read_len=0;
        byte [] buf=new byte[1024];

        try {
            fileInputStream=new FileInputStream(srcfile);
            fileOutputStream=new FileOutputStream(desfile);

            while ((read_len=fileInputStream.read(buf))!=-1){
                //使用位数组的方式拷贝文件：
                fileOutputStream.write(buf,0,read_len);
                System.out.println("拷贝文件完成！");
            }

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

        }
    }
}

字符流：Reader 和Writer

Reader:实现的子类

FileReader类：

 public class test_FileReader {

    //Reader的实现子类；
    /***
     *
     * 使用读取单个字符的方式
     * ***/
    @Test
    public void file_reader01() throws IOException {
        String filepath="d:\\file.txt";
        FileReader fileReader =null;
        int read_len=0;
        try {
            fileReader=new FileReader(filepath);
            System.out.print("读取字符为：");
            while ((read_len=fileReader.read())!=-1){

                System.out.print((char)read_len);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
           fileReader.close();
        }

    }

    /***
     *
     * 使用字符数组的方式进行读取文件
     * **/
    @Test
    public void file_reader02() throws IOException {
        String filepath="d:\\file.txt";
        FileReader fileReader =null;
        //使用字符数组的方式进行读
        char [] chars=new char[20];
        int read_data=0;

        try{
            fileReader=new FileReader(filepath);
            while ((read_data=fileReader.read(chars))!=-1){
                System.out.print(new String(chars,0,read_data));
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            fileReader.close();
        }

    }

}

Writer:实现的子类

Filewriter类：

public class test_FileWriter {

    //Writer的实现子类
    @Test
    public void file_writer01() throws IOException {

        String filepath="d:\\file.txt";
        FileWriter fileWriter=null;

//        char [] str={'a','b','c'};

        try{

            fileWriter=new FileWriter(filepath,true); //以追加的方式写入；
//            fileWriter.write(str); 以字符数组的方式写入
            fileWriter.write("你好java"); //以字符串的方式写入
            System.out.println("写入文件成功");

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            fileWriter.close();
        }
    }
    
}

节点流和处理流：

节点流：

从一个特定的数据源（比如是FileReader和FilerWriter）进行读写文件，比如说文件。直接跟数据源相连。

处理流：(BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream）继承了Reader和Writer类

对某一个节点流进行包装,可以封装任意一个节点流,使处理读写更加方便。

字符处理流：

BufferReader:（用来处理字符）

public class test_BufferReader {
    public static void main(String[] args) throws Exception{
        String filepath="d:\\file.txt";
        String line=null; //按行读取


       BufferedReader bufferedReader = new BufferedReader(new FileReader(filepath));
        //readLine() 是按一行来读取的；
        // 当返回null 表示读取完毕；
       while ((line=bufferedReader.readLine()) !=null){
           System.out.println(line);
       }

       bufferedReader.close();
    }
}

BufferWriter:（用来处理字符）

public class test_BufferWriter {


    public static void main(String[] args) throws IOException {
        String filepath="d:\\file.txt";

        //new FileWriter(filepath,true) //以追加的方式：
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filepath,true));

        bufferedWriter.write("要努力变强啊！");
        bufferedWriter.newLine(); //进行换行操作；


        System.out.println("写入文件成功！");
        bufferedWriter.write("那是肯定的");

        //关闭流的操作：
        bufferedWriter.close();
    }
}

字节处理流（用来处理二进制数据的处理流）：

BufferedInuputStream:(用来处理字节，只要给它传入一个InputStream的节点流)

BufferedOutputStream:（用来处理字节，只要给它传入一个OutputStream节点流）

public class test_BinputStream_BoutputStream {

    public static void main(String[] args) throws IOException {
        String srcpath="d:\\test.jpg";
        String despath="d:\\test01.jpg";

        int read_len=0;//读取数据的长度：


        //字节处理流，就是将其他的节点字节处理进行包装，然后操作的
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream=null;
        byte[] buf=new byte[1024];//以字节数组的方式读取：

        try {
            //新建处理流的对象：
            bufferedInputStream=new BufferedInputStream(new FileInputStream(srcpath));
            bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(despath));
            //读取文件：
            while ((read_len=bufferedInputStream.read(buf))!=-1){
                //写入文件
                bufferedOutputStream.write(buf,0,read_len);

            }
            System.out.println("读取和写入二进制图片成功！");

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            bufferedInputStream.close();
            bufferedOutputStream.close();
        }


    }
}

对象处理流：ObjectInputStream（提供反序列化，读文件）、ObjectOutputStream（提供序列化,写文件）

需求：需要将保存的文件的数据，需要进行序列化和反序列化

序列化：保存数据的值的类型

反序列化：恢复数据的数据类型和值

序列化和反序列的注意事项：

ObjectInputStream

ObjectOutputStream:

 

public class test_ObjectOutputStream {


    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filepath="d:\\data.txt";


        //进行序列化：
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filepath));

        oos.writeInt(10);
        oos.writeBoolean(true);
        oos.writeUTF("你好");
        oos.writeObject(new Dog("小黄",10));


        System.out.println("序列化成功！");

        oos.close();
        //进行反序列化：进行读取数据：

        //读取数据和序列化的类型要是一样的，否则会报异常；
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filepath));

        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readUTF());
        System.out.println(ois.readObject());

        System.out.println("反序列化成功");
        //关闭流文件
        ois.close();

    }

}


//Dog实现序列：
class Dog implements Serializable {

    private String name;
    private int age ;

    Dog(){

    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

标准的输入和输出流：

转换流：处理文件编码方式错乱的情况。

InputStreamReader(将字节流转为字符流) 和OutputStreamWriter

InputStreamReader：将字节流转为字符流

 OutputStreamWriter：将字节流转为字符流

 

  //使用转换流的方式：
    @Test
    public void test_InputStreanReader() throws IOException {
        String filepath="d:\\网盘文件\\a.txt";
        //转换流： 指定转换的字符编码方式= gbk的方式；
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filepath),"gbk");

        //将转换流使用处理流来处理 ;因为InputStreamReader也是Reader的子类，可以使用处理流来包装；
        BufferedReader bufferedReader = new BufferedReader(isr);

        String s = bufferedReader.readLine();
        System.out.println("转换流输出的结果是："+s);
        bufferedReader.close();
    }

    @Test
    public void test_OutputStreamWriter() throws IOException {
        String filepath="d:\\网盘文件\\a.txt";
        
        //将字节流FileOutputStream 转为字符流
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filepath,true),"gbk");
        //将转换流用字符处理流进行包装：
        BufferedWriter bufferedWriter = new BufferedWriter(osw);
        bufferedWriter.write("ok，好的");
        bufferedWriter.close();

        System.out.println("转换流写入文件完毕！");
    }

打印流（只有输出流，没有输入流）：PrintReader、PrinterWriter

PrintStream：（字节流）

public class test_printStream {

    public static void main(String[] args) throws IOException {
        //字节打印流
        PrintStream out = System.out;
        out.write("你好".getBytes());
        out.close();
    }
    
}

PrintWriter：（字符流）

    @Test
    public void test_PrintWriter(){

        System.out.println("使用PrintWriter");
        //打印到显示台：
        PrintWriter printWriter = new PrintWriter(System.out);
        printWriter.write("你好北京");
        printWriter.close();
    }

java中的Properties文件：

 

 常用属性方法：load、store、getProperties()、setProperties()

public class test_properties {


    @Test
    public void test_loadproperties() throws IOException {
        Properties properties = new Properties();

        properties.load(new FileReader("src\\mysql.properties"));
        //将获取到的属性输出到控制台：
//        properties.list(System.out);
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");

        System.out.println("username:"+username);
        System.out.println("password:"+password);
    }

    @Test
    public void test_setproperties() throws IOException {

        Properties properties = new Properties();

        properties.setProperty("charset","utf-8");
        properties.setProperty("小黄","100");
        properties.setProperty("风越大","鱼越贵");
        //存储到文件中
        properties.store(new FileOutputStream("src\\mysql.properties",true),null);

    }
}

灰太狼家的小鸭子
关注
专栏目录
Java的IO流
qq_42865964的博客
04-25 210
Java的IO流
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而字符流用于处理文本数据。 Java中的...
头歌实践教学平台——Java程序设计之高级特性IO流
2201_75537843的博客
05-07 717
头歌实践教学平台——Java程序设计之高级特性IO流
Java中BufferedWriter的write()与append()方法详解
最新发布
ning的博客
08-17 931
是Java I/O库中用于字符输出流的缓冲类。它继承自Writer类，并提供了字符数组、字符串以及可追加序列的写入方法。缓冲机制使得在处理大量数据写入时更加高效。
Educoder/头歌JAVA——JAVA高级特性：IO流
舟舟的博客
12-20 7341
在Java开发中我们经常会涉及到文件方面的操作，不论是网站的上传文件，还是服务器提供给客户端下载文件，这些都需要我们来处理，那Java中是使用什么来进行文件处理的呢？ Java中涉及到文件输入输出处理的类基本都在IO包中。
Java高级特性 - IO流(头歌)
m0_74304371的博客
12-06 2103
Java高级特性 - IO流(头歌) 相关代码
java操作IO流
恋上、小幸福的博客
03-08 483
Java的IO流是一种用于在程序中读取和写入数据的机制。它提供了一种将数据从一个地方传输到另一个地方的方法，这些数据可以来自文件、网络连接、键盘输入等等。IO流是Java的核心组件之一，因此Java程序员需要深入了解其使用方法。Java的IO流还有许多其他类和方法可以使用，例如BufferedReader和BufferedWriter类，可以用于缓存读写操作，提高IO操作的性能。
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
Java中io流解析及代码实例
08-28
Java中IO流解析及代码实例 Java中IO流是一种基本的输入/输出机制，用于读取和写入数据。IO流可以分为两种：字节流和字符流。字节流按照字节来读取和写入数据，而字符流按照字符来存取数据。 字节流 字节流是Java...
Java 中IO流字符流详解及实例
08-30
Java 中IO流字符流详解及实例 Java 中的 IO 流字符流是指 Java 语言中对基本输入/输出流的扩展，用于处理字符流。字符流是指将文本文件或字符串按照某种编码方案（如 UTF-8、UTF-16BE、GBK 等）序列化为字节序列的...
JAVA中IO流
weixin_62843104的博客
03-27 277
1.Io流也成为输入输出流 就是用来读写数据的。 I 表示input是数据从硬盘文件中读入到内存的过程，称为输入，负责读； O 表示output是内存程序的数据从内存写出到硬盘文件的过程，称为输出，负责写； 入和出 是相对内存而言 IO流的分类： 按照数据的流向：IO流的分类为输入流和输出流 按照流中的数据的最小单位分为：字节流（可以操作所有文件：包括音频 视频图片等）和字符流（只能操作纯文本文件包括.txt文件.java文件） IO流可以分为大类： 字节输入流：以内存为基准，来自磁盘文
头歌：Java高级特性 - IO流 （答案+详细注释）第1关：什么是IO流+第2关：字节流-输入输出+第3关：字符流 - 输入输出+第4关：复制文件
Molly 的博客
04-02 7096
头歌：Java高级特性 - IO流 （答案+详细注释）第1关：什么是IO流+第2关：字节流-输入输出+第3关：字符流 - 输入输出+第4关：复制文件
头歌 Java IO 答案 增加章节java学习-Java输入输出之字节缓冲IO流之复制文件
个人博客地址https://sun98k.github.io/
12-22 7948
头歌Java答案 学习-Java输入输出之字节缓冲IO流之复制文件
Java IO 流操作详解
BXA
05-27 1930
Java IO流提供了一种可以对数据进行输入输出的机制。可以把它比作是一条河流从源头流向目标地，由源文件输入到程序再由程序输出到目标文件。IO即Input/Output顾名思义就是数据的输入输出，在Java中指的是java.io包中的类库，提供了一系列操作数据输入与输出的类和接口。Java NIO（New IO）是JDK1.4引入的新的IO API，能够以更高效的方式进行文件、网络读写等各种I/O操作。
java io流操作_java IO流操作
weixin_39688870的博客
03-06 116
什么是IO流？Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。输入输出(IO)：输入输出是指计算机同任何外部设备之间的数据传递。在IO流里，输入输出分为4步：格式化/解析，缓冲，编码转换和传递。格式化/解析：在内部数据表示(以字节为单位)与外部数据表示(以字符为单位)之间进行双向转换。例如一个2字节的整数10002，就需要5个...
Educoder -Java高级特性 - IO流（ 第2关：字节流-输入输出）
weixin_51160138的博客
02-19 4266
package step2; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class Task { public void
头歌 Java高级特性 - IO流
weixin_74284876的博客
12-08 1997
字节是指一小组相邻的二进制数码。通常是8位作为一个字节。它是构成信息的一个小单位，并作为一个整体来参加操作，比字小，是构成字的单位。字节(Byte) 是一种计量单位，表示数据量的多少，它是计算机信息技术用于计量存储容量的一种计量单位.我们想象一下，给你一串二进制码，要你来分辨它是什么含义，是代表数字还是字母还是汉字，你能有效的分辨吗？显然不能，一般来说，我们是比较难以理解一串二进制码代表的含义的，而且一串二进制码是代表什么含义也无法很直观的表示出来。我们比较好识别的是文字，字母和符号。所以就有了。
Java_IO流(精讲)包含练习题及答案
红目香薰
11-28 2352
1、Java Io流的概念 流：代表任何有能力产出数据的数据源对象或者是有能力接受数据的接收端对象。 流的本质:数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 作用：为数据源和目的地建立一个输送通道 Java IO所采用的模型 Java的IO模型设计非常优秀，它使用Decorator[ˈdekəreɪtə(r)](装饰者)模式，按功能划分Stream[striːm]英[striːm]美，您可以动态装配这些Stream，以便获得您需要的功能。 例如，您需要一个具有缓冲的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值