JAVA IO流

前段被迫创业

已于 2022-10-26 12:40:55 修改

阅读量610

点赞数

分类专栏：笔记 JAVA学习文章标签： java 开发语言

于 2022-10-25 22:45:41 首次发布

本文链接：https://blog.csdn.net/weixin_63009369/article/details/127443191

版权

笔记同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

JAVA学习

5 篇文章 0 订阅

订阅专栏

IO流种类

一.字节流：字节流处理单元为8位的字节，字节流可以适用于任何类型的对象，包括文本和二进制，用于处理磁盘，内存，键盘等设备上的数据。字节流由InputStream和OutputStream两个抽象类组成。

InputStream子类图:

InputStream是所有子类的父类。

InputStream主要子类功能
类	功能
ByteArrayInputStream	包含一个内部缓冲区，该缓冲区包含从流中读取的字节
PipedInputStream	管道输入流连接管道输出流，并向管道输出流写入数据字节
FileInputStream	从文件中获取字节
SequenceInputStream	从第一个输入流到最后一个输入流依次读取
FilterInputStream	拥有其他一些输入流，将这些流作用为其数据源

OutputStream子类图:

OutputStream是所有输出流的父类

OutputStream主要子类功能
类	功能
ByteArrayOutputSteam	实现一个输出流，并将数据写入一个byte数组
FileOutStream	将数据写入文件
PipeOutptStream	管理输出流连接到管道输入流，传输数据
FilterOutputStream	过滤输出流的父类

二.字符流：字符流处理单元为16位的unicode字符，字符流通常处理文本文件，由Reader处理输入字符和Writer处理输出字符两个抽象类组成

Reader抽象类:

Reader的主要子类
类	功能
BufferedReader	从字符输入流中读取文本
InputStreamReader	字节流通向字符流的桥梁，使用指定的charset读取字符并解码为字符
CharArrayReader	实现一个可用作字符输入流的字符缓冲区
FileReader	用来读取字符文件
FilterReader	用于读取已经过滤的字符流的抽象类
RushbackReader	允许将字符推回字符流reader
PipedReader	从管道中读取字符
String	一个字符串的字符流

Writer抽象类：

Writer的主要子类
类	功能
BufferedWriter	将文本写入字符输出流
CharArrayWriter	实现一个可用于Writer的字符缓冲区
FilterWriter	用于写入已经过滤的字符流的抽象类
OutputWriter	字符流通向字节流的桥梁，可用指定的charset将要写入流中的字符编码为字节
PipedWriter	向管道中写入字符
PrintWriter	向文本输出流打印格式化对象
StringWriter	一个字符流收集其在字符串缓冲区中的输出，然后建立一个字符串

标准输入输出流

标准输入输出流为java.lang.system包，主要分为三种：

(1)Systeam.in:字节输入流类InputStream的对象，代表标准输入，其中read()方法从键盘接受数据

(2)System.out:输出流OutputStream的对象，代表标准输出，有print()和println()；两个方法

(3)System.err:标准错误信息输出流

注:标准输入输出还有java.util.Scanner,javaj.io.Console,java.utilFormatter类

采用System.in读取数据：

public class IOTest {
    public static void main(String[] args) throws IOException {
        System.out.println("请输入:");
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        String string;
        while(( string=in.readLine()).length()!=0){
            System.out.println(string);
            System.exit(0);
        }
    }
}

实现从键盘读取数据调用了System.in,InputStream,BufferedReader类：System.in标准输入，InputStream实现字节到字符的转换，最后BufferedReader将字符送进缓冲区

java.util.Scanner类:可以对字符串和基本数据类型进行分析，用于扫描输入文本信息，在使用Scanner前要使用该类创建一个对象:Scanner sc = new Scanner(System.in)

public class IOTest {
    public static void main(String[] args) throws IOException {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入文本:");
        String string=sc.next();
       System.out.println(string);
    }
}

Scanner方法：

public boolean nextBoolean();    
public short nextShort();   
public int nextInt();
public double nextDouble();
public float nextFloat();
public String next();

io.Console类:适用与输入安全密码

Java.io.Console主要方法
方法	说明
void flush()	刷新控制台并强制立即写入所有缓冲的输出
Console formant(String fmt,Object...args)	指定字符串格式和参数生成格式化的新字符串输出流
Console printf(String format,Object..args)	使用指定字符串格式和参数将格式化字符串写入此控制台输出流
Reader read()	获取与此控制台关联的唯一Reader对象
String reader()	从控制台获取单行文本
String reader(String fmt,Object...args)	提供一个格式化提示，然后从控制台读取单行数据
char[] readPassword()	从控制台读取密码，禁用回显
char[] readPassword(String fmt,Object...args)	提供一个格式化提示，然后从控制台读取密码，禁用回显
PrintWriter writer()	获取与控制台关联的唯一PrintWriter对象

Console类包含一个printf()方法，和C语言printf()方法用一样

文件输入输出流

文件输入输出流：书局存储在文件里，也可以从文件中获取，文件内容可以分为按字节读取，按字符读取和随机读取

字符输出流

字符输出流：将文本数据存储到文本文件中，对字符流的操作采用字符输出方式，应用到FileWriter和BufferedWriter两个类

1.FileWriter类:是Writer的子类OutputSteam下的子类，提供了一组writer()方法实现向文件输出输入字符串，字符数组，整型数据

FileWriter类的方法
方法	说明
void close()	关闭流，但要先刷新它
writer append()	将指定字符添加到此writer
FileWriter(File file) FileWriter(File file,boolean apped) FileWriter(FileDescriptorr fd) FileWriter(String fileName) FileWriter(String file;Name,boolean append)	一组构造方法，根据指定的File 对象，文件名或文件描述符构造一个FileWriter对象
void writer(char[] cbuf)	写入字符串数组
void writer(char[] cbuf,int off,int len)	写入字符数组的某一部分
void writer(int c)	写入单个字符
void writer(String str)	写入字符串
void writer(String str,int off,int len)	写入字符串的某一部分

创建一个文件，并采用FileWriter向文件写入数据，最后要close文件才能向文件读取数据

public class IOTest {
    public static void main(String[] args) throws IOException {
      String filename="C:\\Users\\myun\\Desktop\\hello.txt";
        FileWriter writer=new FileWriter(filename);
        writer.write("hello world!hello time!");
        writer.close();
    }
}

2.BufferWriter类:如果输出的内容较多，可以采用更高效的缓冲器流类BufferedWriter来输出字符，方法和FileWriter一样，不过BufferedWriter添加了newLine()方法提供流换行功能

BufferedWriter类的方法
方法	说明
void close()	关闭流，但要先刷新它
writer append()	将指定字符添加到此writer
BufferedWriter(File file) BufferedWriter(File file,boolean apped) BufferedWriter(FileDescriptorr fd) BufferedWriter(String fileName) BufferedWriter(String file;Name,boolean append)	一组构造方法，根据指定的File 对象，文件名或文件描述符构造一个BufferedWriter对象
void writer(char[] cbuf)	写入字符串数组
void writer(char[] cbuf,int off,int len)	写入字符数组的某一部分
void writer(int c)	写入单个字符
void writer(String str)	写入字符串
void writer(String str,int off,int len)	写入字符串的某一部分
void newLine()	换行功能

创建一个文件，采用BufferedWriter向文件输出字符流

public class IOTest {
    public static void main(String[] args) throws IOException {
      String filename="C:\\Users\\myun\\Desktop\\hello.txt";
        BufferedWriter writer=new BufferedWriter(new FileWriter(filename));
        writer.write("hello world!");
        writer.newLine();
        writer.write("hello time!");
        writer.newLine();
        writer.close();
    }
}

字符输入流

字符输入流:从文本中读取数据时，采用字符输入方式，用于FileReader和BufferedReader两个类

1.FileReader类:继承Reader抽象类的子类InputStream，提供一组read()方法用于单个字符，字符串的读取

FileReader类的方法
方法	说明
int read()	读取单个数据
int read(char[] cbuf)	将字符串读入数组
int read(char[] cbuf,int off,int len)	将字符串一部分读入数组
int read(CharBuffer target)	将字符读入指定字符缓冲区
boolean ready()	判断是否读取此流
void close()	关闭该流并释放与之关联的所有资源
FileReader(File file)	在给定从中读取数据的File的情况下，创建一个新的FileReader
FileReader(FileDescriptor fd)	在给定从中读取数据的FileDescriptor的情况下，创建一个新的FileReader
FileReader(String fileName)	在给定从中读取的文件名的情况下，创建一个新的FileReader

使用FileReader从文件中读取字符流数据:

public class IOTest {
    public static void main(String[] args) throws IOException {
      String filename="C:\\Users\\myun\\Desktop\\hello.txt";
      char[] buff=new char[100];  //定义数组。用来保持每次读到的数据
        int n;   //每次读到的字符长度
    FileReader reader=new FileReader(filename);
    while((n=reader.read(buff))!=-1){
        for(int i=0;i<n;i++){
            System.out.print(buff[i]);
        }
    }
    reader.close();
    }
}

2.BufferedReader类:继承Readerl类，用于从字符输入流读取文本，缓冲字符，通过ReadLine()方法来鉴别换行符

方法	说明
int read()	读取单个数据
int read(char[] cbuf)	将字符串读入数组
int read(char[] cbuf,int off,int len)	将字符串一部分读入数组
int read(CharBuffer target)	将字符读入指定字符缓冲区
boolean ready()	判断是否读取此流
void close()	关闭该流并释放与之关联的所有资源
FileReader(File file)	在给定从中读取数据的File的情况下，创建一个新的FileReader
FileReader(FileDescriptor fd)	在给定从中读取数据的FileDescriptor的情况下，创建一个新的FileReader
FileReader(String fileName)	在给定从中读取的文件名的情况下，创建一个新的FileReader
readLine()	鉴别换行符

使用BufferedReader从文件中逐行读取数据：

public class IOTest {
    public static void main(String[] args) throws IOException {
      String filename="C:\\Users\\myun\\Desktop\\hello.txt";
     String line;
     BufferedReader in=new BufferedReader(new FileReader(filename));
     line=in.readLine();
      while (line!=null){
         System.out.println(line);
         line=in.readLine();
     }
    in.close();
    }
}

字节输出流

字符输出流：如果把非文本数据存储到一个文件中，这些数据可以是文本格式和其他非字符信息格式，图像，音频，视频等，这时可以采用字节的方式将数据输出到文件中，纯文本数据也可以采用字节输出方式。相关类有FileOutputStream，DataOutputStream，BufferedOutputStream

1.FileOutputStream类:继承抽象类OutputStream，将数据输出到File对象或FileDescriptor文件描述符中

FileOutputStream类常用方法
方法	说明
void close()	关闭文件输出流并释放与此流的所有系统资源
void finalize()	清理到文件的连接
FileChannel getChannel()	返回与从文件流有关的FileChannel对象，FileChannel属于NIO
FIleDescriptor getFD()	返回与当前输出流有关的文件描述
void write(byte[] b)	将b.length个字节从指定byte数组写到此文件的输出流
void write(byte[] b,int off,int len)	将指定的byte数组从偏移量off开始的len字节写到文件输出流
void write(int b)	将字节写到文件输出流
FileOutputStream(File file)	构造方法，创建一个向指定File对象的file文件中写入数据的文件输出流
FileOutputStream(String name)	构造方法，创建一个向名称为name的文件中写入数据的文件流

2.DataOutputStream类：继承于FileOutputStream类，是数据输出流。允许程序将基本Java数据类型写入输出流

DataOutputStream类常用方法
方法	说明
void flush()	清空此数据输出流
int size()	写入此输出流的字节数
void write(byte[] b,int off,int len)	将指定byte数组从偏移量off开始的len个字节写入输出流
void write(int b)	将指定字节写入输出流
void writeBoolean(boolean v)	将一个boolean值以1-byte值形式写入输出流
void writeByte(int v)	将一个byte值以1-byte值形式写入输出流
void write(String s)	将字符串按字节顺序写入输出流
void writeChar(int v)	将一个char值以2-byte值形式写入输出流，先写高字节
void writeDouble(double v)	将使用Double类的方法doubleToLongBits方法将double参数转换为一个long值，再将long值以8-byte的形式写入输出流
void writeFloat(float v)	使用Float类的floatToLongBits方法将float参数转换为int，再将int值以4-byte值的形式输出流
void writeInt(int v)	将int值以4-byte值形式写入输出流
void writeLong(long v)	将long值以8-byte值形式写入输出流
void writeShort(int v)	将一个short值以2-byte值形式写入输出流
void writeChars(String s)	将字符串按字符顺序写入输出流
void writeUTF(String str)	以与机器无关方式使用UTF-8编码将一个字符串写入输出流
DataOutputStream(OutputStream out)	创建一个新的输出流，将数据写入指定的输出流

3.BufferedOutputStream类：实现缓冲的输出流

BufferedOutputStream类常用方法
方法	说明
void flush()	刷新缓冲的输出流
void write(byte[] b,int off,int len)	将byte数组从偏移量off开始的len个字节写入到此输出流
void write(int b)	将字节b写入缓冲的输出流
BufferedOutputStream(OutputStream out)	创建一个新的缓冲输出流，将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out,int size)	创建一个缓冲输出流，将具有指定缓冲区大小的数据写入指定的底层输出流

使用BufferedOutputStream将不同数据写入文件：

public class IOTest {
    public static void main(String[] args) throws IOException {
     String filename="C:\\Users\\myun\\Desktop\\bainary.dat";
     DataOutputStream dataOutputStream=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filename)));
     dataOutputStream.writeInt(0);
     System.out.println(dataOutputStream.size()+"已写入字节");
        dataOutputStream.writeDouble(39.3);
        System.out.println(dataOutputStream.size()+"已写入字节");
        dataOutputStream.writeBytes("hello world");
        System.out.println(dataOutputStream.size()+"已写入字节");
        dataOutputStream.close();
    }
}

字节输入流

字节输入流：提供FileInputStream，DataInputStream，BufferedInputStream以字节方式从文件系统中读取数据

1.FileInputStream类：继承于InputStream类，适用于从文件系统的文件读取字节，用于读取二进制的原始字节源

FileInputStream类常用方法
方法	说明
int available()	返回输入流中估计剩余的，实际可读取的字节数
void close()	关闭此文件输入流并释放与此类有关的系统资源
void finalize()	确保在不再引用文件输入流时调用其close方法
FileChannel getChannel()	返回与此文件输入流有关的唯一FileChannel对象
FileDescriptor getFD()	返回当前FileInputStream所连接文件的FileDescriptor对象
int read()	从此输入流中读取一个数据字节
int read(byte[] b)	从从输入流中将最多b.length字节的数据读入一个byte数组bzhong
int read(byte[] b,int off,int len)	从此输入流中将最多len字节的数据读入一个byte数组中
long skip(long n)	从输入流中跳过并丢弃n字节数据
FileInputStream(File file)	通过打开与实际文件的连接来创建一个FileInputStream
FileInputStream(String name)	通过打开一个与实际文件的连接来创建一个FileInputStream

2.DataInputStream类：继承FileInputStream类，允许程序从底层输入流中读取基本的Java数据类型

DataInputStream类常用方法
方法	说明
int read(byte[] b)	从包含的输入流中读取一定量的字节，并将它们存储到缓冲区数组b中
int read(byte[] b,int off,int len)	从包含输入流中将最多len字节读入一个byte数组中
boolean readBoolean()	从包含的输入流中读取Boolean类型的数据
byte readByte()	从包含的输入流中读取Byte类型的数据
char readChar()	从包含的输入流中读取char类型的数据
double readDouble()	从包含的输入流中读取double类型的数据
float readFloat()	从包含的输入流中读取float类型的数据
void readFully(byte[] b)	将b.length字节从文件读入byte数组b中，并从当前文件指针开始
void readFully(byte[] b,int off,int len)	将正好len字节从此文件读入byte数组，读取位置从当前文件指针跳过off字节开始
int readInt()	从包含的输入流中读取Int类型数据
DataInputStream(InputStream in)	构造方法，使用指定的底层InputStream创建一个DataInputStream

以字节流方式从文件读取数据:

public class IOTest {
    public static void main(String[] args){
   try{
       FileInputStream fileInputStream=new FileInputStream("C:\\Users\\myun\\Desktop\\bainary.dat");
      DataInputStream dataInputStream=new DataInputStream(fileInputStream);
      System.out.println("\t"+dataInputStream.readChar());
      System.out.println("\t"+dataInputStream.readInt());
       System.out.println("\t"+dataInputStream.readBoolean());
   }catch(IOException e){
    System.err.println(e);
   }
    }
}

3.BufferedInputStream类：继承FileInputStream类，实现了通过缓冲区高效读取数据

BufferedInputStream类常用方法
方法	说明
BufferedInputSteam(InputStream in)	创建一个BufferedInputStream并保持其参数
BufferedInputStream(InputStream in,size)	创建具有指定缓冲区大小的BufferedInputStream并保持参数
int available()	返回输入流中实际可读的字节数
int read()	读出数据
int read(byte[] b,int off,int len)	从此字节输入流中的给定偏移量处开始将各个字节读取到指定的byte数组b中
void close()	关闭从输出并释放与该流关联的所有系统资源

所有BufferedInputStream以字节方式从文件中读取数据：

public class IOTest {
    public static void main(String[] args){
   String filename="C:\\Users\\myun\\Desktop\\bainary.dat";
int sum=0;
try{
    DataInputStream ins=new DataInputStream(new BufferedInputStream(new FileInputStream(filename)));
    System.out.println("\t"+ins.readBoolean());
    System.out.println("\t"+ins.readInt());
    System.out.println("\t"+ins.readChar());
    System.out.println("\t"+ins.readByte());
    ins.close();
}catch(IOException iox){
    System.out.println("problem reading"+filename);
}
    }
}

File类

File类：将文件和目录封装为类，通过面向对象的方式来实现创建文件，删除文件，重命名文件，判断文件的读写文件等待

方法	说明
boolean delete()	输出此抽象路径名表示的文件或目录
boolean equals(Objectn obj)	测试此抽象和给定的对象是否相等
boolean exists()	测试此抽象路径表示的文件或目录是否存在
boolean isFile()	测试此抽象路径名表示的文件是否是一个标准文件
boolean isDirectory()	测试此抽象类路径名表示的文件是否是一个目录
long length()	返回由此抽象路径名表示的文件的长度
String getName()	f返回由此抽象路径名表示的文件或目录的名称
boolean renameTo(File name)	以name重命名当前文件名字
static String separator	separator和pathSeparator是两个常量，表示在不同的系统中斜杆的方向，在Windows中，斜杆是向右斜的\\,在Linux中，斜杆是向左斜的//
static String pathSeparator

随机文件的读写

随机文件读写RandomAccessFile类继承object类，实现文件的随机读写

RandomAccessFile常用类
方法	说明
int readInt()	从此文件中读取一个int型数据
float readfloat()	从此文件读取一个float型数据
char readChar	从此文件读取一个char型数据
double readDouble()	从此文件读取一个double型数据
String readline()	从此文件读取一行文本
String readUTF()	从此文件读取一个string
void writeInt(int v)	向文件中写入一个int型数据
void writefloat(float v)	向文件中写入一个float型数据
void writeLong(Long v)	向文件中写入一个long型数据
void writeChar(int v)	向文件中写入一个char型数据
void writeChars(String v)	向文件写入一个String
int skipBytes(int n)	将指针向下移动若干个字节
long length()	返回文件长度
long getFilePointer()	返回指针当前位置
void seek(long pos)	将指针调整到需要的位置
RandomAccessFile(File file,String mode)	创建从中读取和向其中写入的随机访问文件流，该文件由File参数指定
RandomAccessFile(String name,String mode)	创建从中读取和向其中写入的随机访问文件流，该文件由name参数指定

把一个整形数据写入文件中，然后从文件末把数据读出来:

public class IOTest {
    public static void main(String[] args){
   try{
       FileOutputStream fo=new FileOutputStream("C:\\Users\\myun\\Desktop\\file.ra");
       fo.close();
   }catch (Exception e){
    System.out.println("无法创建文件："+e);
   }
   try{
       RandomAccessFile randf=new RandomAccessFile("C:\\Users\\myun\\Desktop\\file.ra","rw");
       int data[]={1,2,3,4,5,6,7,8,9,10};
       System.out.print("写入数据为：");
       for(int i=0;i<data.length;i++){
           System.out.print(data[i]+",");
           randf.writeInt(data[i]);
       }
       System.out.println("读取的数据为:");
       for(int i=data.length-1;i>=0;i--){
           randf.seek(i*4L);
           System.out.print(randf.readInt()+",");
       }
       System.out.println();
       randf.close();
   }catch(Exception e){
       System.out.println(e+"文件错误");
   }

    }
}

对象序列化

对象序列化：把Java对象转换为字节序列的过程

对象序列化：把字节序列转换为Java对象

ObjectOutputStream类通过一组writexxx方法实现向文件中写入对象

ObjectOutputStream部分方法
方法	说明
Object replaceObject(Object obj)	在序列化期间，此方法允许ObjectOutputStream的子类使用一个对象代替另一个对象
void reset()	重置已写流中的所有对象的状态
void writeObject(Object obj)	将对象obj写入ObjectOutputStream
void writeDouble(double val)	写入一个64位的double型值
void writeChars(String str)	以char序列形式写入一个String
void writeFloat(float val)	写入一个32位的float型值
void writeInt(int val)	写入一个32位的int型值
void writeLong(long val)	写入一个32位的long型值
void writeUTF(String str)	以UTF-8修改版本格式写入此String的基本数据

ObjectInputStreaml类实现了从文件读取对象：

方法	说明
void readObject()	从ObjectOutputStream中读取一个对象
void readChar()	读取一个16位的char型值
void readDouble()	读取一个64位的double型值
void readFloat()	读取一个32位的float型值
void readInt()	读取一个32位的int型值
void readLong()	读取一个64位的long值
void readUTF()	以UTF-8修改版本格式读取一个String