Java IO流初步

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

Java IO流初步

文章目录

一、Java IO流简介

 I 为Input，O 为Output 。
 在Java程序中，对于数据的输入、输出操作以 流（stream）方式进行。从外部的存储媒介或其他程序中读入所需的数据时需要使用 输入流。而程序在处理数据后，可能需要将处理的结果写入到永久的存储媒介中或传送给其他应用程序，这时便需要使用 输出流。输入流的指向称为 源，输出流的指向称为它的 目的地，“源”和“目的地”经常为磁盘文件，也可以为键盘，内存或显示器窗口。

二、Java流类的分类

 Java.iO包中提供了大量的流类，用以获取不同种类的数据，可以从不同的角度对其进行分类：

  • 按数据流的方向不同可以分为输入流和输出流。
  • 按处理数据单位不同可以分为字节流和字符流。

字节流与字符流的区别：

  1. 读取单位不同，字节流的读取单位为1 byte = 8 bit，而字符流的读取单位为1 char = 2 byte = 16 bit。
  2. 适用场景不同，字节流可以处理任意类型的数据，如图片、视频等；而字符流只能读取纯文本文件。
  3. 字节流默认不使用缓冲，而字符流会使用缓冲。
  • 按照功能不同可以分为节点流和处理流。

节点流与处理流的区别：

  1. 节点流直接从一个特定的数据源（节点）读写数据。
  2. 处理流是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

 所有的输入流都是抽象类InputStream（字节输入流）或抽象类Reader（字符输入流）的子类，所有输出流都是抽象类OutputStream（字节输出流）或抽象类Writer（字符输出流）的子类。

常用方法：

  • InputStream类

int read() throws IOException /* 读取一个字节并以整数的形式返回
（0 ~ 255），若已到输入流的末尾则返回-1 */

int read(byte[] buffer) throws IOException /*读取一系列字节并存储到一
个数组buffer，返回实际读取的字节数，如果读取前已到输入流的末尾返回-1 */

int read(byte[] buffer, int offset, int len) throws IOException 
/* 读取len个字节，并从offset位置开始，存储到一个字节数组buffer，
返回实际读取的字节数，如果读取前已到输入流的末尾返回-1 */

void close() throws IOException // 关闭流释放内存资源

long skip(long n) throws IOException /* 跳过n个字节不读，返回实际跳过
的字节数 */

  • OutputStream类

void write(int n) throws IOException /* 向输出流中写入一个字节数据，
该字节数据为参数n的低8位 */

void wirte(byte[] n) throws IOException /* 将一个字节类型的数组中的
数据写入输出流 */

void write(byte[] n, int offset, int len) throws IOException /* 将
一个字节类型的数组中从offset位置开始的len个字节写入到输出流中 */

void close() throws IOException // 关闭流释放资源

void flush() throws IOException //将输出流中缓冲的数据全部写出到目的地

  • Reader类

int read() throws IOException /* 读取一个字符并以整数的形式返回
（0 ~ 255），若已到输入流的末尾则返回-1 */

int read(char[] cbuf) throws IOException /*读取一系列字符并存储到一个
数组buffer，返回实际读取的字符数，如果读取前已到输入流的末尾返回-1 */

int read(char[] cbuf, int offset, int len) throws IOException /*
读取len个字符，并从offset位置开始，存储到一个数组buffer，返回实际读取的
字符数，如果读取前已到输入流的末尾返回-1 */

void close() throws IOException // 关闭流释放内存资源

void skip(long n) throws IOException /* 跳过n个字符不读，返回实际跳过
的字符数 */

  • Writer类

void write(int n) throws IOException /* 向输出流中写入一个字符数据，
该字符数据为参数n的低16位 */

void write(char[] cbuf) throws IOException /*将一个字符类型的数组写入
中的数据写入输出流 */

void write(char[] cbuf, int offset, int len) throws IOException
/* 将一个字符类型的数组中从offset位置开始的len个字符写入到输出流中 */

void write(String str) throws IOException /* 将一个字符串中的字符写入
到输出流中 */

void write(String str， int offset, int len) throws IOException
/* 将一个字符串中从offset位置开始的len个字符写入到输出流中 */

void close() throws IOException // 关闭流释放内存资源

void flush() throws IOException //将输出流中缓冲的数据全部写出到目的地

三、Java常用节点流和处理流

节点流：

1、文件流：

 了解文件流之前需要先了解文件（File）类

File类：

File类的对象主要用于获取文件本身的一些信息，不涉及对文件的读写操作。
创建一个File对象的构造方法有3个：

File(String filename) // filename 为文件名字

File(String directoryPath, String filename) // directory 为文件的路径

File(File dir, String filename) // dir 为一个目录

File类中的常用方法：

public String getName() // 获取文件的名字

public boolean exists() // 判断文件是否存在

public long length() // 获取文件的长度（单位为字节）

public String getAbsolutePath() // 获取文件的绝对路径

public String getParent() // 获取文件的父目录

public boolean  file.mkdir() /* 创建一个目录，如果创建成功，返回true, 
创建失败，返回false。如果这个文件夹已经存在，则返回false */

public boolean  file.mkdirs() /* 创建多级目录，成功返回true，失败则
返回 false */

public boolean file.createNewFile() /* 创建一个新文件，创建成功，
返回true；创建失败，返回false。如果这个文件已经存在，则返回false */

public String[] list() // 以字符串形式返回目录下的全部文件

public File [] listFiles() // 以File对象的形式返回目录下的全部文件

简单写一个小程序测试一下：

import java.io.File;

public class test {
    public static void main(String[] args) {
        File f_1 = new File("D:\\java", "HW.txt");
        System.out.println("文件是否存在：" + f_1.exists());
        System.out.println("文件的名字为：" + f_1.getName());
        System.out.println("文件的长度为：" + f_1.length());
        System.out.println("文件的绝对路径为: " + f_1.getAbsolutePath());
        File f_2 = new File("D:\\java");
        String list[] = f_2.list();
        System.out.println("该目录下的文件有：");
        for (String string : list){
            System.out.println(string);
        }
    }
}
/*

文件是否存在：true
文件的名字为：HW.txt
文件的长度为：14
文件的绝对路径为： D:\java\HW.txt
该目录下的文件有：
.metadata
apache-tomcat-8.5.77
HW.txt
IntelliJ IDEA 2021.3.3
Navicat Premium 15
text

*/
FileInputStream类(文件字节输入流)
1、构造方法
FileInputStream(String name); // 使用给定的文件名创建

FileInputStream(File file); // 使用File对象创建
2、代码演示

读取一个写有“Hello World”的txt文件：

import java.io.*;

public class test {
    public static void main(String[] args) {
        int n = -1;
        FileInputStream in = null;
        try {
            in = new FileInputStream("D:\\java\\HW.txt");
        } catch (FileNotFoundException e) {
            System.out.println("找不到指定文件");
            System.exit(-1);
        }
        try {
            while ((n = in.read()) != -1) {
                System.out.print((char) n);
            }
            in.close();
        } catch (IOException e1) {
            System.out.println("文件读取错误");
            System.exit(-1);
        }
    }
}
/*
输出结果：
Hello，World
*/
FileOutputStream类(文件字节输出流)
1、构造方法
FileOutputStream(String name); // 使用给定的文件名创建

FileOutputStream(File file); // 使用File对象创建
2、代码演示
import java.io.*;

public class test {
    public static void main(String[] args) {
        int n = -1;
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream("D:\\java\\HW.txt");
            out = new FileOutputStream("D:\\java\\HW2.txt"); /* 若没
有该文件，则系统会自动创建一个。*/
            while((n = in.read())!= -1){
                out.write(n);
            }
            in.close();
            out.close();
        }
        catch (FileNotFoundException e1) {
            System.out.println("未找到指定文件");
            System.exit(-1);
        }catch (IOException e2){
            System.out.println("文件复制错误");
            System.exit(-1);
        }
        System.out.println("文件复制成功，内容为：");
// 读取 HW2.txt 文件
        FileInputStream _in = null;
        int m = -1;
        try {
            _in = new FileInputStream("D:\\java\\HW2.txt");
        } catch (FileNotFoundException e) {
            System.out.println("找不到指定文件");
            System.exit(-1);
        }
        try {
            while ((m = _in.read()) != -1) {
                System.out.print((char) m);
            }
            _in.close();
        } catch (IOException e3) {
            System.out.println("文件读取错误");
            System.exit(-1);
        }
    }
}
/*
输出结果为：
文件复制成功，内容为：
Hellow,World
*/
FileReader类与FileWriter类(文件字符输入、输出流)
1、构造方法
FileReader(String filename);

FileReader(File filename);

FileWriter(String filename);

FileWriter(File filename)

FileWriter(String filename, boolean append)

FileWriter(File filename, boolean append)
2、代码演示

将写有“你好，World”的HW.txt文件复制给HW2.txt文件

import java.io.*;

public class test {
    public static void main(String[] args) {
        int n = -1;
        File reader = new File("D:\\java\\HW.txt");
        File write = new File("D:\\java\\HW2.txt");
        char s[] = new char[20];
        try {
            Writer out = new FileWriter(write, true);
            Reader in = new FileReader(reader);
            while ((n = in.read(s)) != -1) {
                out.write(s, 0, n);
            }
            out.flush();
            out.close();
        } catch (IOException e) {
            System.out.println("文件读取错误");
            System.exit(-1);
        }
        System.out.println("文件复制成功");
    }
}
/*
输出结果为：
文件复制成功
*/

处理流：

1、缓冲流：

BufferedInputStream类与BufferedOutputStream类：

 缓冲输入、输出流 相较字符输入流和字符输出流有更强的读写能力，如BufferedReader流就可以使用方法readLine（）按行读取文件。

构造方法
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size) 
// size为自定义缓存区的大小

BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out, int size)
代码示例

HW.txt中写有英文字母表A-Z。

import java.io.*;

public class test {
    public static void main(String[] args) {
        try {
            int n = 0;
            int i = 0;
//创建一个FileInputStream流
            FileInputStream f = new FileInputStream("D:\\java\\HW.txt");
//再创建一个BufferedInputStrea流，并将它与FileInputStream流连接在一起
            BufferedInputStream buf = new BufferedInputStream(f);
            for (i = 0; i < 5 && (n = buf.read())!= -1;i++){
                System.out.println((char) n);
            }
            buf.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}
/*
输出结果为：
A
B
C
D
E
*/
BufferedReader类与BufferedWriter类：
构造方法
BufferedReader(Reader in)
BufferedReader(Reader in, int size)

BufferedWriter(Writer out)
BufferedWriter(Writer out, int size)
代码示例

HW.txt中的字符为：
ABCDEFGHIJKLMN
OPQRST
UVWX
YZ
HW2.txt为空

import java.io.*;

public class test {
    public static void main(String[] args) {
        try {
            FileReader r = new FileReader("D:\\java\\HW.txt");
            FileWriter w = new FileWriter("D:\\java\\HW2.txt");
            BufferedReader br = new BufferedReader(r);
            BufferedWriter bw = new BufferedWriter(w);
            String s = br.readLine();
            bw.write(s);
            bw.flush();
            while ((s = br.readLine()) != null) {
                System.out.println(s);
            }
            bw.close();
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
/*输出结果为：
OPQRST
UVWX
YZ
*/
/*
HW2.txt中的字符为：
ABCDEFGHIJKLMN
*/

2、数据流：

 数据输入流和数据输出流允许程序按着机器无关的风格读取Java原始数据，即读取一个数值时，不必再关心这个数值应当是多少个字节。

DataInputStream类与DataOutputStream类：
构造方法
DataInputStream(InputStream in)
// 创造的数据输入流指向一个由参数in指定的底层输入流

DataOutputStream(OutputStream out)
// 创造的数据输出流指向一个由参数out指定的底层输出流
常用方法

字面意思便可理解的不多解释

close(); // 关闭流
readBoolean();
readByte();
readChar();
readDouble():
readFloat();
readInt();
readLong();
readShort();
readUnsignedByte(); // 读取一个无符号字节
readUTF(); // 读取一个UTF字符串
skipBytes(int n); // 跳过给定数量的字节
writeInt(int n);
writeBytes(String s);
writeBoolean(boolean n);
writeChars(String s);
writeDouble(double n);
writeFloat(float n);
writeLong(long n);
writeShort(int n);
writeUTF(String s);
代码示例

将几个数据写入到HW.txt文件再读出

import java.io.*;

public class test {
    public static void main(String[] args) {
        try {
            FileOutputStream out = new FileOutputStream("D:\\JAVA\\HW.txt");
            DataOutputStream outdata = new DataOutputStream(out);
            outdata.writeBoolean(true);
            outdata.writeFloat(3.14f);
            outdata.writeChars("Lin");
        } catch (IOException e1) {
            System.exit(-1);
        }
        try {
            FileInputStream in = new FileInputStream("D:\\JAVA\\HW.txt");
            DataInputStream indate = new DataInputStream(in);
            System.out.println(indate.readBoolean());
            System.out.println(indate.readFloat());
            char s = '\0';
            while ((s = indate.readChar()) != '\0') {
                System.out.print(s);
            }
        } catch (IOException e) {}
    }
}
/*
输出结果为：
true
3.14
Lin
*/

3、转换流：

 转换流 InputStreamReader 和 OutputStreamWriter 实现了字节流和字符流之间的转换。

InputStreamReader类与OutputStreamWriter类：
代码示例
import java.io.*;

public class test {
    public static void main(String[] args) {
        try {
            FileOutputStream out = new FileOutputStream("D:\\java\\HW.txt");
            OutputStreamWriter ow = new OutputStreamWriter(out);
            ow.write("ABCD霖");
            ow.close();
        } catch (IOException e1) {
            System.exit(-1);
        }
        try {
            FileInputStream in = new FileInputStream("D:\\java\\HW.txt");
            InputStreamReader is = new InputStreamReader(in);
            int s = -1;
            while ((s = is.read()) != -1) {
                System.out.print((char) s);
            }

        } catch (IOException e2) {
            System.exit(-1);
        }
    }
}
/*
输出结果为：
ABCD霖
*/
霖栩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java io基础
04-24
01_IO初步_java基础_www.gougu.net_文件流
JAVA八股文基础部分
01-11
Java编程基础是深入理解与应用Java技术的基石，涵盖了面向对象编程的基本概念、数据类型、控制结构、类和对象的定义与使用、封装、继承、多态等核心特性，还包括异常处理机制、集合框架、IO流操作以及线程并发等内容...
Java流IO初步
DaxiongYaYa的博客
08-18 308
百度传课听了几节课，从流开始，流，水流的流，流氓的流 用老师的话讲流就相当于一根管道，怼到水桶上，水桶里的水就是数据，在原来的管道上也可以包上其他的管道。 流的分类：输入流输出流（输入输出是站在程序的角度上来说）                                                eg：InputStream/Reader（输入流）,OutoutStream/W
java中的IO流
weixin_75202470的博客
06-28 178
初始java中的IO流
java io流输出_JAVAＩＯ流输出
weixin_35426913的博客
02-23 242
ｊａｖａｉｏ流概述在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了。一般我们对文件的存储都是通过ｗｉｎｄｏｗ来操作的。所以在ｊａｖａ应用程序中我们需要一个对象来告诉虚拟机，让虚拟...
java io流 字符编码_JAVA IO流中字符串编码不一致问题
weixin_36302350的博客
02-13 129
问题：在读一个txt文件中的日期数据"2020-06-18"存入数据库时，发现读出的string怎么转都不能转为sql.Date类型。初步诊断：System.out.println()输出的从流中读的字符串和预期字符串一样，但是length属性一个是21，一个是10。(因为字符间填充了"u0000"，而且是空字符)空字符输出：System.out.println("aa"+"u0000"+"bb"...
Java IO流操作
Charge8的博客
07-25 688
在整个Java.io 包中最重要的就是5个类和一个接口。5个类指的是File、InputStream、OutputStream、Reader、Writer；一个接口指的是 Serializable。掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了。 一、IO概述 IO(Input/Output)：即输入和输出. 下图是...
JavaIO流：概述
栗筝i的博客
11-23 2151
在接触 IO 流前，无论是 变量的声明、数组的创建，又或者是复杂的并发设计还是 Jvm 的性能调优，我们更多的还是和内存打交道。但我们知道计算机组成包括运算器，控制器，存储器，输入设备，输出设备。也就是不仅仅只有内存和 CPU，所以程序设计语言必须要提供程序与外部设备交互的方式，这就是 IO 框架的由来。我们需要和外部设备进行数据的交互。本篇内容包括：关于 IO 流、关于 Java IO 流、Java IO 层次体系结构
JAVA IO 流学习总结
小小的博客
07-22 154
java.IO层次体系结构 在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了 流式部分――IO的主体部分 非流式部分――主要包含一些辅助流式部分的类，如：File类、Rand...
java io流总结
weixin_44333359的博客
03-14 155
java流的总结 1.基础知识： （1）电脑中数据的三种存储方式：外存（硬盘，磁盘，u盘）》内存（内存条），》缓冲区（在cpu中）。 （2）Java将输入输出抽象称为流 数据流： 一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。 输入流（Input Stream）： 程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道 输出流...
JavaIO流超详解
乐无声的博客
02-23 591
转载请注明文章出处： 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy a
JAVA输入输出流实验报告
11-07
JAVA中，字节流和字符流的套用，提供ＩＯ输入输出的基本语法和步骤
Java-预备知识-Java基础
11-20
语法、数组、面向对象、抽象类、接口、枚举、常用类、集合、泛型、注解、异常处理、多线程、IO 流、网络编程、反射。 学习目标：打下扎实的语言基础，深刻理解面向对象的抽象概念，具备初步编码能力，培养对于编程的...
实验项目D、Java应用专题编程
04-05
4、初步了解和掌握Java集合框架。 5、掌握Java包装类的基本用法。 6、初步掌握几个常用类和接口的含义和使用。 ★专题：文件IO和数据库编程★ 1、掌握File类的使用。 2、掌握字节流IO的操作。 3、掌握字符流IO的...
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 895
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1206
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 493
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
javaio流字节流
12-14
Java IO流是用来处理设备之间的数据传输的，Java对数据的操作是通过流的方式进行的。Java用于操作流的类都在IO包中。Java IO流分为字节流和字符流两种类型。字节流以字节为单位进行操作，而字符流以字符为单位进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值