Java学习（16）—— I/O流（2）

最新推荐文章于 2022-08-31 11:26:48 发布
最新推荐文章于 2022-08-31 11:26:48 发布
阅读量330 收藏 1
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Archer__13/article/details/121316987
版权

一. 标准的输入流和输出流

      System.in：标准的输入流，从键盘输入

      System.out：标准的输出流，从显示器输出

      System类中的setIn(InputStream is)和setOut(PrintStream ps)方式重新指定输入和输出的流

import java.io.BufferedReader;
import java.io.InputStreamReader;


public class Test{
    public static void main(String[] args){
        InputStreamReader isr = new InputStreamReader(System.in);   //输入的是字节流，需要使用转换流将字节流转换为字符流

        BufferedReader br = new BufferedReader(isr);

        while(true){
            String data = br.readLine();
            if(data.equalsIgnoreCase("exit")){
                break;
            }
            System.out.println(data);
        }
        br.close();
    }
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Test{
    public static void main(String[] args){
        BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);

            br = new BufferedReader(isr);

            while(true){
                String data = br.readLine();
                if(data.equalsIgnoreCase("exit")){
                    break;
                }
                System.out.println(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

二. 打印流

import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;


public class Test{
    public static void main(String[] args){
        File file = new File("test.txt");

        FileOutputStream fos = new FileOutputStream(file);

        PrintStream ps = new PrintStream(fos);
        if(ps != null){
            System.setOut(ps);         //之后输出的数据会写入test.txt文件中，不会在控制台输出
        }

        for(int i = 0; i <=100; i++){
            System.out.print(i);
        }

        ps.close();
    }
}
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;


public class Test{
    public static void main(String[] args){
        PrintStream ps = null;
        try {
            File file = new File("test.txt");

            FileOutputStream fos = new FileOutputStream(file);

            ps = new PrintStream(fos);
            if(ps != null){
                System.setOut(ps);         //之后输出的数据会写入test.txt文件中，不会在控制台输出
            }

            for(int i = 0; i <= 100; i++){
                System.out.print(i);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            ps.close();
        }
    }
}

三. 数据流

      用于读取或写入基本数据类型的变量和字符串

import java.io.*;

public class Test{
    public static void main(String[] args){
        //写入
        File file = new File("test.txt");

        FileOutputStream fos = new FileOutputStream(file);

        DataOutputStream dos = new DataOutputStream(fos);

        dos.writeUTF("Tom");        //将数据写入test.txt文件中
        dos.flush();    //刷新
        dos.writeInt(23);
        dos.flush();
        dos.writeChar('男');
        dos.flush();

        dos.close();


        //读取
        FileInputStream fis = new FileInputStream(file);

        DataInputStream dis = new DataInputStream(fis);

        String name = dis.readUTF();     //读出的顺序需要与写入的顺序一致
        int age = dis.readInt();
        char sex = dis.readChar();

        System.out.println("name:" + name + ",age:" + age + ",sex:" + sex);

        dis.close();
    }
}
import java.io.*;

public class Test{
    public static void main(String[] args){
        //写入
        File file = null;
        DataOutputStream dos = null;
        try {
            file = new File("test.txt");

            FileOutputStream fos = new FileOutputStream(file);

            dos = new DataOutputStream(fos);

            dos.writeUTF("Tom");        //将数据写入test.txt文件中
            dos.flush();    //刷新
            dos.writeInt(23);
            dos.flush();
            dos.writeChar('男');
            dos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(dos != null){
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }




        //读取
        DataInputStream dis = null;
        try {
            FileInputStream fis = new FileInputStream(file);

            dis = new DataInputStream(fis);

            String name = dis.readUTF();     //读出的顺序需要与写入的顺序一致
            int age = dis.readInt();
            char sex = dis.readChar();

            System.out.println("name:" + name + ",age:" + age + ",sex:" + sex);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(dis != null){
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

四. 对象流

      用于读取和写入基本数据类型数据或对象

      序列化：将内存中的java对象保存到磁盘中，使用ObjectOutputStream

      反序列化：将磁盘中的对象还原为内存中的一个java对象，使用ObjectInputStream

import java.io.*;

public class Test{
    public static void main(String[] args){
        //写入
        File file = new File("test.txt");
        FileOutputStream fos = new FileOutputStream(file);

        ObjectOutputStream oos = new ObjectOutputStream(fos);

        oos.writeObject(new String("I love China"));
        oos.flush();

        oos.close();


        //读取
        FileInputStream fis = new FileInputStream(file);

        ObjectInputStream ois = new ObjectInputStream(fis);

        Object obj = ois.readObject();
        System.out.println(obj);

        ois.close();
    }
}
import java.io.*;

public class Test{
    public static void main(String[] args){
        //写入
        File file = null;
        ObjectOutputStream oos = null;
        try {
            file = new File("test.txt");
            FileOutputStream fos = new FileOutputStream(file);

            oos = new ObjectOutputStream(fos);

            oos.writeObject(new String("I love China"));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos != null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


        //读取
        ObjectInputStream ois = null;
        try {
            FileInputStream fis = new FileInputStream(file);

            ois = new ObjectInputStream(fis);

            Object obj = ois.readObject();
            System.out.println(obj);              //I love China
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

        自定义类实现序列化和反序列化        

        自定义类可以序列化的要求：①该类需要实现Serializable接口；②该类需要提供一个全局常量serialVersionUID，该值为任意数；③该类内部的属性必须都是可序列化的（默认情况下，基本数据类型都是可序列化的），static和transient修饰的变量是不可序列化的。

import java.io.*;

public class Test{
    public static void main(String[] args){
        //写入
        File file = null;
        ObjectOutputStream oos = null;
        try {
            file = new File("test.txt");
            FileOutputStream fos = new FileOutputStream(file);

            oos = new ObjectOutputStream(fos);

            oos.writeObject(new Person("Tom",22));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos != null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


        //读取
        ObjectInputStream ois = null;
        try {
            FileInputStream fis = new FileInputStream(file);

            ois = new ObjectInputStream(fis);

            Object obj = ois.readObject();
            System.out.println(obj);                //Person{name='Tom', age=22}
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

class Person implements Serializable{
    public static final long serialVersionUID = 45612387952L;

    String name;
    int age;

    public Person(){

    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

五. 任意访问文件流（RandomAccessFile）

      RandomAccessFile直接继承于Object类，实现了DataInput和DataOutput接口

      RandomAccessFile既可以作为一个输入流，也可以作为一个输出流

      创建RandomAccessFile类实例时，需要指定访问模式：① r：只读；② rw：读写

import java.io.File;
import java.io.RandomAccessFile;

public class Test{
    public static void main(String[] args){
        File file1 = new File("test1.jpg");
        File file2 = new File("test2.jpg");

        RandomAccessFile raf1 = new RandomAccessFile(file1,"r");
        RandomAccessFile raf2 = new RandomAccessFile(file2,"rw");

        byte[] buffer = new byte[1024];
        int len = raf1.read(buffer);
        while(len != -1){
            raf2.write(buffer,0,len);
            len = raf1.read(buffer);
        }

        raf1.close();
        raf2.close();
    }
}
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Test{
    public static void main(String[] args){
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            File file1 = new File("test1.jpg");
            File file2 = new File("test2.jpg");

            raf1 = new RandomAccessFile(file1,"r");
            raf2 = new RandomAccessFile(file2,"rw");

            byte[] buffer = new byte[1024];
            int len = raf1.read(buffer);
            while(len != -1){
                raf2.write(buffer,0,len);
                len = raf1.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(raf1 != null){
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(raf2 != null){
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

         如果RandomAccessFile作为输出流时，如果写出到的文件不存在，则会自动创建该文件，如果写出到的文件存在，则会对文件原有内容进行覆盖（能覆盖多少是多少）

import java.io.File;
import java.io.RandomAccessFile;

public class Test{
    public static void main(String[] args){
        File file = new File("test.txt");    //文件原内容为HelloWorld

        RandomAccessFile raf = new RandomAccessFile(file,"rw");

        raf.write("ABCDE".getBytes());      //现在文件内容为：ABCDEWorld

        raf.close();
    }
}
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Test{
    public static void main(String[] args){
        RandomAccessFile raf = null;
        try {
            File file = new File("test.txt");    //文件原内容为HelloWorld

            raf = new RandomAccessFile(file,"rw");

            raf.write("ABCDE".getBytes());      //现在文件内容为：ABCDEWorld
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(raf != null){
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

          raf.seek(int i)：将指针调到 i 的位置

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Test{
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = null;
        try {
            File file = new File("test.txt");    //文件原内容为HelloWorld

            raf = new RandomAccessFile(file,"rw");

            raf.seek(2);    //将指针调到2的位置
            raf.write("ABCDE".getBytes());      //现在文件内容为：HeABCDErld
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(raf != null){
                raf.close();
            }
        }
    }
}

        使用RandomAccessFile实现数据的插入：

import java.io.File;
import java.io.RandomAccessFile;

public class Test{
    public static void main(String[] args){
        File file = new File("test.txt");      //文件原内容为HelloWorld

        RandomAccessFile raf = new RandomAccessFile(file,"rw");

        raf.seek(5);    //将指针调到4的位置

        int flieLength = (int)file.length();
        StringBuilder sb = new StringBuilder(flieLength);

        byte[] buffer = new byte[20];
        int len = raf.read(buffer);
        while(len != -1){
            sb.append(new String(buffer,0,len));     //将指针5后面的数据保存到StringBuilder中
            len = raf.read(buffer);
        }

        raf.seek(5);       //调回指针，将要添加的数据数据写入文件中
        raf.write("New".getBytes());

        raf.write(sb.toString().getBytes());   //将StringBuilder中的的数据数据写入文件中
        
        raf.close();

        //现在文件内容为：HelloNewWorld
    }
}
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Test{
    public static void main(String[] args){
        RandomAccessFile raf = null;
        try {
            File file = new File("test.txt");      //文件原内容为HelloWorld

            raf = new RandomAccessFile(file,"rw");

            raf.seek(5);    //将指针调到4的位置

            int flieLength = (int)file.length();
            StringBuilder sb = new StringBuilder(flieLength);

            byte[] buffer = new byte[20];
            int len = raf.read(buffer);
            while(len != -1){
                sb.append(new String(buffer,0,len));     //将指针5后面的数据保存到StringBuilder中
                len = raf.read(buffer);
            }

            raf.seek(5);       //调回指针，将要添加的数据数据写入文件中
            raf.write("New".getBytes());

            raf.write(sb.toString().getBytes());   //将StringBuilder中的的数据数据写入文件中
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(raf != null){
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        //现在文件内容为：HelloNewWorld
    }
}

 

注意：可以使用第三方jar包进行数据读写（更简单） 

Yacht13
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java I/O
02-16
Java I/O 是Java编程语言中一个至关重要的领域，它涵盖了数据的输入与输出操作，包括文件操作、流处理、字符编码、网络通信等。在Java I/O系统中，各种类和接口构成了一个庞大的框架，使得开发者能够高效地处理数据...
JAVA学习笔记2020/4/27——Stream流、方法引用
01-20
说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 引言 传统集合的...
Java.io.BufferedReader.Close()方法实例
wuxiaopengnihao1的博客
01-18 277
java.io.BufferedInputStream.Close()方法关闭该流并释放与之关联的所有系统资源。 流关闭后， read(), ready(), mark(), reset(), 或 skip() 调用将抛出IOException异常。 更多教程请访问http://www.manongzj.com 声明 以下是java.io.BufferedReader.close()方法的声明 public void close() 参数 NA 返回值 此方法不返回任何值。 .
BufferedReader用法--博客园
qq_42058441的博客
12-19 1574
BufferedReader由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine，读取一个文本行，从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。   BufferedReader和BufferedWriter为默认带有缓冲的字符输出输入流，因为有缓冲区所以效率比没有缓冲区的高。   InputStreamReader类是字节流通向字符流...
JAVA--数据字节流,对象流与序列化
bujiujie8的博客
09-03 2194
数据字节流 DataOutputStream与DataInputStream 父类与缓冲流一样都是过滤字节流:FilterOutputStream与FilterInputStream,这两个类可以写基本数据类型. DataOutputStream 这里只写了代码,方法的介绍可以看注释: import java.io.DataOutputStream; import java.io.Fi...
Java输入/输出之RandomAccessFile的功能和用法
最新发布
weixin_42051619的博客
08-31 848
Java I/O
Java课程设计报告书-学生版-1_I/O流与文件课程设计_
09-30
本课程设计报告书——“Java课程设计报告书-学生版-1_I/O流与文件课程设计_”旨在帮助学生深入理解并掌握如何在Java中进行文件操作，通过实际的实验案例来学习文件对象和流类的应用。 一、Java I/O流概述 Java的I/O...
Java I/O 操作及优化建议
12-22
　Java内存模型——或者更确切的说垃圾回收器——已经解决了许多内存问题。然而同时，也带来了新的问题。特别是在有着大量并行用户的J2EE运行环境下，内存越来越成为一种至关重要的资源。乍看之下，这似乎有些奇怪...
java学习教程——简洁易懂，一步步跟随即可上手学习
02-22
5. **输入/输出(I/O)** - **文件操作**：File类的使用，读写文件。 - **流**：字节流和字符流的理解，如InputStream、OutputStream、Reader、Writer等。 - **缓冲流**：BufferedReader、BufferedWriter等提高读写...
java 程序理解 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
热门推荐
qq_43754223的博客
12-16 1万+
首先System.in是向屏幕输入一些数据，new InputStreamReader()是输入流，可以用来读取数据，new InputStreamReader(System.in)以System.in作为参数，创建InputStreamReader的对象，就是读取屏幕上输入的数据，但这样读取不具有缓冲功能，所以用了BufferedReader这个类，BufferedReader br=new B...
BufferedReader/BufferedWriter,带缓冲区的字符输入/输出流
qq_37203178的博客
07-06 572
注意： 这个两个流都是带有缓冲区的，所以就不需要准备自定义的char数组，或者byte数组来缓存数据。 BufferedReader的使用： //创建一个字符输入流 FileReader reader = new FileReader("src/com/io/temp"); //创建一个带有缓冲区的字符输入流，并把前面的字符输入流输入 BufferedReader br = new BufferedReader(reader);
BufferedReader小练习
Peter_Hao1015的博客
04-19 250
java写一个程序，实现从文件中读出文件内容，并将其打印在屏幕当中，并标注上行号public class PrintFileWithLineNumber { public static void main(String[] args) throws IOException { printFile("D:\\count.txt"); } private static void pri...
Java学习笔记——读写追加文件内容
Denglishang的博客
05-20 478
实际项目中，拿到文本文件如果需要在文件中替换或者添加内容，可以用java.io.RandomAccessFile实现。 原文件内容： 1、最简单的文件末尾添加 需要在网页中添加一个打印网页的按钮，上码 import java.io.RandomAccessFile; public class MyTest20200405 { public static void main(String[] args) throws Exception { try { String sFile
RandomAcessFile类用法
haqer0825的专栏
01-07 947
RandomAcessFile类 创建一个对象，构造函数有两个参数，第一个可以是文件名字符串也可以是File型的对象。 第二个有三种选择"rw","r","w" 即读模式，写模式，读写模式。 RandomAcessFile  raf = new RandomAcessFile(new File(args[0]),"rw"); raf.seek(raf.length());//此行的意义 是
Java——RAF
qq_50728916的博客
04-03 300
开头：RAF的简单介绍 package raf; import java.io.RandomAccessFile; /** * java.io.RandomAccessFile * RAF是专门用来读写文件数据的API.其基于指针对文件数据进行读写 * 操作，可以灵活的编译文件数据内容。 * 创建RAF时可以指定对该文件的权限，常用的有两种： * r:只读模式 * rw:读写模式 * 对当前目录中的raf.dat文件读写 * RAF支持两种常用构造方法： * RandomAccessF
java学习笔记（十五）
u014596135的博客
05-08 544
1.java.io.File基本的API File(String) long length() long lastModified() String getName() String getPath() boolean exists() boolean dir.isFile() boolean dir.isDirectory() boolean mkdir()//创建一个目录
JAVA常用API###raf
buxiangmafan的博客
03-19 558
RAF java.io.RandomAccessFile用于读写文件数据的API RAF有两种创建模式：r只读 rw读写 RandomAccessFile raf = new RandomAccessFile（“文件名”,“rw”）； getFilePointer（）获取RAF的指针位置 write（）写 writeInt（）写入int值 read（）读写 readInt（）读写 seek（）将...
Java基础：第19章——二进制I/O与数据处理
本资源是关于Java语言程序设计的基础篇，主要聚焦于第十九章——二进制I/O。在这一章中，作者详细探讨了Java中I/O操作的相关概念和技术，包括文本文件和二进制文件的区别、处理方式以及各自的优缺点。 首先，章节...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值