java IO流

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量81 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52605986/article/details/128307418
版权

文件操作

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStream_ {
    //写入文件时如果文件不存在，则会创建一个文件
    //注意：当new FileOutputStream(File,boolean) 第二个参数设为true为在原文件中append而不是覆盖
    //第一种写入方式：一次写一个字符
    @Test
    public void writeFile(){
        String filePath = "d:\\b.txt";
        File file = new File(filePath);
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write('W');

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    //第二种一次写入多个字节
    @Test
    public void writeFile2(){
        String filePath = "d:\\b.txt";
        File file = new File(filePath);
        FileOutputStream fileOutputStream = null;
        try {

            fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write("WST".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //第二种一次写入多个字节，指定范围
    @Test
    public void writeFile3(){
        String filePath = "d:\\b.txt";
        File file = new File(filePath);
        FileOutputStream fileOutputStream = null;
        try {

            fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write("WST hello".getBytes(),0,2);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

FileInputStream

package com.st.io;

import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileInputSteam_ {

    //第一种读取方式：一次读取一个字节
    @Test
    public void readFile(){
        String filePath="d:\\a.txt";
        File file = new File(filePath);
        FileInputStream fileInputStream = null;
        //用于接收读取出来的数据
        int fileData=0;
        try {
            fileInputStream=new FileInputStream(file);
            while ( (fileData=fileInputStream.read()) !=-1 ){
                System.out.print((char) fileData);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //第二种读取方式一次读取多个字节
    @Test
    public void readFile2(){
        String filePath = "D:\\a.txt";
        File file = new File(filePath);
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(file);
            byte[] aByte = new byte[8];
            int readLen = 0;
            while ((readLen = fileInputStream.read(aByte) )!= -1){
                System.out.print(new String(aByte,0,readLen,"UTF-8"));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

FileOutputStream

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStream_ {
    //写入文件时如果文件不存在，则会创建一个文件
    //注意：当new FileOutputStream(File,boolean) 第二个参数设为true为在原文件中append而不是覆盖
    //第一种写入方式：一次写一个字符
    @Test
    public void writeFile(){
        String filePath = "d:\\b.txt";
        File file = new File(filePath);
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write('W');

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
    //第二种一次写入多个字节
    @Test
    public void writeFile2(){
        String filePath = "d:\\b.txt";
        File file = new File(filePath);
        FileOutputStream fileOutputStream = null;
        try {

            fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write("WST".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //第二种一次写入多个字节，指定范围
    @Test
    public void writeFile3(){
        String filePath = "d:\\b.txt";
        File file = new File(filePath);
        FileOutputStream fileOutputStream = null;
        try {

            fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write("WST hello".getBytes(),0,2);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

节点流和处理流的区别

节点流可以从一个特定的数据源读写数据。
处理流也叫包装流是在已存在的流（节点流或者处理流）之上，为程序提供更强大的读写功能。

字节处理流拷贝文件

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.*;

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

    }
    //字节处理流文件拷贝
    @Test
    public  void copyFile1()  throws Exception{
        String fileReadPath = "d:\\c.txt";
        String fileWritePath = "d:\\d.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        bufferedReader = new BufferedReader(new FileReader(fileReadPath));
        bufferedWriter = new BufferedWriter(new FileWriter(fileWritePath));
        String fileData = "";
        while ((fileData = bufferedReader.readLine()) != null){
            bufferedWriter.write(fileData);
            bufferedWriter.newLine();
        }
        bufferedReader.close();
        bufferedWriter.close();
   }
   //字节流拷贝文件
   @Test
    public void copyFile2(){
        String fileInputPath = "d:\\dog.png";
        String fileOutPath = "d:\\dpg2.png";
       BufferedInputStream bf = null;
       BufferedOutputStream bo =null;
       try {
           bf = new BufferedInputStream(new FileInputStream(fileInputPath));
           bo = new BufferedOutputStream(new FileOutputStream(fileOutPath));
           byte[] data = new byte[1024];
           int dataLen = 0;
           while((dataLen=bf.read(data)) != -1){
               bo.write(data, 0, dataLen);
           }
       } catch (IOException e) {
           e.printStackTrace();
       } finally {
           try {
               if(bf != null){
                    bf.close();
               }
               if(bo != null){
                    bo.close();
               }
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }
}

对象处理流（序列化）

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.*;

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

    }
    //字节处理流文件拷贝
    @Test
    public  void copyFile1()  throws Exception{
        String fileReadPath = "d:\\c.txt";
        String fileWritePath = "d:\\d.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        bufferedReader = new BufferedReader(new FileReader(fileReadPath));
        bufferedWriter = new BufferedWriter(new FileWriter(fileWritePath));
        String fileData = "";
        while ((fileData = bufferedReader.readLine()) != null){
            bufferedWriter.write(fileData);
            bufferedWriter.newLine();
        }
        bufferedReader.close();
        bufferedWriter.close();
   }
   //字节流拷贝文件
   @Test
    public void copyFile2(){
        String fileInputPath = "d:\\dog.png";
        String fileOutPath = "d:\\dpg2.png";
       BufferedInputStream bf = null;
       BufferedOutputStream bo =null;
       try {
           bf = new BufferedInputStream(new FileInputStream(fileInputPath));
           bo = new BufferedOutputStream(new FileOutputStream(fileOutPath));
           byte[] data = new byte[1024];
           int dataLen = 0;
           while((dataLen=bf.read(data)) != -1){
               bo.write(data, 0, dataLen);
           }
       } catch (IOException e) {
           e.printStackTrace();
       } finally {
           try {
               if(bf != null){
                    bf.close();
               }
               if(bo != null){
                    bo.close();
               }
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }
}

节点流和处理流注意事项

1)读写顺序要一致
2)要求实现序列化或反序列化对象,需要实现 Serializable
3)序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
4)序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员5)序列化对象时，要求里面属性的类型也需要实现序列化接口
6)序列化具备可继承性,也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

转换流

inputStreamReader

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.*;

//读入字符转换流
public class InputStream_ {
    String filePath = "d:\\e.txt";
    @Test
    public void test1() throws IOException{
        BufferedReader bf = new BufferedReader(new FileReader(filePath));
        String fileData = null;
        while ((fileData=bf.readLine()) != null){
            System.out.println(fileData);
        }
        bf.close();
    }
    @Test
    public void inputStreamReader_() throws IOException {
        //将字节流转换为字符流&&原文件是gbk编码，用默认编码解析会报错
        BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));
        String fileData = null;
        while ((fileData=bf.readLine()) != null){
            System.out.println(fileData);
        }
        bf.close();
    }

}

OutputStreamWriter

package com.st.io;

import org.junit.jupiter.api.Test;

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

//输出字符转换流 字节流->字符流
//编码设置
public class OutputStreamWriter_ {
    @Test
    public void test() throws IOException {
        String filePath = "d:\\e.txt";
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath,true), "gbk"));
        bw.write("勇敢去飞!");
        bw.newLine();
        bw.write("123456");
        bw.close();
    }
}

打印流

打印流只有输出流，没有输入流。

PrintStream

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.PrintStream;

//打印字节流
public class PrintStream_ {
    @Test
    public void printStream() throws IOException {
        PrintStream out = System.out;
        out.println("勇敢去飞");
        String filePath = "d:\\f.txt";
        System.setOut(new PrintStream(filePath));
        System.out.println("勇敢去飞3");

    }

}

PrintWriter

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

//打印字符流
public class PrintWriter_ {
    @Test
    public void test() throws IOException {
        PrintWriter pw = new PrintWriter(System.out);
        pw.write("勇敢去飞");
        String filePath = "d:\\g.txt";
        PrintWriter printWriter = new PrintWriter(new FileWriter(filePath));
        printWriter.write("123456");
        printWriter.close();
    }
}

注意：打印字符输出流一定要有关闭流操作，close方法中包含真正的写操作。

读写Properties文件

package com.st.io;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

//properties读写
public class Properties_ {
    //properties读入
    @Test
    public void readProperties() throws IOException {
        Properties p = new Properties();
        //加载properties文件
        p.load(new FileInputStream("C:\\Users\\songtao\\Desktop\\ideaWorkspace\\io\\src\\Properties_.properties"));
        //控制台打印properties文件
        p.list(System.out);
        //获取属性
        String user = p.getProperty("user");
        String age = p.getProperty("age");
        System.out.println("user:"+user);
        System.out.println("age:"+age);
    }
    @Test
    public void writeProperties() throws IOException{
        Properties p = new Properties();
        String filePath = "C:\\Users\\songtao\\Desktop\\ideaWorkspace\\io\\src\\Properties_.properties";
        p.setProperty("age", "12");
        p.setProperty("name", "张三");
        p.store(new FileWriter(filePath), null);
    }
}
确实不知道起什么昵称
关注
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javaIO流详解
weixin_46676497的博客
01-27 2551
java常用io流介绍
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java io流 详解
m0_68987535的博客
06-11 4780
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
Java IO流详解
ss810540895的博客
04-21 1万+
原文 Java IO流详解 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 IO又分为流IO（java.io）和块IO(java.nio) Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的
Java IO流的种类
程序员
02-20 3328
Java IO流的种类
JavaIO流：模型
栗筝i的博客
11-24 3808
IO 的字面意思是读/写数据，IO 模型是读/写数据的方式。常用到的读/写数据方式有：同步阻塞 IO、同步非阻塞 IO、IO 多路复用、信号驱动、异步 IO 本篇内容包括：Java IO 与 IO 模型、五种 IO 模型、三种 Java IO 模型。
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6275
笑霸能看懂的学习笔记
Java IO流
菜鸡的博客
09-25 1万+
1、File类的使用 java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关 File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 File对象可以作为参数传递给流的构造器 1.1、常用构造器 public File(String pathname) 以path
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
java IO流将一个文件拆分为多个子文件代码示例
08-28
Java IO流将一个文件拆分为多个子文件代码示例 Java IO流是一个文件流处理的基础组件，它提供了基本的文件读取和写入操作。将一个文件拆分为多个子文件是文件处理中一个常见的需求，例如上传大文件时，可以先分割成...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 890
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 287
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 490
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1001
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
Android应用设计与Java IO流
"Android应用程序设计I-Java IO流" 在Android应用程序设计中，理解并掌握Java的IO流是至关重要的，因为这关乎到如何在应用中有效地读取、写入和处理数据。Java IO流提供了在不同数据源之间传输数据的机制，包括设备...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值