精华内容
下载资源
问答
  • C++输入输出流
    千次阅读
    2022-03-09 21:23:52

    C++输入输出流

    一、关于C++ IO库

    1.引言

    ​ c++使用类型安全的IO流操作,不同类型的IO流操作都是重载的,没有定义过IO功能的类型不具备IO操作能力。

    ​ 通过修改 和扩充,C++既可以为标准数据类型的IO,也能用于自定义类型的IO,这种扩展性是C++最有价值的特点之一。

    ​ 所谓流stream是指数据从一个未知流向另一个位置,流是字节的序列。

    ​ 输入输出是一种数据传递操作,可以看作字符序列在计算机内存与外设之间的流动,c++将数据从一个对象到另一个对象的流动称为流。

    2.IO流库的层次结构

    ​ ·C++ IO流库中有两个平行基类:

    streambuf

    ios

    ​ ios直接派生类:

    ​ ·输入流类istream

    ​ ·输出流类ostream

    ​ ·文件流类基类fstreambase

    ​ ·字符串流类基类strstreambase

    3.IO流库的头文件

    ​ iostream:包含了对输入输出流进行操作的基本信息,还包括cin、cout、cerr、clog

    ​ fstream:用于用户管理文件的IO操作

    ​ strstream:用于字符串流IO

    ​ stdiostream:用于混合使用C和C++的IO操作

    ​ iomanip:用于格式化IO

    二、无格式输入输出

    ​ 无格式IO就是按照系统预定义的格式进行输入输出

    ​ cin用于处理标准输入,即键盘输入

    ​ cout用于处理标准输出,即屏幕输出

    ​ 原函数:

    ostream cout(stdout);
    istream cin(stdin);
    

    ​ 重载运算符>>和<<:

    cin>>E1>>E2;
    cout<<E<<E2<<endl;//endl用于换行
    

    三、C++的格式化输入输出

    1.方式一 用流对象的成员函数格式化

    ​ 流成员函数主要是通过对状态标志、输出宽度、填充字符以及输出精度的操作来完成输入、输出格式化。

    ​ 输入输出的格式由各种状态标志来决定,在ios类中定义为枚举量。

    ​ 因为定义在ios类中,引用时必须包含ios::前缀。使用时全用符号名,不能用数值。

    //设置状态标志的函数
    long ios::setf(long flags);
    //清除状态标志的函数
    long ios::unsetf(long flags);
    //用函数flags取状态标志的两种形式:
    long ios::flags();
    long ios::flags(long flag);
    //用于设置输出宽度(只对其后的第一个输出项有效)
    int ios::width(int len);//设置输出宽度,并返回原输出宽度
    int ios::width();//返回当前输出宽度,默认输出宽度为0
    //设置填充字符(当输出值不满输出宽度时用填充字符填充,故需要与width函数配合使用)
    char ios::fill(char ch);//设置填充字符,并返回设置前的填充字符
    char ios::fill();//返回当前填充字符
    //设置输出精度(默认为6)
    int ios::precision(int p);//重新设置输出精度
    int ios::precision();//返回当前输出精度
    //输出单个字符:
    char ios::put();
    //读入一个字符(若遇到文件结束符,函数的返回值就是读入的字符,遇到输入流文件结束符返回EOF)
    char ios::get();
    char ios::get(char ch);//读入的参数赋值给ch
    void ios::get(char *ch,int n,char end);//在遇到end字符前读n-1个字符赋值给*ch
    //读入一行字符
    void ios::getline(char *ch,int n,char end);
    

    ​ istream其他成员函数

    bool eof();//表示文件结束
    char peek();//观察返回下一个字符,观察指的是流指针位置不变
    void putback();//将前面用get或getline读取的字符插入到当前流指针位置
    void ignore(int n,char end);//跳过n个字符,遇到end不继续跳
    void ignore();//ignore(1,EOF)
    

    ​ 以上函数的使用:

    <流对象名>.<函数名>(ios::<状态标志>);
    cout.setf(ios::showpos);//设置状态标志showpos
    cout.unsetf(ios::showpos);//删除状态标志showpos
    cout.with(10);//设置宽度十
    cout.put('a').put(97);//输出aa
    cin.get(ch,20,'\n');//读到换行符号之前读19个字符给ch
    cin.eof();//文件结束返回true
    cin.peek();//观察返回下一个字符
    cin.ignore(5,'A');//跳过五个字符,遇到A不继续跳
    

    2.方式2:用控制符格式化

    //设置输入输出宽度setw(int)
    //只对后边第一个输入输出有效
    //实际宽度小向右对其
    //反之按数据实际宽度输出
    cout<<E1<<setw(6)<<E2<<setw(4)<<E3;
    //设置填充字符setfill(char)
    //设置后直到下一次设置前一直有效
    cout<<E1<<setfill('a')<<E2<<setfill('b')<<E3;
    //设置输出精度setprecision(int)
    //参数为0默认六位输出
    cout<<E1<<setprecision(6)<<E2<<setprecision(4)<<E3;
    //设置标志setiosflags(long flag)
    cout<<setiosflags(ios::fixed)<<E;
    //设置终止输出格式resetiosflags()
    cout<<resetiosflags();
    //设置输入输出整数数制dec hex oct
    //换行控制符endl
    //输出单字符控制符ends
    

    ​ 用户自定义控制符:

    ostream &<控制符函数名>(ostream stream){
    	//自定义语句
    	return stream;
    }
    istream &<控制符函数名>(istream stream){
    	//自定义语句
    	return stream;
    }
    

    3.flags:

    flag参数作用
    ios::fixed定点数表示实数
    ios::scientific科学计数法表示实数
    ios::left左对齐
    ios::right右对齐
    ios::uppercase大写表示
    ios::showpos输出正数时给出+
    ios::skipws忽略前导空格

    四、文件的输入输出

    1.文件

    ​ C++把文件看作是一个字符(字节)的序列,即由一个个字符(字节)顺序组成;

    ​ 根据数据组织形式,可分为ASCII文档和二进制文件

    2.文件流

    ​ iostream->fstream

    ​ istream->ifstream (mod值ios::in)

    ​ ostream->ofstream (mod值ios::out)

    void open(char *filename,int mod);//使用open()函数简历或打开一个文件
    void close();//使用close()函数关闭一个文件
    void read(char *ch,int len);//读入len个字符
    void write(char *ch,int len);//读入len个字符
    
    //示例
    #include<iostream>
    #include<fstream>
    using namespace std;
    int main(){
        char s[100];
    	ofstream ostrm;
        ostrm.open("f1.txt",ios::out);
        ostrm.write(s,10);
        ostrm<<120<<endl;//写操作
        ostrm.close();
        ifstream istrm;
        istrm.open("f2.txt",ios::in);
        cin>>s;
        istrm.read(s,10);
        istrm.close();
    }
    

    五、字符串流(内存流)

    1.特点

    ​ 以字符数组作为输入输出对象

    ​ 具有相应缓冲区

    ​ 在字符数组中可以存放字符,也可以存放整数、浮点数

    2.原型

    ostrstream::ostrstream(char *buffer,int n,int mod=ios::out);
    istrstream::istrstream(char *buffer,int n);
    istrstream::istrstream(char *buffer);
    
    更多相关内容
  • Java输入输出流

    千次阅读 2021-03-11 11:58:19
    1.什么是IOJava中I/O操作主要是指使用Java进行输入,输出操作.Java所有的I/O机制都是基于数据进行输入输出,这些数据表示了字符或者字节数据的流动序列。Java的I/O提供了读写数据的标准方法。任何Java中表示...

    1.什么是IO

    Java中I/O操作主要是指使用Java进行输入,输出操作. Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。

    Java.io是大多数面向数据流的输入/输出类的主要软件包。此外,Java也对块传输提供支持,在核心库 java.nio中采用的便是块IO。

    流IO的好处是简单易用,缺点是效率较低。块IO效率很高,但编程比较复杂。

    JavaIO模型  :

    Java的IO模型设计非常优秀,它使用Decorator模式,按功能划分Stream,您可以动态装配这些Stream,以便获得您需要的功能。例如,您需要一个具有缓冲的文件输入流,则应当组合使用FileInputStream和BufferedInputStream。

    2.数据流的基本概念

    数据流是一串连续不断的数据的集合,就象水管里的水流,在水管的一端一点一点地供水,而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据,这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说,看不到数据流在写入时的分段情况,每次可以读取其中的任意长度的数据,但只能先读取前面的数据后,再读取后面的数据。不管写入时是将数据分多次写入,还是作为一个整体一次写入,读取时的效果都是完全一样的。

    “流是磁盘或其它外围设备中存储的数据的源点或终点。”

    在电脑上的数据有三种存储方式,一种是外存,一种是内存,一种是缓存。比如电脑上的硬盘,磁盘,U盘等都是外存,在电脑上有内存条,缓存是在CPU里面的。外存的存储量最大,其次是内存,最后是缓存,但是外存的数据的读取最慢,其次是内存,缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解,我们可以简单的理解为容器,即外存是一个容器,内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢?

    在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:

    标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流等等,java中将输入输出抽象称为流,就好像水管,将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流,将数据从内存写入外存中的称为输出流。

    流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。

    总结的基本概念如下:

    1) 数据流:

    一组有序,有起点和终点的字节的数据序列。包括输入流和输出流。

    1355473547_6986.jpg

    2) 输入流(Input  Stream):

    程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…),即是将数据源读入到程序的通信通道

    1333248748_3106.jpg

    3) 输出流:

    程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

    1333248874_6866.jpg

    采用数据流的目的就是使得输出输入独立于设备。

    Input  Stream不关心数据源来自何种设备(键盘,文件,网络)

    Output  Stream不关心数据的目的是何种设备(键盘,文件,网络)

    4 数据流分类:

    流序列中的数据既可以是未经加工的原始二进制数据,也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种:

    1)  字节流:数据流中最小的数据单元是字节

    2)  字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。

    3. 标准I/O

    Java程序可通过命令行参数与外界进行简短的信息交换,同时,也规定了与标准输入、输出设备,如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

    1. 命令行参数

    public class TestArgs {

    public static void main(String[] args) {

    for (int i = 0; i 

    System.out.println("args[" + i + "] is ");

    }

    }

    }

    运行命令:javaJava C VB

    运行结果:

    args[0] is

    args[1] is

    args[2] is

    2. 标准输入,输出数据流

    java系统自带的标准数据流:java.lang.System:

    java.lang.System

    public final class System  extends Object{

    static  PrintStream  err;//标准错误流(输出)

    static  InputStream  in;//标准输入(键盘输入流)

    static  PrintStream  out;//标准输出流(显示器输出流)

    }

    注意:

    (1)System类不能创建对象,只能直接使用它的三个静态成员。

    (2)每当main方法被执行时,就自动生成上述三个对象。

    1) 标准输出流 System.out

    System.out向标准输出设备输出数据,其数据类型为PrintStream。方法:

    Void print(参数)

    Void println(参数)

    2)标准输入流 System.in

    System.in读取标准输入设备数据(从标准输入获取数据,一般是键盘),其数 据类型为InputStream。方法:

    int read()  //返回ASCII码。若,返回值=-1,说明没有读取到任何字节读取工作结束。

    int read(byte[] b)//读入多个字节到缓冲区b中返回值是读入的字节数

    例如:

    import java.io.*;

    public class StandardInputOutput {

    public static void main(String args[]) {

    int b;

    try {

    System.out.println("please Input:");

    while ((b = System.in.read()) != -1) {

    System.out.print((char) b);

    }

    } catch (IOException e) {

    System.out.println(e.toString());

    }

    }

    }

    等待键盘输入,键盘输入什么,就打印出什么:

    1354093989_4632.jpg

    3)标准错误流

    System.err输出标准错误,其数据类型为PrintStream。可查阅API获得详细说明。

    标准输出通过System.out调用println方法输出参数并换行,而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法,包括输出参数类型为boolean、char、int、long、float和double。同时,也重载实现 了输出参数类型为char[]、String和Object的方法。其中,print(Object)和println(Object)方法在运行时将调 用参数Object的toString方法。

    import java.io.BufferedReader;

    import java.io.IOException;

    import java.io.InputStreamReader;

    public class StandardInputOutput {

    public static void main(String args[]) {

    String s;

    // 创建缓冲区阅读器从键盘逐行读入数据

    InputStreamReader ir = new InputStreamReader(System.in);

    BufferedReader in = new BufferedReader(ir);

    System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"

    + "\nWindows系统: ctrl-z 退出");

    try {

    // 读一行数据,并标准输出至显示器

    s = in.readLine();

    // readLine()方法运行时若发生I/O错误,将抛出IOException异常

    while (s != null) {

    System.out.println("Read: " + s);

    s = in.readLine();

    }

    // 关闭缓冲阅读器

    in.close();

    } catch (IOException e) { // Catch any IO exceptions.

    e.printStackTrace();

    }

    }

    }

    4.java.IO层次体系结构

    在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了

    Java I/O主要包括如下几个层次,包含三个部分:

    1.流式部分――IO的主体部分;

    2.非流式部分――主要包含一些辅助流式部分的类,如:File类、RandomAccessFile类和FileDescriptor等类;

    3.其他类--文件读取部分的与安全相关的类,如:SerializablePermission类,以及与本地操作系统相关的文件系统的类,如:FileSystem类和Win32FileSystem类和WinNTFileSystem类。

    主要的类如下:

    1. File(文件特征与管理):用于文件或者目录的描述信息,例如生成新目录,修改文件名,删除文件,判断文件所在路径等。

    2. InputStream(二进制格式操作):抽象类,基于字节的输入操作,是所有输入流的父类。定义了所有输入流都具有的共同特征。

    3. OutputStream(二进制格式操作):抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

    Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

    4. Reader(文件格式操作):抽象类,基于字符的输入操作。

    5. Writer(文件格式操作):抽象类,基于字符的输出操作。

    6. RandomAccessFile(随机文件操作):它的功能丰富,可以从文件的任意位置进行存取(输入输出)操作。

    Java中IO流的体系结构如图:

    1355467587_4888.jpg

    5. 非流式文件类--File类

    在Java语言的java.io包中,由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类,因为它不负责数据的输入输出,而专门用来管理磁盘文件与目录。

    作用:File类主要用于命名文件、查询文件属性和处理文件目录。

    public    class   File   extends Object

    implements Serializable,Comparable

    {}

    File类共提供了三个不同的构造函数,以不同的参数形式灵活地接收文件和目录名信息。构造函数:

    1)File (String   pathname)

    例:File  f1=new File("FileTest1.txt"); //创建文件对象f1,f1所指的文件是在当前目录下创建的FileTest1.txt

    2)File (String  parent  ,  String child)

    例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意:D:\\dir1目录事先必须存在,否则异常

    3)File (File    parent  , String child)

    例:File  f4=new File("\\dir3");

    File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建

    一个对应于某磁盘文件或目录的File对象一经创建, 就可以通过调用它的方法来获得文件或目录的属性。

    1)public boolean exists( ) 判断文件或目录是否存在

    2)public boolean isFile( ) 判断是文件还是目录

    3)public boolean isDirectory( ) 判断是文件还是目录

    4)public String getName( ) 返回文件名或目录名

    5)public String getPath( ) 返回文件或目录的路径。

    6)public long length( ) 获取文件的长度

    7)public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。

    File类中还定义了一些对文件或目录进行管理、操作的方法,常用的方法有:

    1) public boolean renameTo( File newFile );    重命名文件

    2) public void delete( );   删除文件

    3)  public boolean mkdir( ); 创建目录

    例子:

    import java.io.File;

    import java.io.IOException;

    public class TestFile {

    public static void main(String args[]) throws IOException {

    File dir = new File("\\root");

    File f1 = new File(dir, "fileOne.txt");

    File f2 = new File(dir, "fileTwo.java");

    // 文件对象创建后,指定的文件或目录不一定物理上存在

    if (!dir.exists())

    dir.mkdir();

    if (!f1.exists())

    f1.createNewFile();

    if (!f2.exists())

    f2.createNewFile();

    System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath());

    System.out.println("f1 Canread=" + f1.canRead());

    System.out.println("f1's len= " + f1.length());

    String[] FL;

    int count = 0;

    FL = dir.list();

    for (int i = 0; i 

    count++;

    System.out.println(FL[i] + "is in \\root");

    }

    System.out.println("there are" + count + "file in //root");

    }

    }

    说明:File类的方法:

    (1) exists()测试磁盘中指定的文件或目录是否存在

    (2) mkdir()创建文件对象指定的目录(单层目录)

    (3) createNewFile()创建文件对象指定的文件

    (4) list()返回目录中所有文件名字符串

    6. Java.IO流类库

    1. io流的四个基本类

    java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类:InputStream、OutputStream及Reader、Writer类,它们分别处理字节流和字符流:

    基本数据流的I/O

    输入/输出

    字节流

    字符流

    输入流

    Inputstream

    Reader

    输出流

    OutputStream

    Writer

    IO框架:

    1160987d328c8cead727d37b3764be23.png

    Java中其他多种多样变化的流均是由它们派生出来的:

    1333250374_3564.gif

    1333250382_9126.gif

    1333250341_6152.gif

    1333250133_8675.gif

    JDK1.4版本开始引入了新I/O类库,它位于java.nio包中,新I/O类库利用通道和缓冲区等来提高I/O操作的效率。

    在java.io包中, java.io.InputStream 表示字节输入流, java.io.OutputStream表示字节输出流,处于java.io包最顶层。这两个类均为抽象类,也就是说它们不能被实例化,必须生成子类之后才能实现一定的功能。

    1. io流的具体分类

    一、按I/O类型来总体分类:

    1. Memory 1)从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream

    2)从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream

    2.Pipe管道实现管道的输入和输出(进程间通信): PipedReader、PipedWriter、PipedInputStream、PipedOutputStream

    3.File 文件流。对文件进行读、写操作 :FileReader、FileWriter、FileInputStream、FileOutputStream

    4. ObjectSerialization 对象输入、输出 :ObjectInputStream、ObjectOutputStream

    5.DataConversion数据流 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型,字节,整数和浮点数)):DataInputStream、DataOutputStream

    6.Printing 包含方便的打印方法 :PrintWriter、PrintStream

    7.Buffering缓冲 在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream

    8.Filtering滤流,在数据进行读或写时进行过滤:FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过

    9.Concatenation合并输入 把多个输入流连接成一个输入流 :SequenceInputStream

    10.Counting计数  在读入数据时对行记数 :LineNumberReader、LineNumberInputStream

    11.Peeking Ahead 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream

    12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader,Writer的转换类):InputStreamReader、OutputStreamWriter

    二、按数据来源(去向)分类:

    1、File(文件): FileInputStream, FileOutputStream, FileReader, FileWriter

    2、byte[]:ByteArrayInputStream, ByteArrayOutputStream

    3、Char[]: CharArrayReader, CharArrayWriter

    4、String: StringBufferInputStream, StringReader, StringWriter

    5、网络数据流:InputStream, OutputStream, Reader, Writer

    7. 字节流InputStream/OutputStream

    1. InputStream抽象类

    InputStream 为字节输入流,它本身为一个抽象类,必须依靠其子类实现各种功能,此抽象类是表示字节输入流的所有类的超类。 继承自InputStream  的流都是向程序中输入数据的,且数据单位为字节(8bit);

    InputStream是输入字节数据用的类,所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法:

    (1) public abstract int read( ):读取一个byte的数据,返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。

    (2) public int read(byte b[ ]):读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的

    (3) public int read(byte b[ ], int off, int len):从输入流中最多读取len个字节的数据,存放到偏移量为off的b数组中。

    (4) public int available( ):返回输入流中可以读取的字节数。注意:若输入阻塞,当前线程将被挂起,如果InputStream对象调用这个方法的话,它只会返回0,这个方法必须由继承InputStream类的子类对象调用才有用,

    (5) public long skip(long n):忽略输入流中的n个字节,返回值是实际忽略的字节数, 跳过一些字节来读取

    (6) public int close( ) :我们在使用完后,必须对我们打开的流进行关闭.

    主要的子类:

    1333250374_3564.gif

    1) FileInputStream把一个文件作为InputStream,实现对文件的读取操作

    2) ByteArrayInputStream:把内存中的一个缓冲区作为InputStream使用

    3) StringBufferInputStream:把一个String对象作为InputStream

    4) PipedInputStream:实现了pipe的概念,主要在线程中使用

    5) SequenceInputStream:把多个InputStream合并为一个InputStream

    2.OutputStream抽象类

    OutputStream提供了3个write方法来做数据的输出,这个是和InputStream是相对应的。

    1. public void write(byte b[ ]):将参数b中的字节写到输出流。

    2. public void write(byte b[ ], int off, int len) :将参数b的从偏移量off开始的len个字节写到输出流。

    3. public abstract void write(int b) :先将int转换为byte类型,把低字节写入到输出流中。

    4. public void flush( ) : 将数据缓冲区中数据全部输出,并清空缓冲区。

    5. public void close( ) : 关闭输出流并释放与流相关的系统资源。

    主要的子类:

    1333250382_9126.gif

    1) ByteArrayOutputStream:把信息存入内存中的一个缓冲区中

    2) FileOutputStream:把信息存入文件中

    3) PipedOutputStream:实现了pipe的概念,主要在线程中使用

    4) SequenceOutputStream:把多个OutStream合并为一个OutStream

    流结束的判断:方法read()的返回值为-1时;readLine()的返回值为null时。

    3. 文件输入流: FileInputStream类

    FileInputStream可以使用read()方法一次读入一个字节,并以int类型返回,或者是使用read()方法时读入至一个byte数组,byte数组的元素有多少个,就读入多少个字节。在将整个文件读取完成或写入完毕的过程中,这么一个byte数组通常被当作缓冲区,因为这么一个byte数组通常扮演承接数据的中间角色。

    1354189614_8795.jpg

    作用:以文件作为数据输入源的数据流。或者说是打开文件,从文件读数据到内存的类。

    使用方法(1)

    File  fin=new File("d:/abc.txt");

    FileInputStream in=new FileInputStream( fin);

    使用方法(2)

    FileInputStream  in=new  FileInputStream(“d: /abc.txt”);

    程序举例:

    将InputFromFile.java的程序的内容显示在显示器上

    1354189800_1523.jpg

    import java.io.IOException;

    import java.io.FileInputStream;

    ;

    public class TestFile {

    public static void main(String args[]) throws IOException {

    try{

    FileInputStream rf=new   FileInputStream("InputFromFile.java");

    int n=512;   byte  buffer[]=new  byte[n];

    while((rf.read(buffer,0,n)!=-1)&&(n>0)){

    System.out.println(new String(buffer) );

    }

    System.out.println();

    rf.close();

    } catch(IOException  IOe){

    System.out.println(IOe.toString());

    }

    }

    }

    4.文件输出流:FileOutputStream类

    作用:用来处理以文件作为数据输出目的数据流;或者说是从内存区读数据入文件

    FileOutputStream类用来处理以文件作为数据输出目的数据流;一个表示文件名的字符串,也可以是File或FileDescriptor对象。

    创建一个文件流对象有两种方法:

    方式1:

    File   f=new  File (“d:/myjava/write.txt ");

    FileOutputStream  out= new FileOutputStream (f);

    方式2:

    FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt ");

    方式3:构造函数将 FileDescriptor()对象作为其参数。

    FileDescriptor() fd=new FileDescriptor();

    FileOutputStream f2=new FileOutputStream(fd);

    方式4:构造函数将文件名作为其第一参数,将布尔值作为第二参数。

    FileOutputStream f=new FileOutputStream("d:/abc.txt",true);

    注意: (1)文件中写数据时,若文件已经存在,则覆盖存在的文件;(2)的读/写操作结束时,应调用close方法关闭流。

    程序举例:使用键盘输入一段文章,将文章保存在文件write.txt中

    1354190012_9885.jpg

    import java.io.IOException;

    import java.io.FileOutputStream;

    public class TestFile {

    public static void main(String args[]) throws IOException {

    try {

    System.out.println("please Input from      Keyboard");

    int count, n = 512;

    byte buffer[] = new byte[n];

    count = System.in.read(buffer);

    FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");

    wf.write(buffer, 0, count);

    wf.close(); // 当流写操作结束时,调用close方法关闭流。

    System.out.println("Save to the write.txt");

    } catch (IOException IOe) {

    System.out.println("File Write Error!");

    }

    }

    }

    5. FileInputStream流和FileOutputStream的应用

    利用程序将文件file1.txt 拷贝到file2.txt中。

    import java.io.File;

    import java.io.IOException;

    import java.io.FileOutputStream;

    import java.io.FileInputStream;

    public class TestFile {

    public static void main(String args[]) throws IOException {

    try {

    File inFile = new File("copy.java");

    File outFile = new File("copy2.java");

    FileInputStream finS = new FileInputStream(inFile);

    FileOutputStream foutS = new FileOutputStream(outFile);

    int c;

    while ((c = finS.read()) != -1) {

    foutS.write(c);

    }

    finS.close();

    foutS.close();

    } catch (IOException e) {

    System.err.println("FileStreamsTest: " + e);

    }

    }

    }

    6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream

    1355473479_8987.jpg

    计算机访问外部设备非常耗时。访问外存的频率越高,造成CPU闲置的概率就越大。为了减少访问外存的次数,应该在一次对外设的访问中,读写更多的数据。为此,除了程序和流节点间交换数据必需的读写机制外,还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区,一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

    BufferedInputStream:当向缓冲流写入数据时候,数据先写到缓冲区,待缓冲区写满后,系统一次性将数据发送给输出设备。

    BufferedOutputStream :当从向缓冲流读取数据时候,系统先从缓冲区读出数据,待缓冲区为空时,系统再从输入设备读取数据到缓冲区。

    1)将文件读入内存:

    将BufferedInputStream与FileInputStream相接

    FileInputStream in=new  FileInputStream( “file1.txt ” );

    BufferedInputStream bin=new  BufferedInputStream( in);

    2)将内存写入文件:

    将BufferedOutputStream与 FileOutputStream相接

    FileOutputStreamout=new FileOutputStream(“file1.txt”);

    BufferedOutputStream  bin=new BufferedInputStream(out);

    3)键盘输入流读到内存

    将BufferedReader与标准的数据流相接

    InputStreamReader sin=new InputStreamReader (System.in) ;

    BufferedReader bin=new             BufferedReader(sin);

    import java.io.*;

    public class ReadWriteToFile {

    public static void main(String args[]) throws IOException {

    InputStreamReader sin = new InputStreamReader(System.in);

    BufferedReader bin = new BufferedReader(sin);

    FileWriter out = new FileWriter("myfile.txt");

    BufferedWriter bout = new BufferedWriter(out);

    String s;

    while ((s = bin.readLine()).length() > 0) {

    bout.write(s, 0, s.length());

    }

    }

    }

    程序说明:

    从键盘读入字符,并写入到文件中BufferedReader类的方法:String readLine()

    作用:读一行字符串,以回车符为结束。

    BufferedWriter类的方法:bout.write(String s,offset,len)

    作用:从缓冲区将字符串s从offset开始,len长度的字符串写到某处。

    8. 字符流Writer/Reader

    Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

    1. Reader抽象类

    用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。

    1333250341_6152.gif

    1) FileReader :与FileInputStream对应

    主要用来读取字符文件,使用缺省的字符编码,有三种构造函数:

    (1)将文件名作为字符串 :FileReader f=new FileReader(“c:/temp.txt”);

    (2)构造函数将File对象作为其参数。

    File f=new file(“c:/temp.txt”);

    FileReader f1=new FileReader(f);

    (3)  构造函数将FileDescriptor对象作为参数

    FileDescriptor() fd=new FileDescriptor()

    FileReader f2=new FileReader(fd);

    (1) 用指定字符数组作为参数:CharArrayReader(char[])

    (2) 将字符数组作为输入流:CharArrayReader(char[], int, int)

    读取字符串,构造函数如下: public StringReader(String s);

    2) CharArrayReader:与ByteArrayInputStream对应

    3) StringReader :与StringBufferInputStream对应

    4) InputStreamReader

    从输入流读取字节,在将它们转换成字符:Public inputstreamReader(inputstream is);

    5) FilterReader:允许过滤字符流

    protected filterReader(Reader r);

    6) BufferReader :接受Reader对象作为参数,并对其添加字符缓冲器,使用readline()方法可以读取一行。

    Public BufferReader(Reader r);

    主要方法:

    (1)  public int read() throws IOException; //读取一个字符,返回值为读取的字符

    (2)  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中,返回值为实际读取的字符的数量*/

    (3)  public abstract int read(char cbuf[],int off,int len) throws IOException;

    /*读取len个字符,从数组cbuf[]的下标off处开始存放,返回值为实际读取的字符数量,该方法必须由子类实现*/

    2. Writer抽象类

    写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。 其子类如下:

    1333250133_8675.gif

    1) FileWrite: 与FileOutputStream对应

    将字符类型数据写入文件,使用缺省字符编码和缓冲器大小。

    Public FileWrite(file f);

    2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。

    Public CharArrayWrite();

    3) PrintWrite:生成格式化输出

    public PrintWriter(outputstream os);

    4) filterWriter:用于写入过滤字符流

    protected FilterWriter(Writer w);

    5) PipedWriter:与PipedOutputStream对应

    6) StringWriter:无与之对应的以字节为导向的stream

    主要方法:

    (1)  public void write(int c) throws IOException; //将整型值c的低16位写入输出流

    (2)  public void write(char cbuf[]) throws IOException; //将字符数组cbuf[]写入输出流

    (3)  public abstract void write(char cbuf[],int off,int len) throws IOException; //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流

    (4)  public void write(String str) throws IOException; //将字符串str中的字符写入输出流

    (5)  public void write(String str,int off,int len) throws IOException; //将字符串str 中从索引off开始处的len个字符写入输出流

    (6)  flush( ) //刷空输出流,并输出所有被缓存的字节。

    (7)close()    关闭流 public abstract void close() throws IOException

    3 .InputStream与Reader差别 OutputStream与Writer差别

    InputStream和OutputStream类处理的是字节流,数据流中的最小单位是字节(8个bit)

    Reader与Writer处理的是字符流,在处理字符流时涉及了字符编码的转换问题

    import java.io.*;

    public class EncodeTest {

    private static void readBuff(byte [] buff) throws IOException {

    ByteArrayInputStream in =new ByteArrayInputStream(buff);

    int data;

    while((data=in.read())!=-1)   System.out.print(data+"  ");

    System.out.println();     in.close();     }

    public static void main(String args[]) throws IOException {

    System.out.println("内存中采用unicode字符编码:" );

    char   c='好';

    int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;

    System.out.println(""+lowBit+"   "+highBit);

    String s="好";

    System.out.println("本地操作系统默认字符编码:");

    readBuff(s.getBytes());

    System.out.println("采用GBK字符编码:");

    readBuff(s.getBytes("GBK"));

    System.out.println("采用UTF-8字符编码:");

    readBuff(s.getBytes("UTF-8"));      }

    }

    1354191297_8218.jpg

    Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符,然后在内存中为其分配内存

    Writer类能够将内存中的Unicode字符转换为其他编码类型的字符,再写到输出流中。

    9. FileWriter类(字符输出流类)

    构造方法:FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话,并创建。

    如: FileWriter fw = new FileWriter("C:\\1.txt");

    FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。

    如:FileWriter fw = new FileWriter("C:\\1.txt",ture); //表示在fw对文件再次写入时,会在该文件的结尾续写,并不会覆盖掉。

    主要方法:

    void write(String str)   //写入字符串。当执行完此方法后,字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。

    viod flush()                //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。

    viod close()               //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后,再写入或者刷新的话,会抛IOException异常。

    10. 如何选择IO流

    1)确定是数据源和数据目的(输入还是输出)

    源:输入流 InputStream Reader

    目的:输出流 OutputStream Writer

    2)明确操作的数据对象是否是纯文本

    是:字符流Reader,Writer

    否:字节流InputStream,OutputStream

    3)明确具体的设备。

    是硬盘文件:File++:

    读取:FileInputStream,, FileReader,

    写入:FileOutputStream,FileWriter

    是内存用数组

    byte[]:ByteArrayInputStream, ByteArrayOutputStream

    是char[]:CharArrayReader, CharArrayWriter

    是String:StringBufferInputStream(已过时,因为其只能用于String的每个字符都是8位的字符串), StringReader, StringWriter

    是网络用Socket流

    是键盘:用System.in(是一个InputStream对象)读取,用System.out(是一个OutoutStream对象)打印

    3)是否需要转换流

    是,就使用转换流,从Stream转化为Reader,Writer:InputStreamReader,OutputStreamWriter

    4)是否需要缓冲提高效率

    是就加上Buffered:BufferedInputStream, BufferedOuputStream, BuffereaReader, BufferedWriter

    5)是否需要格式化输出

    例:将一个文本文件中数据存储到另一个文件中。

    1)数据源和数据目的:读取流,InputStream Reader  输出:OutputStream Writer

    2)是否纯文本:是!这时就可以选择Reader Writer。

    3)设备:是硬盘文件。Reader体系中可以操作文件的对象是 FileReader FileWriter。

    FileReader fr = new FileReader("a.txt");

    FileWriter fw = new FileWriter("b.txt");

    4)是否需要提高效率:是,加Buffer

    BufferedReader bfr = new BufferedReader(new FileReader("a.txt");  );

    BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt");  );

    11. IOException异常类的子类

    1.public class  EOFException :

    非正常到达文件尾或输入流尾时,抛出这种类型的异常。

    2.public class FileNotFoundException:

    当文件找不到时,抛出的异常。

    3.public class InterruptedIOException:

    当I/O操作被中断时,抛出这种类型的异常。

    from: http://blog.csdn.net/hguisu/article/details/7418161

    展开全文
  • 【Java 输入、输出流

    千次阅读 多人点赞 2021-04-15 17:02:47
    Java 输入、输出流(I/O流)1 File类1.1 文件的属性1.2 目录2 文件字节输入、输出流二级目录三级目录3 文件字符输入、输出流二级目录三级目录4 缓冲流二级目录三级目录 概述:输入、输出流提供一条通道程序,可以...


    概述:输入、输出流提供一条通道程序,可以使用这条通道读取源中的数据或把数据传送到目的地。把输入流的指向称作源,程序从指向源的输入流中读取源中的数据;而输出流的指向是数据要去的一个目的地,程序通过向输出流中写入数据把数据传送到目的地。

    在这里插入图片描述

    1 File类

    File对象主要用来获取文件本身的一些信息,不涉及对文件的读写操作

    创建一个File对象的构造方法有3个,如下:

    (1) File(String filename);//filename为文件名
    (2) File(String directoryPath,String filename);//directoryPath是文件的路径
    (2) File(File dir,String filename);//dir为一个目录
    

    使用File(String filename);创建文件时,该文件位置默认为当前程序所在位置

    1.1 文件的属性

    File类的下列方法获取文件本身的一些信息。

    public String getName()//获取文件的名字。
    public boolean canRead()//判断文件是否是可读的。
    public boolean canWrite()//判断文件是否可被写入。
    public boolean exits()//判断文件是否存在。
    public long length()//获取文件的长度(单位是字节)。
    public String getAbsolutePath()//获取文件的绝对路径。
    public String getParent()//获取文件的父目录。
    public boolean isFile()//判断文件是否是一个普通文件,而不是目录。
    public boolean isDirectroy()//判断文件是否是一个目录。
    public boolean isHidden()//判断文件是否是隐藏文件。
    public long lastModified()//获取文件最后修改的时间。
    

    例子1.1(例子中使用上述的一些方法,获取某些文件的信息)

    package Example1;
    
    import java.io.File;
    
    public class Example1_1 {
        public static void main(String[] args) {
            File file = new File("D:\\lifeilin", "lifeilin.txt");//创建文件对象
            try {
                file.createNewFile();//创建一个新文件
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("文件是否存在:" + file.exists());
            System.out.println(file.getName() + "是可读的吗:" + file.canRead());
            System.out.println(file.getName() + "的长度:" + file.length());
            System.out.println(file.getName() + "的绝对路径:" + file.getAbsolutePath());
        }
    }
    

    在这里插入图片描述

    1.2 目录

    (1)创建目录
    public boolean mkdir()

    (2)列出目录中的文件

    public String[] list();用字符串形式返回目录下的全部文件。
    public File [] listFiles();File对象形式返回目录下的全部文件。
    public String[] list(FilenameFilter obj)用字符串形式返回目录下的指定类型的所有文件。
    public File [] listFiles(FilenameFilter obj)File对象形式返回目录下的指定类型所有文件。
    

    上述两方法的参数FilenameFilter是一个接口,该接口有一个方法:
    public boolean accept(File dir,String name);

    例子2(Example1_2.java ,FileAccept.java ),例子2列出当前目录(应用程序所在的目录)下全部java文件的名字)

    FileAccept.java

    package Example1_2;
    
    import java.io.*;
    
    public class FileAccept implements FilenameFilter {//FileAccept类实现FilenameFilter接口
        private String extendName;
        public void setExtendName(String s) {
            extendName="."+s;
        }
        public boolean accept(File dir,String name) { //重写接口中的方法
            return name.endsWith(extendName);
        }
    }
    

    Example1_2.java

    package Example1_2;
    
    import java.io.*;
    
    public class Example1_2 {
        public static void main(String[] args) {
            File dirFile = new File(".");
            FileAccept fileAccept = new FileAccept();
            fileAccept.setExtendName("java");
            String fileName[] = dirFile.list(fileAccept);
            for (String name : fileName) {
                System.out.println(name);
            }
        }
    }
    

    1.3 文件的创建与删除

    当使用File类创建一个文件对象后,例如
    File file=new File(“D:”,“letter.txt”);

    如果D:\目录中没有名字为letter.txt文件,文件对象file调用方法
    public boolean createNewFile();
    文件对象调用方法public boolean delete()可以删除当前文件,
    例如:
    file.delete();

    1.4 运行可执行文件

    ➢用Runtime类声明一个对象( Runtime类在java.lang包)
    Runtime ec;
    ➢然后使用该类的getRuntime()静态方法创建这个对象:
    ec=Runtime.getRuntime();
    ec可以调用 exec(String command) 方法打开本地机的可执行
    文件或执行一个操作。

    下面例子演示打开本地的记事本:

    import java.io.*;
    
    public class Example1_4 {
        public static void main(String[] args) {
            try {
                Runtime ce = Runtime.getRuntime();//创建对象
                File file = new File("c:/windows", "Notepad.exe");
                ce.exec(file.getAbsolutePath());//打开本地记事本
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }
    

    2 文件字节输入、输出流

    ➢java.io包提供了大量的流类.
    ➢Java把InputStream 抽象类的子类创建的流对象称作字节输入流;OutputStream抽象类的子类创建的流对象称作字节输出流。
    ➢针对不同的源或目的地。java.io包为程序提供了相应的输入流或输出流。这些输入、输出流绝大部分都是InputStream、OutputStream、Reader或Writer的子类。

    2.1 文件字节输入流

    使用输入流通常包括4个基本步骤:
    (1)设定输入流的源
    (2)创建指向源的输入流
    (3)让输入流读取源中的数据
    (4)关闭输入流。

    (1)构造方法:设定输入流源
    使用FileInputStream类的下列构造方法创建指向文件的输入流。

    FileInputStream(String name);//使用给定的文件名name创建FileInputStream流
    FileInputStream(File file);//使用File对象创建FileInputStream流
    //参数name和file指定的文件称为输入流的源
    

    FileInpuStream输入流打开一个到达文件的通道(源就是这个文件,输入流指向这个文件)。当创建输入流时,可能会出现错误(也被称为异常)。例如,输入流指向的文件可能不存在。当出现I/O错误,Java 生成一个出错信号,它使用IOException (IO异常)对象来表示这个出错信号。程序必须在try-catch语句中的try块部分创建输入流,在catch (捕获)块部分检测并处理这个异常。例如,为了读取一个名为hello.txt 的文件,建立一个文件输入流in。

            try {
                FileInputStream in = new FileInputStream("hello.txt");//创建指向文件hello.txt的输入流
            } catch (IOException e) {
                System.out.println("File read error:" + e);
            }
    

    或者:

    		File f = new File("hello.txt");//指定输入流的源
            try {
                FileInputStream in = new FileInputStream(f);//创建指向源输入流
            } catch (IOException e) {
                System.out.println("File read error:" + e);
            }
    

    (2)使用输入流读取字节
    文件字节流可以调用从父类继承的read方法顺序地读取文件,只要不关闭流,每次调用read方法就顺序地读取文件中的其余内容,直到文件的末尾或文件字节输入流被关闭。

    ➢int read();读取单个字节的数据,返回字节值(0~255整数) ,如果未读出字节就返回-1。
    ➢int read(byte b[]);读取b.length个字节到字节数组b中,返回实际读取的字节数。如果到达文件的末尾,则返回-1。
    ➢int read(byte b[], int off, int len);读取len个字节到字节数组b中,并返回实际读取的字节数目。如果到达文件的末尾,则返回-1,参数off指定从字节数组的某个位置开始存放读取的数据。

    (3) 关闭流
    输入流都提供了关闭方法close(),尽管程序结束时会自动关闭所有的流,但是当程序使用完流后,显示地关闭任何打开的流仍然是一个良好的习惯,如果没有关闭那些被打开的流,那么就可能不允许另一个程序操作这些所用的资源。

    下面例子使用文件字节流读文件内容:

    import java.io.*;
    
    public class Example2_1 {
        public static void main(String[] args) {
            int n = -1;
            byte[] a = new byte[100];
            try {
                File f = new File("D:\\","Example2_1.java");
                InputStream in = new FileInputStream(f);
                while ((n = in.read(a, 0, 100)) != -1) {
                    String s = new String(a, 0, n);
                    System.out.print(s);
                }
                in.close();
            } catch (IOException e) {
                System.out.println("File read Error" + e);
            }
        }
    }
    

    2.2 文件字节输出流

    ➢使用输出流通常包括4个基本步骤:
    (1)给出输出流的目的地
    (2)创建指向目的地的输出流
    (3)让输出流把数据写入到目的地
    (4)关闭输出流。

    (1)构造方法
    使用FileOutputStream类的下列具有刷新功能的构造方法创建指向文件的输出流。

    FileOutputStream(String name);
    FileOutputStream(File file);
    //参数name和file指定的文件称为输出流的目的地
    

    FileOutpuStream输出流开通一个到达文件的通道(目的地就是这个文件,输出流指向这个文件)。需要特别注意的是,如果输出流指向的文件不存在,Java 就会创建该文件,如果指向的文件是已存在的文件,输出流将刷新该文件(使得文件的长度为0)。另外,与创建输入流相同,创建输出流时,可能会出现错误(被称为异常),例如,输出流试图要写入的文件可能不允许操作或有其他受限等原因。所以必须在try-catch语句中的try块部分创建输出流,在catch (捕获)块部分检测并处理这个异常。例如,创建指向名为destin.txt的输出流out。

            try {
                FileOutputStream out = new FileOutputStream("destin.txt");//创建指向文件destin.txt的输出流
            } catch (IOException e) {
                System.out.println("File writeerror:" + e);
            }
    

    或者:

    		File f = new File("destin.txt");//指定输出流的源
            try {
                FileOutputStream out = new FileOutputStream (f);//创建指向源输出流
            } catch (IOException e) {
                System.out.println("File write:" + e);
            }
    

    可以使用FileOutputStream类的下列能选择是否具有刷新功能的构造方法创建指向文件的输出流。

    FileOutputStream(String name, boolean append) ;
    FileOutputStream(File file, boolean append) ;
    

    当用构造方法创建指向一个文件的输出流时,如果参数append取值true, 输出流不会刷新所指向的文件(假如文件已存在),输出流的write的方法将从文件的末尾开始向文件写入数据,参数append取值false, 输出流将刷新所指向的文件(假如文件已存在)。

    (2)使用输出流写字节
    输出流的wirie方法以字节单位向目的地写数据。

    void write(int n)//向目的地写入单个字节。
    void write(byte b[])//向目的地写入一个字节数组。
    void write(byte b[],int off,int len)//从字节数组中偏移量off处取len个字节写到目的地。
    

    FileOutputStream流顺序地写文件,只要不关闭流,每次调用write方法就顺序地向目的地写入内容,直到流被关闭。

    (3)关闭流
    通过调用close()方法,可以保证操作系统把流缓冲区的内容写到它的目的地,即关闭输出流可以把该流所用的缓冲区的内容冲洗掉(通常冲洗到磁盘文件上)。

    例子2.2使用文件字节输出流写文件a.txt。
    例子2.2首先使用具有刷新功能的构造方法创建指向文件a.txt的输出流、并向a.txt文件写入“新年快乐”,然后再选择使用不刷新文件的构造方法指向a.txt,并向文件写入( 即尾加)“ Happy New Year

    import java.io.*;
    
    public class Example2_2 {
        public static void main(String[] args) {
            byte[] a = "新年快乐".getBytes();
            byte[] b = "Happy New Year".getBytes();
            File file = new File("D:\\","a.txt");                         //输出的目的地
            try {
                OutputStream out = new FileOutputStream(file);      //指向目的地的输出流
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");//a.txt的大小:0字节
                out.write(a);                                    //向目的地写数据
                out.close();
                out = new FileOutputStream(file, true);             //准备向文件尾加内容
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");///a.txt的大小:8字节
                out.write(b, 0, b.length);
                System.out.println(file.getName() + "的大小:" + file.length() + "字节");///a.txt的大小:8字节
                out.close();
            } catch (IOException e) {
                System.out.println("Error " + e);
            }
        }
    }
    

    在这里插入图片描述

    3 文件字符输入、输出流

    ➢Java把Reader抽象类的子类创建的流对象称作字符输入流;Writer抽象类的子类创建的流对象称作字符输出流。

    与FileInputStream. FileOutputStream字节流相对应的是FileReader、FileWriter字符流(文件字符输入、输出流),FileReader 和FileWriter 分别是Reader和Writer的子类,其构造方法分别是:

    FileReader(String filename) ; 
    FileReader(File filename) ;
    
    FileWriter(String filename) ; 
    FileWriter(File filename) ;
    FileWriter(String filename, boolean append) ; 
    FileWriter(File filename,boolean append) ;
    

    字符输入流和输出流的read和write方法使用字符数组读写数据,即以字符为基本单位处理数据。

    ➢1. Reader类提供的read方法以字符为单位顺序地读取源中的数据。

    int read();
    int read(char b[]);
    int read(char b[], int off, int len);
    void close();
    

    ➢2. Writer流 以字符为单位顺序地写文件,每次调用write方法就顺序地向目的地写入内容。Writer类有 如下常用的方法。

    void write(int n)//向输出流写入一个字符。
    void write(byte b[])//向输出流写入一个字符数组。
    void write(byte b[],int off,int length)//从给定字符数组中起始于偏移量off处取len个字符写到输出流。
    void close()//关闭输出流。
    

    例子3使用文件字符输入、输出流将文件a.txt的内容尾加到文件b.txt中

    import java.io.*;
    
    public class Example3 {
        public static void main(String args[]) {
            File sourceFile = new File("a.txt");  //读取的文件
            File targetFile = new File("b.txt");  //写入的文件
            char c[] = new char[19];               //char型数组
            try {
                Writer out = new FileWriter(targetFile, true); //指向目的地的输出流
                Reader in = new FileReader(sourceFile);   //指向源的输入流
                int n = -1;
                while ((n = in.read(c)) != -1) {
                    out.write(c, 0, n);
                }
                out.flush();
                out.close();
            } catch (IOException e) {
                System.out.println("Error " + e);
            }
        }
    }
    

    注:对于Writer流,write 方法将数据首先写入到缓冲区,每当缓冲区溢出时,缓冲区的内容被自动写入到目的地,如果关闭流,缓冲区的内容会立刻被写入到目的地。流调用flush0方法可以立刻冲洗当前缓冲区,即将当前缓冲区的内容写入到目的地。

    4 缓冲流

    ➢BufferedReader和BufferedWriter类创建的对象称作缓冲输入、输出流。二者的源和目的地必须是字符输入流和字符输出流。
    ➢构造方法:

    BufferedReader(Reader in);
    BufferedWriter(Writer out);
    

    BufferedReader流能够读取文本行,方法是readLine()。通过向BufferedReader 传递一个Reader子类的对象(如FileReader 的实例),来创建一个BufferedReader对象,如:

    FileReader inOne = new FileReader("Student. txt") ;
    BufferedReader inTwo = BufferedReader(inOne) ;
    

    然后inTwo流调用readLine()方法中读取Student.txt,例如:

    String strLine = inTwo. readLine() ;
    

    类似地,可以将BufferedWriter流和FileWriter 流连接在一起, 然后使用BufferedWriter流将数据写到目的地,例如:

    FileWriter tofile = new FileWriter("hello.txt") ;
    BufferedWriter out = BufferedWriter(tofile) ;
    

    然后out使用BufferedReader类的方法wite(tring s,int off,int len)把字符串s写到hello.txt中,参数off是s开始处的偏移量,len是写入的字符数量。
    另外,BufferedWriter 流有-一个独特的向文件写入一 个回行符的方法

    newLine() ;

    ➢BufferedReader和BufferedWriter类读 写文件的方法:

    readLine()//读取文本行
    write(String s,int of,int len)//把字符串s写到文件中
    newLine();// 向文件写入一个回行符
    

    由英语句子构成的文件english. txt (每句占一行):
    The arrow missed the target.
    They rejected the union demand.
    Where does this road go to?

    例子4按行读取english. txt,并在该行的后面尾加上该英语句子中含有的单词数目,然后再将该行写入到一个名字为englishCount. txt的文件中

    import java.io.*;
    import java.util.*;
    
    public class Example10_1 {
        public static void main(String[] args) {
            File fRead = new File("D:\\","english.txt");
            File fWrite = new File("D:\\","englishCount.txt");
            try {
                Writer out = new FileWriter(fWrite);//指向目的地的输出流
                BufferedWriter bufferWrite = new BufferedWriter(out);
    
                Reader in = new FileReader(fRead);//指向源的输入流
                BufferedReader bufferRead = new BufferedReader(in);
    
                String str = null;
                while ((str = bufferRead.readLine()) != null) {
                    StringTokenizer fenxi = new StringTokenizer(str);
                    int count = fenxi.countTokens();
                    str = str + " 句子中单词个数:" + count;
                    bufferWrite.write(str);
                    bufferWrite.newLine();
                }
                bufferWrite.close();
                out.close();
                in = new FileReader(fWrite);
                bufferRead = new BufferedReader(in);
                String s = null;
                System.out.println(fWrite.getName() + "内容:");
                while ((s = bufferRead.readLine()) != null) {
                    System.out.println(s);
                }
                bufferRead.close();
                in.close();
            } catch (IOException e) {
                System.out.println(e.toString());
            }
        }
    }
    

    在这里插入图片描述

    展开全文
  • c++输入输出流

    千次阅读 2022-03-23 10:15:11
    输出操作中,字节从内存流向设备(例如,显示屏、打印机、磁盘驱动器、网络连接等)。 应用程序通过字节传达信息。字节可以组成字符、原始数据、图形图像、数字语音、数字视频或者任何应用程序所需要的其他信息。...


    前言

    最近在准备复试,学习c++,就当作是学习笔记了


    `

    一、流

    C++的I/O是以一连串的字节流的方式进行的。在输入操作中,字节从设备(例如,键盘、磁盘驱动器、网络连接等)流向内存。在输出操作中,字节从内存流向设备(例如,显示屏、打印机、磁盘驱动器、网络连接等)。
    应用程序通过字节传达信息。字节可以组成字符、原始数据、图形图像、数字语音、数字视频或者任何应用程序所需要的其他信息。系统I/O结构应该能持续可靠地将字节从设备传输到内存,反之亦然。这种传输一般包含一些机械运动,例如,磁盘或磁带的旋转,或者键盘的敲击。数据传输所花费的时间远远大于处理器内部处理数据所花费的时间。所以I/O操作需要仔细计划和协调,以保证最优的性能。
    C++同时提供“低层次的”和“高层次的”I/O功能。

    低层次的I/O功能(也就是非格式化的I/O)指定字节应从设备传输到内存还是从内存传输到设备。这种传输通常针对单个字节。这种低层次的L/0提供速度快、容量大的传输,但是对程序员来说并不方便。
    高层次的I/O(也就是格式化的I/O)。在这种输出方式中字节被组成了有意义的单元,例如整数、浮点数、字符、字符串和用户定义类型。除了大容量的文件处理之外,这种面向类型的方法能够满足绝大多数的I/O处理。

    1.iostream 库的头文件

    <iostream >头文件定义了cin 、 cout 、cerr和 clog对象,分别对应于标准输入流、标准输出流、无缓冲的标准错误流和有缓冲的标准错误流。同时还提供了非格式化和格式化的LO服务。

    <iomanip>头文件中声明了参数化流操纵符(例如setw和 setprecision)用于向格式化I/O提供有用的服务。
    <fstream>头文件声明了文件处理服务。

    2.输入/输出流的类和对象

    预定义对象cin是一个 istream实例,并且“被连接到”(或者“被绑定到”)标准输入设备,通常是键盘。在下面的语句中,流提取运算符(>>)用于使一个整型变量 grade的值(假设grade已经被声明为int变量)从cin输入到内存:
    cin >> grade;
    注意,由编译器确定grade的数据类型,并选择适当的流提取运算符重载。假设grade已经被正确地声明,流提取运算符不需要附加的类型信息(例如,像C语言的I/O的方式)。重载>>运算符用来输入内置类型、字符串和指针的值。
    预定义对象cout是一个ostream实例,并且“被连接到”标准输出设备,通常是显示屏。在下面的语句中,使用流插人运算符(<<)将变量grade的值从内存输出到标准输出设备:
    cout << grade
    注意,也是由编译器确定grade的数据类型(假设grade已经被正确地声明)并且选择合适的流插入运算符,因此流插入运算符也同样不需要附加类型信息。重载<<运算符用来输出内置类型、字符串和指针的值。
    预定义对象cerr是一个ostream 实例,并且“被连接到”标准错误设备。对象cerr的输出是无缓冲的。这意味着每个针对cerr的流插入的输出必须立刻显示,这对于迅速提示用户发生错误非常合适。
    预定义对象clog是一个ostream 实例,并且“被连接到"标准错误设备。clog 的输出是有缓冲的。这意味着每个针对clog中的流插入的输出将保存在缓冲区中,直到缓冲区填满或是被清空才会输出。在操作系统课程上曾讨论过,使用缓冲技术可以加强I/O的性能。

    二、输出流

    ostream提供了格式化的和非格式化的输出功能。输出功能包括使用流插入运算符(<<)执行标准数据类型的输出;通过成员函数put进行字符输出;通过成员函数write进行非格式化的输出;十进制、八进制、十六进制格式的整数输出;具有不同精确度的浮点数的输出,或是具有强制小数点的浮点数的输出,以及以科学记数和定点小数格式的输出;指定宽度数据的输出;用指定符号填充数据域的输出;以及使用科学记数和十六进制符号表示的大写字母的输出。

    使用成员函数put进行字符输出

    可以使用成员函数put输出字符。例如,语句
    cout.put(“A’);
    显示单个字符A。put也可以级联使用。例如,语句
    cout.put( ‘A’ ).put( ‘\n’ );
    输出一个字母A,接着输出一个换行符。前面的语句就以像使用<<一样的方式执行,因为点运算符(.)是从左向右执行,put 成员函数给ostream对象( cout)返回一个引用,该对象接受了put的调用。也可以用代表一个ASCII值的数字表达式作为参数来调用put成员函数,例如,语句
    cout.put( 65 );
    的输出也是A。

    三、输入流

    1.get函数

    三种get

    没有实参的成员函数 get从指定流输入一个字符(包括空白字符及其他非图形字符,比如表示文件尾的键序列等),并将这个值作为函数调用的返回值返回。get函数在遇到流中的文件尾时返回EOF值。
    带一个字符引用参数的get 函数将输入流中的下一个字符(即使它是一个空白字符)输人,并将它存诸在其引用的字符参数内。在调用这个版本的get 函数时将给调用它的istream对象返回一个引用。
    get 函数拥有三个参数:一个字符数组、一个数组长度限制和一个分隔符(默认值为‘\n’)。这个函数可以从输入流读取多个字符,它可以读取“数组最大长度-1"个字符后终止,也可以遇到分隔符就终止。在程序中,插入一个空字符用来结束字符数组中的输入字符串,字符数组在程序中作为缓冲区。**分隔符没有放置在字符数组中,而是保留在输入流中(分隔符是下一个被读取的字符)。**因此,第二次 get 函数调用所得的结果将是个空行,除非将分隔符从输人流中移出(可以使用cin.ignore( ))。

    2. getline

    成员函数getline操作与第三个版本的成员函数get类似,在该行所存储的字符数组的末尾插入一个空字符。getline函数从流中移除分隔符(也就是读取该字符然后丢弃),没有将其放在字符数组内存储。

    四、使用read、write和gcount的非格式化的I/O

    非格式化的输入/输出使用的分别是istream与 ostream 的成员函数read和 write。成员函数read将一定数量的字节读入到字符数组中,
    成员函数write则从字符数组中输出字节。这些字节没有经过任何格式化,它们就像原始字节一样输入或输出。例如,命令
    char buffer[ ] =“HAPPY BIRTHDAY”;
    cout.write( buffer,10);
    输出 buffer数组中的前10个字符(包括空字符,任何一个空字符都会导致使用cout和<<进行输出操作的终止)。调用
    cout.write(“ABCDEFGHIJKLMNOPQRSTUVWXYZ”,10);
    显示字母表的前10个字母。
    成员函数read将指定数量的字符读入到字符数组中。当读取的字符数量少于指定数量时,failbit将被设置

    五、流操纵符

    浮点精度(precision,setprecision)

    可以使用流操纵符setprecision或ios_base的成员函数 precision来控制浮点数的精度(也就是小数点右边的位数)。调用这两者之中的任何一个都可以改变输出精度,这将影响后面所有的输出操作,直到下一个设置精度操作被调用为止。调用无参数的成员函数 precision将返回当前的精度设置(这样可以在不再使用“黏性的"设置时,重新使用原来的精度设置)。

    域宽( width, setw)

    成员函数width(基类是ios_base)可以设置域宽(也就是输出值所占的字符位数或是可输入的最大字符数)并且返回原先的域宽。如果输出值的宽度比域宽小,则插入填充字符进行填充。宽度大于指定宽度的值不会被截短,会将整个值都打印出来。不含参数的width函数将返回当前域宽。
    宽度设置只适用于下一次输入或输出(也就是说宽度设置并不是“黏性的”),之后的宽度被隐式地设置为0(也就是输入和输出将使用默认设置)。一次宽度设置适用于所有后续输出的假设是逻辑错误。

    对齐(left、right 和 internal)

    流操纵符left和right分别使域左对齐并在其右边填充字符,或者右对齐并在其左边填充字符。填充字符由成员函数fill或是参数化流操纵符setill指定
    流操纵符internal 表示数字的符号(或是使用showbase流操纵符显示的基数)应当左对齐,同时数字的数值部分应右对齐,而中间的部分则使用填充字符填充。

    内容填充( fill , setfill)

    成员函数fill 指定对齐域的填充字符。如果没有字符被指定,则使用空格符填充。fill函数返回设定之前的填充字符。setill操纵符也用于设置填充字符。

    展开全文
  • Flink 侧输出流使用

    千次阅读 2022-03-27 09:37:14
    Flink 侧输出流使用
  • C++ 输入输出流

    千次阅读 2021-04-06 20:08:31
    C++ 输入输出流 输入输出流基本概念 与输入输出流操作相关的类:类的继承关系从上往下如下图所示 istream:用于输入的流类,cin 是该类的对象 ostream:用于输出的流类,cout cerr clog 是该类的对象 ifstream:...
  • java 输入输出流

    千次阅读 2020-06-18 21:57:53
    输出流 我们使用输出流将字符串hello educoder写入到一个文件中: 运行这段代码,打开D盘下你会发现test.txt文件被创建了,并且文件的内容是hello educoder。 代码解释: 最佳实践 上面作为示例的两段代码都是存在...
  • C++文件输入/输出流

    千次阅读 2022-03-24 19:16:48
    文章目录文件输入/输出流类表5: 文件读写模式表6:ios_base 标识的组合意义ofstream:写入文件的流类例8:输出文本文件例9:输出二进制文件ifstream:从文件中读取的流类例10:输入文本文件例11:输入二进制文件表7:...
  • 流是一组有序的数据序列,根据操作类型,分为输入流和输出流。程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个对象,它们提供了各种支持“读入”与“写入”操作的流类。...
  • java输入、输出流的简单入门

    万次阅读 多人点赞 2019-03-30 19:17:24
    另一方面,程序在处理数据后,可能需要将处理的结果写入到永久的存储媒介中或传送给其他的应用程序,这就需要使用输出流。 通俗的解释就是,以我当前程序为主,我要和其他的事物进行交流,所以我必须要搭一个通道...
  • Java输出文件到本地(输出流

    千次阅读 2021-03-05 22:08:58
    } } Java修炼——文件字节输入输出流复制和缓冲流复制 一:文件字节输入输出流复制 首先明确数据源和目的文件,然后就是"中转站",最后就是关闭 package com.bjsxt.ioproject; import java.io.Fi ... Java 输出文件...
  • Flink——Side Output侧输出流

    千次阅读 2020-05-03 23:08:15
    主要内容: 在处理数据的时候,有时候想对不同情况的数据进行不同的处理,那么就需要把数据流进行分流。可以在主数据流上产生出任意数量额外的侧输出流
  • Java IO流学习总结一:输入输出流

    万次阅读 多人点赞 2017-01-09 19:49:50
    Java IO流学习总结一:输入输出流 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构:流的概念和作用流是一组有顺序的,有起点和终点的字节...
  • Flink之侧输出流和流的拆分

    千次阅读 2020-03-01 18:12:52
    窗口watermark和allowedLateness之后依然迟到的流数据,也是通过.sideOutputLateData(outputTag)和result.getSideOutput(outputTag)的侧输出流方式输出的,拿到这一部分数据后用户可以自己处理,相比于spark的水印和...
  • Java实现文件写入——IO流(输入输出流详解)

    万次阅读 多人点赞 2017-09-09 20:43:12
    流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个...
  • Java 文件输出流.pdf

    千次阅读 2021-03-17 19:37:09
    Java 文件输出流Java ⽂件输出流Java IO教程 - Java⽂件输出流创建输出流要写⼊⽂件,我们需要创建⼀个FileOutputStream类的对象,它将表⽰输出流。// Create a file output streamString destFile = "test.txt";...
  • java总结输入流输出流

    万次阅读 多人点赞 2018-05-11 15:50:00
     Java所有的I/O机制都是基于数据进行输入输出,这些数据表示了字符或者字节数据的流动序列。Java的I/O提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据的方式读写它的数据的方法。 ...
  • 输入流和输出流的区别

    千次阅读 2019-11-26 09:14:04
    从程序中向外写出数据,就是输出流 从磁盘、网络、键盘读到内存,就是输入流,用InputStream 或 Reader 写到磁盘、网络、屏幕,都是输出流,用 OuputStream 或 Writer 【Java面试题与答案】整理推荐 基础与语法...
  • 考试题型:主要在选择题、填空题,比分占5%左右。 第一节 类简介 1、在C++中,输入输出时用来完成的。...3、在C++标准类库中,将与数据输入输出相关的统称为“类”,C++常见的几个类的派生关系为:
  • 无意间都到一篇《走心的安卓工程师跳槽经验分享》,发现自己工作几年了,技术方面虽然有了飞跃的进步,可是不知道自己的技术...08.IO输入流与输出流 java的核心库java.io提供了全面的IO接口。包括:文件读写、标准设...
  • 流相关e69da5e887aa3231313335323631343130323136353331333363393133资源流相关资源一般遵循:1)先开后关,先开的输入流,再开的输出流,通过读取输入流写入输出流中,那么应该先关输出流,再关输入流,但是一般关闭...
  • 输出流(SideOutput) 大部分的DataStream API的算子的输出是单一输出,也就是某种数据类型的流。除了split算子,可以将一条流分成多条流,这些流的数据类型也都相同。process function的side outputs功能可以产生...
  • 文件输入流和输出流详解

    千次阅读 2018-06-24 14:30:38
    按照流向划分为输入流和输出流 输入流:就是以程序为中心点,硬盘上的文件内容流入到程序中可以存储数据的东西中比如说数组,用read方法 输出流:就是以程序为中心点,程序中的数组或者其他的可以存储数据的东西中...
  • C++文件输入输出流及标准I/O流类知识总结

    万次阅读 多人点赞 2018-10-13 23:42:06
    在学习使用C++进行STL模型文件的读写与显示时,遇到了一些文件读取的问题...C++所有的输入输出流(I/O)都是基于stream流类,包括iostream,fstream,stringstream等,其对象称为流对象,其之间的相互关系如下: ...
  • Java输入输出流详解

    万次阅读 多人点赞 2017-06-17 21:15:21
    通过数据、序列化和文件系统提供系统输入和输出。 Java把这些不同来源和目标的数据都统一抽象为数据。Java语言的输入输出功能是十分强大而灵活的,美中不足的是看上去输入输出的代码并不是很简洁,因为你往往...
  • Java文件输入输出流

    千次阅读 2019-05-08 16:28:05
    首先按照流向可以分为输入流与输出流两种,这里的输入输出是站在内存的角度而言的,流向内存的为输入流,流出内存的为输出流 按照传输的单位可以分为字节流与字符流,字节流传输的是二进制字节,可操作任何类型的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,181,761
精华内容 472,704
关键字:

输出流