一、读写文本文件
 
可以用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类
 
 
 
 
 
 
 
 
 
 
 

在Android开发中，文件操作还是比较频繁的，本文主要记录下文件的加载，写入等相关操作的使用。
 
流的分类
 
在Java程序中操作文件，都是以流的形式来操作
 
首先按照流向可以分为输入流与输出流两种，这里的输入输出是站在内存的角度而言的，流向内存的为输入流，流出内存的为输出流
按照传输的单位可以分为字节流与字符流，字节流传输的是二进制字节，可操作任何类型的文件，字符流传输的是字符，只能用来读取文本文件
 
字节流
 
字节流有两个抽象的父类，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类派生的，用来支持从磁盘文件的输入
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 等类型的数据 但是我们吧这三个流连接起来 

 就增强了流的功能

 下面通过代码 实现 

   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();

    

    

    

    

   

   

   

  }

  

  

  

  

  

 }