精华内容
下载资源
问答
  • C# System.IO 文件流输入输出

    万次阅读 2017-10-25 16:24:45
    一、读写文本文件 可以用fileStream来读写文本文件,但是FileStream是通过字节形式来读写数据的,要把字节数据转换为文本,要自己处理编码转换。 对于文本文件的读写,通常用 StreamReader类和 StreamWriter类更...

    一、读写文本文件

    可以用fileStream来读写文本文件,但是FileStream是通过字节形式来读写数据的,要把字节数据转换为文本,要自己处理编码转换。

    对于文本文件的读写,通常用 StreamReader类和 StreamWriter类更方便。其底层是通过FileStream实现读写文本文件的。

     

    1、构造函数

     

    Public StreamReader(string path,Encoding encodeing)

    其中path指定要读取的完整文件路径,encoding指定要使用的字节编码。例如GB2312,UTF8等编码形式

     

     

    using System;
    using System.IO;
    using System.Text;
    
    namespace StreamReader
    {
    	class Program
    	{
    		[STAThread]
    		public static void Main(string[] args)
    		{
    			StreamReader sr=new StreamReader("f:\\temp.txt",Encoding.GetEncoding("gb2312"));
    			string line;
    			while((line=sr.ReadLine())!=null)
    			{
    				Console.WriteLine(line);
    			}
    			sr.close();
    		}
    	}
    }

     

     

     

     

     

    二、写入文本文件

    与StreamReader类对应的类是StreamWriter类,它专门用于写入文本文件

    1、构造函数

    Public StreamWrite(string path,bool append,Encoding encoding);

    其中path指定要写入的完整文件路径,append为false则该文件被改写,如果该文件存在,并且append为true,则数据被追加到该文件中。否则将创建新文件。Encoding指定要使用的字节编码。

     

    (注意:append为true为追加,append为false为覆盖)

     

    using System;
    using System.IO;
    using System.Text;
    
    namespace StreamReader
    {
    	class Program
    	{
    		[STAThread]
    		public static void Main(string[] args)
    		{
    			StreamWriter sw=new StreamWriter("f:\\temp.txt",true,Encoding.GetEncoding("gb2312"));
    			string line="hello world!;
    				sw.WriteLine(line);
    			sw.close();
    		}
    	}
    }


    三、Stream类

     

    是派生出各种类的抽象类,处理字节流

    其中一些派生类包括

    – FileStream

    – MemoryStream

    – BufferedStream

    – CryptoStream

    方法包括:

     

    3.1FileStream类构造函数

    FileStream(string FilePath, FileMode)

    FileStream(string FilePath, FileMode, FileAccess)

    FileStream(string FilePath, FileMode, FileAccess, FileShare)

    方法:

    int Read(byte array, offset, count)

    int ReadByte( )

    void Write(byte array, offset, count)

    void WriteByte(byte value)

     

    枚举数:

    FileMode 枚举数

    – Append

    – Create

    /若文件已存在,则引发IO异常

    – CreateNew

    – Open

    – OpenOrCreate

    – Truncate

    FileAccess 枚举数

    – Read

    – Write

    – ReadWrite

    FileShare 枚举数

    – None

    – Read

    – Write

    – ReadWrite

     

    3.2MemoryStream类

    用于从内存中读取数据和将数据写入内存中

    以下是 MemoryStream 的一些方法

     

    int Read(byte array, offset, count)

    int ReadByte( )

    void Write(byte array, offset, count)

    void WriteByte(byte value)

    void WriteTo(Stream stream)

     

    3.3BufferedStream类

    用于在缓冲区中读取和写入

    • 当缓冲区满(默认缓冲区大小:4096 字节)或关闭时,内容将自动刷新输出到底层流

    它有两个重载的构造函数

    Public BufferedStream(Stream StName);

    Public BufferedStream(Stream StName,int bsize);

     

    3.4CryptoStream

    对数据流中的数据进行加密、解密

    using System.Security.Cryptography;

    使用前加上上面的命名空间

     

    四、Dirctory类

     

    1.Directory类

    目录使用 Directory类,可以用目录类创建、移动目录,并可列举目录及子目录的内容。Directory类全部是静态方法。

     

    2、DirectoryInfo类

    在使用DirectoryInfo类的属性和方法前必须先创建它的对象实例,在创建时需要指定该实例所对应的目录。例如:DirectoryInfo di=new DirectoryInfo(''c:\\mydir'');DirectoryInfo类的常用方法见表。

     

    五、Path类

     

     

     

     

     

    展开全文
  • Java文件输入输出流

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

    在Android开发中,文件操作还是比较频繁的,本文主要记录下文件的加载,写入等相关操作的使用。

    流的分类

    在Java程序中操作文件,都是以流的形式来操作

    1. 首先按照流向可以分为输入流与输出流两种,这里的输入输出是站在内存的角度而言的,流向内存的为输入流,流出内存的为输出流
    2. 按照传输的单位可以分为字节流与字符流,字节流传输的是二进制字节,可操作任何类型的文件,字符流传输的是字符,只能用来读取文本文件

    字节流

    字节流有两个抽象的父类,InputStram和outputStream,本文主要记录文件的操作,其他的具体实现类暂不讨论,主要看一下经常使用的几个字节流实现类的使用。
    针对文件操作的字节流主要包括FileInputStream与FileOutputStream

    向磁盘写入文件

    			File destFile = new File(filePath);
                FileOutputStream fileOutputStream = new FileOutputStream(destFile);
                fileOutputStream.write(content.getBytes());
                fileOutputStream.close();
    

    写入文件比较简单,传入一个File对象构造FileOutputStream的对象,然后调用write方法即可,最后一定要调用close,释放资源

    从磁盘读取文件

    			FileInputStream fileInputStream = new FileInputStream(file);
                byte[] bytes = new byte[1024];
                int i;
                while((i=fileInputStream.read(bytes))!=-1){
                    stringBuilder.append(new String(bytes,0,i));
                }
                Log.i(TAG, stringBuilder.toString());
                fileInputStream.close();
    

    相对于从磁盘读入内存,读取文件多了几行代码,但也很好理解。需要声明一个byte类型的数组,用于每次读取时将数据存入该数组,声明一个整型i用于保存一次读取到的字节数。最后再根据将字节数组转换成需要的类型,最后也需要调用close释放资源

    缓冲流

    缓冲流相对于上述的字节流字符流并不是一个层面的东西,它并不具备直接操作文件的能力,而是要基于上述的字节流和字符流为基础。之所以要设计缓冲流这个东西,是为了提高读写效率,因为缓冲是利用了将数据先缓存起来,然后再一起写入或读出,避免频繁的磁盘IO操作,提高读写速度。
    针对字节流的缓冲流类有BufferedoutputStream和BufferedInputStream,实际这两个类的设计利用了装饰者模式,利用它可以把FileInputStream与FileOutputStream给包起来,然后操作文件

    向磁盘写入文件

    			FileOutputStream fileOutputStream = new FileOutputStream(destFile);
                BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
                bufferedOutputStream.write(content.getBytes());
                bufferedOutputStream.flush();
                bufferedOutputStream.close();
    

    使用的逻辑和FileInputStream差不多,只是包了一层,最后还调用了flush,用于刷新,相当于向磁盘写入一次

    从磁盘读取文件

    			FileInputStream fileInputStream = new FileInputStream(file);
                BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
                byte[] bytes = new byte[1024];
                int i;
                while((i=bufferedInputStream.read(bytes))!=-1){
                     stringBuilder.append(new String(bytes,0,i));
                }
                fileInputStream.close();
                bufferedInputStream.close();
    

    使用方式与FileOutputStream也差不多,只是用BufferedInputStream把他包了起来

    字符流

    字符流主要包括FileWriter和FileReader,字符缓冲流BufferedWriter,BufferedReader,用法与上述的字节流基本一致,只不过调用read之后获取到的是字符类型,需要用char类型的数组去接收

    			FileReader fileReader = new FileReader(file);
                BufferedReader bufferedReader = new BufferedReader(fileReader);
                char[] chars = new char[1024];
                int charInt;
                while ((charInt = bufferedReader.read(chars))!=-1){
                    Log.i(TAG,"char:"+new String(chars,0,charInt));
                    stringBuilder.append(new String(chars,0,charInt));
                }
                Log.i(TAG,"stringResult : "+stringBuilder.toString());
                fileReader.close();
                bufferedReader.close();
    

    另外在BufferedReader中还提供了readLine方法,按行读取文本文件

    			FileReader fileReader = new FileReader(file);
                BufferedReader bufferedReader = new BufferedReader(fileReader);
                String s;
                while ((s=bufferedReader.readLine())!=null){
                    stringBuilder.append(s);
                }
                Log.i(TAG,"stringResult : "+stringBuilder.toString());
                fileReader.close();
                bufferedReader.close();
    

    以上是对于常用的输入输出流使用的总结,如果有写的不对的欢迎批评指正

    展开全文
  • 文件流类和文件流对象文件流是以外存文件为输入输出对象的数据流。输出文件流 内存->外存输入文件流 外存->内存 文件流类流的名称 流的作用 ifstream类 从istream类派生的,用来支持从磁盘文件的...

    文件流类和文件流对象

    文件流是以外存文件为输入输出对象的数据流。

    输出文件流   内存->外存

    输入文件流   外存->内存

     

    文件流类

    流的名称

    流的作用

    ifstream类

    从istream类派生的,用来支持从磁盘文件的输入

    ofstream类

    从ostream类派生的,用来支持向磁盘文件的输出

    fstream类

    从iostream类派生的,用来支持对磁盘文件的输入输出

     

     

    操作:

    打开文件:

    1、调用文件流的成员函数open。如

    ofstream outfile;

    outfile.open("f1.dat",ios::out);

    2、在定义文件流对象时指定参数在声明文件流类时定义了带参数的构造函数,其中包含了打开磁盘文件的功能。

    ostream outfile("f1.dat",ios::out);

     

    输入输出格式:

    ios::in

    以输入方式打开文件

    ios::out

    以输出方式打开文件(这是默认方式),如果已有此名字的文件,则将其原有内容全部清除

    ios::app

    以输出方式打开文件,写入的数据添加在文件末尾

    ios::ate

    打开一个已有的文件,文件指针指向文件末尾

    ios: :trunc

    打开一个文件,如果文件已存在,则删除其中全部数据,如文件不存在,则建立新文件。如已指定了 ios::out 方式,而未指定ios: :app,ios::ate,ios: :in,则同时默认此方式

    ios:: binary

    以二进制方式打开一个文件,如不指定此方式则默认为ASCII方式

    ios::nocreate

    打开一个已有的文件,如文件不存在,则打开失败。nocrcate的意思是不建立新文件

    ios:: noreplace

    如果文件不存在则建立新文件,如果文件已存在则操作失败,replace 的意思是不更新原有文件

    ios::in l ios::out

    以输入和输出方式打开文件,文件可读可写

    ios:: out | ios::binary

    以二进制方式打开一个输出文件

    ios::in l ios::binar

    以二进制方式打开一个输入文件

     

    注意点:

    1)每一个打开的文件都有一个文件指针,该指针的初始位置由I/O方式指定,每次读写都从文件指针的当前位置开始。每读入一个字节,指针就后移一个字节当文件指针移到最后,就会遇到文件结束EOF(文件结束符也占一个字节,其值为-1),此时流对象的成员函数eof的值为非0值(一般设为1),表示文件结束了。

     

    2)可以用“位或”运算符“|”对输入输出方式进行组合但是不能组合互斥的方式

     

    3如果打开操作失败,open函数的返回值为0(假),如果是用调用构造函数的方式打开文件的,则流对象的值为0。可以据此测试打开是否成功。如

     

        if(!outfile.open("f1.bat", ios::app) )

            cout<<"open error";

     

    向二进制文件中写入类对象,并且读取

    #include <iostream>
    #include <fstream>
    #include <string>
    
    using namespace std;
    
    class Data
    {
    private:
    	int m_a;
    	string m_b;
    	float m_c; 
    public:
    	Data(int  a, string b, float c) :m_a(a), m_b(b), m_c(c){}
    	void show()
    	{
    		cout << "m_a:" << m_a << " , m_b:" << m_b << " , m_c:" << m_c << endl;
    	}
    };
    
    int main()
    {
    	/*输出*/
    	ofstream out("myclass.dat", ios::app | ios::binary);
    	
    	if (out.is_open()!=true)
    	{
    		cout << "can not open myclass.dat " << endl;
    		exit(1);
    	}
    	Data *dataArray[5];
    	dataArray[0] = new Data(0, "hello0", 0.0);
    	dataArray[1] = new Data(1, "hello1", 1.0);
    	dataArray[2] = new Data(2, "hello2", 2.0);
    	dataArray[3] = new Data(3, "hello3", 3.0);
    	dataArray[4] = new Data(4, "hello4", 4.0);
    	out.write((char *)dataArray[0], sizeof(*dataArray[0]));
    	out.write((char *)dataArray[1], sizeof(*dataArray[0]));
    	out.write((char *)dataArray[2], sizeof(*dataArray[0]));
    	out.write((char *)dataArray[3], sizeof(*dataArray[0]));
    	out.write((char *)dataArray[4], sizeof(*dataArray[0]));
    	out.close();
    	system("pause");
    }
    
    int  main1()
    {
    	/*输入*/
    	ifstream in("myclass.dat", ios::binary);
    	if (in.is_open() != true)
    	{
    		cout << "can not open" << endl;
    		exit(0);
    	}
    	Data *dataArray[5] ;
    	dataArray[0] = new Data(0,"",0);
    	dataArray[1] = new Data(0, "", 0);
    	dataArray[2] = new Data(0, "", 0);
    	dataArray[3] = new Data(0, "", 0);
    	dataArray[4] = new Data(0, "", 0);
    	in.read((char *)dataArray[0], sizeof(*dataArray[0]));
    	in.read((char *)dataArray[1], sizeof(*dataArray[0]));
    	in.read((char *)dataArray[2], sizeof(*dataArray[0]));
    	in.read((char *)dataArray[3], sizeof(*dataArray[0]));
    	in.read((char *)dataArray[4], sizeof(*dataArray[0]));
    	(*dataArray[0]).show();
    	(*dataArray[1]).show();
    	(*dataArray[2]).show();
    	(*dataArray[3]).show();
    	(*dataArray[4]).show();
    	in.close();
    	system("pause");
    }

    展开全文
  • /* 流的链接  文件输入输出流->带缓冲的输入输出流(过滤流)->基本数据的输入输出流 链接 ...例如 我们只用文件流不能直接对文件写入 int char float 等类型的数据 但是我们吧这三个流连接起来 就增
     /*
    
    流的链接 
    文件输入输出流->带缓冲的输入输出流(过滤流)->基本数据的输入输出流   链接
    这样的好处是增强了文件输入输出流的功能 
    例如 我们只用文件流不能直接对文件写入 int  char  float 等类型的数据 但是我们吧这三个流连接起来
    就增强了流的功能
    下面通过代码 实现
      FileOutputStream
      BufferedOutputStream
      DataOutputStream    链接对文件输出流进行写
     
     
      FileInputStream
      BufferedInputStream
      DataInputStream    链接对文件输入流进行写
     
     
     
    */
    import java.io.* ;
    class Test
    {
      public static void main(String []args)  throws Exception
     {
       //写文件
      /* FileOutputStream  fos =new  FileOutputStream("link.txt") ;
         BufferedOutputStream bos=new BufferedOutputStream(fos);
         DataOutputStream dis=new DataOutputStream(bos); 
         int a=1;
         char ch='c';
         float f=1.2f; 
       dis.writeInt(a) ;
       dis.writeFloat(f);
       dis.writeChar(ch) ;
       dis.close();//关闭基本数据输出力 
      */
        FileInputStream  fis=new FileInputStream("link.txt");
          BufferedInputStream bis=new BufferedInputStream(fis);
          DataInputStream dis=new DataInputStream(bis);  
        System.out.println(dis.readInt());
        System.out.println(dis.readFloat());
        System.out.println(dis.readChar());
        dis.close();
      
      
      
      
      
      
      
     }
     
     
     
     
     
    }
    展开全文
  • Java实现文件写入——IO输入输出流详解)

    万次阅读 多人点赞 2017-09-09 20:43:12
    输入输出的重要性: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;输入和输出功能是Java对程序处理数据能力的提高,Java以的形式处理数据。是一组有序的数据序列,根据操作的类型,分为输入和输出。...
  • 文件输入流输出流详解

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

    千次阅读 2017-09-06 11:41:13
    输出文件#include #include using namespace std; int i = 100; ofstream file("1.txt"); //文件输出对象,文件名绑定int main() { cout ; //输出到屏幕 file ; //输出
  • C++ 文件操作(输入输出流

    万次阅读 多人点赞 2018-09-26 20:37:15
    到目前为止,我们已经使用了 iostream 标准库,它提供了 cin 和 cout 方法分别用于从标准输入读取流和向标准输出写入流。...该数据类型表示输出文件流,用于创建文件并向文件写入信息。 ifstream 该数据类型...
  • C++输入输出文件流

    千次阅读 2020-02-12 20:40:38
    一、C++输入输出 I/O 库头文件 下列的头文件在 C++ 编程中很重要。 标准输出(cout) 预定义的对象 cout 是 iostream 类的一个实例。cout 对象“连接”到标准输出设备,通常是显示屏。cout 是与插入运算符 <...
  • 文件流类和文件流对象 C普通文件输入输出操作 C二进制文件输入输出操作 总结前言C++输入和输出流(一)——标准输入输出记录了cin和cout的一些使用总结。本文记录文件输入输出的一些代码,理论太多了,其实看完代码,...
  • 当我们使用Java处理文件时,经常会将输入流输出流初始化在一起,(习惯方式) BufferedReader br = null; PrintWriter pw = null; try{ br = new BufferedReader(new FileReader(file)); pw = new PrintWriter...
  • java文件输入输出流学习笔记

    千次阅读 2014-11-06 20:00:19
    1.字节输入输出流:
  • C++ 输入输出流之文件操作和文件流

    千次阅读 2013-12-01 18:46:23
    1. 根据文件中数据的组织形式,文件分为: ...二进制文件(内部格式文件或字符文件):是把内存中的数据按照其在存储中的形式原样输出到磁盘上存放,节省空间,输入输出快,效率高。 例如:43,001
  • 输入输出流 (文件读写)

    千次阅读 2017-06-05 01:30:37
    期末考查:肯定是最基本的1)how to 读;how to 写; 2)文本文件;...fstream:输入输出文件流类1.2 输入输出单个字符的函数:get函数和put函数 get函数 用处:输入单个字符 参数:可以是字符或字符
  • java中文件输入输出流是FileInputStream和FileOutputStream,文件输入文件系统中的某个文件中获得输入字节,然后可以用输出将数据写入 文件中。 首先创建两个的对象: FileInputStream的构造方法有三种重载...
  • Java IO学习总结一:输入输出流

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

    万次阅读 多人点赞 2018-10-13 23:42:06
    在学习使用C++进行STL模型文件的读写与显示时,遇到了一些文件读取的问题,在网上找了很多资料,有些写的比较模糊,自己也遇到了很多坑,在参考以前大神的资料基础上,C++文件流及I/O流相关知识进行了一些总结。...
  • 文件输入输出和string

    万次阅读 2015-10-29 20:48:50
    文件流: 头文件fstream定义了三个类型:ifstream读取,ofstream写入,fstream读取和写入,其继承了iostream。当要读写文件时,把文件流对象与文件关联起来,每个文件流都定义了open成员函数,并对文件视情况打开为...
  • Java(2)-Java IO输入输出流

    万次阅读 多人点赞 2012-04-01 11:28:55
    Java中I/O操作主要是指使用Java进行输入,输出操作.Java所有的I/O机制都是基于数据进行输入输出,这些数据表示了字符或者字节数据的流动序列。Java的I/O提供了读写数据的标准方法。任何Java中表示数据源的...
  • C语言 文件输入输出

    千次阅读 2014-02-07 12:00:04
    文件输入输出函数分为两大类 1.有缓冲区的输入输出(Buffered I/O) 数据先写到缓冲区,满了再写入文件 2.无缓冲区的输入输出(Unbuffered file I/O) 直接操作文件 有缓冲区的输入输出函数,含于stdio.h ...
  • 1.编写应用程序,使用文件输入输出流实现文件的复制,被拷贝的源文件和复制的目标文件由命令行参数给出。 2.编写应用程序,创建一个文件输出,向文件中分别写入以下类型数据:int、double和字符串,然后创建一个...
  • C语言对文件输入输出

    千次阅读 多人点赞 2018-09-03 18:31:51
    输入输出数据的开始和结束仅受程序控制而不受物理符号(如回车换行符)控制,这就增加了处理的灵活性。这种文件称为流式文件。 一、打开与关闭文件 1.1 C语言用标准输入输出函数fopen来实现打开文件,...
  • Java 文件输入字节输出字节

    千次阅读 2019-05-09 19:24:25
    1 文件输入字节输出字节 文件输入字节输出字节FileInputStream 类和 FileOutputStream 类 ,他们创建的相应对象可以以字节为单位完成对文件输出输入操作。 FileInputStream 常用的构造方法 构造...
  • JAVA文件读写输入输出流关闭问题、JAVA垃圾回收
  • Java实现文件写入——输入输出流(IO

    万次阅读 多人点赞 2018-09-21 16:49:14
    输入输出含义和意义: 输入和输出功能是Java对程序处理数据能力的提高,java以的形式处理数据。 是一组有序的数据序列,根据操作类型,分为输入和输出。 程序从输入读取数据,向输出写入数据。 Java...
  • C++文件操作(输入输出流

    千次阅读 2017-01-16 02:13:21
    如图:ios_base是ios类的基类,然后分别派生出 istream 和 ostream 输入输出类,而iostream 类由继承了 istream 和 ostream 的输入输出。 ifstream 类继承了istream ,ofstream 继承了 ostream类。 2.文件打开方式...
  • C++输入输出流

    万次阅读 多人点赞 2019-06-11 20:46:05
    在C++的标准库中,将用于进行数据输入输出的类统称为”类“。cin是类istream的对象,cout是类ostream的对象。要使用类,需要在程序中包含iostream头文件。 C++中常用的几个类及其2相互关系: 图1中的...
  • 输入流的指向称为源,程序从指向源的输入流中读取源中的数据。当程序需要读取数据时,就会开启一个通向数据源的,这个数据源可以时文件、内存或者网络连接。 输出流的指向称为目的地,程序通过向输出流中写入数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 481,222
精华内容 192,488
关键字:

文件流输入输出