文件流读入



import java.util.*;
import java.io.*;
public class Test {
    public static void main(String[] args) throws FileNotFoundException
    {
        Scanner in;
        in = new Scanner(new File("1.txt"));
        int temp;
        for (int i = 0; i < 5; ++i) {
            temp = in.nextInt();
            System.out.println(temp);
        }
    }
}



文件流输出



import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("2.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
        PrintWriter out = new PrintWriter(osw, true);
        out.println("Hello world!");
    }
}

很有意思的一点是，如果只用了文件名，放到那个类的构造的过程中，那得到的文件是空的！！

这个很有意思！



import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("2.txt");
        PrintWriter out = new PrintWriter(fos, true);
        out.println("Hello world!!");
    }
}

上面的代码也是可以的

注意看下这个代码：

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("2.txt");
        PrintWriter out = new PrintWriter(fos, false);
        out.println("Hello world!!");
    }
}

我改成了false，这样的结果，让文件重新变为空的了。

文件传输是以流的方式进行，根据流向分输入流输出流。
一般以程序为参考  流向设备的 成为输出流。流向程序的成为输入流。
也可以内存与存储设备 为例。流向内存的成为输入流，反之成为输出流。




流分 字节流与字符流两种方式 。
FileInputStream   fs= new FileInputStream(filepath);
byte[] bts = new byte[1024];
  while(fs.read(bts)!=-1)
    System.out.print(new String(bts,0,temp));



fis.close();

一、读写文本文件

可以用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类

 



 

 

 

 

文件流类和文件流对象
文件流是以外存文件为输入输出对象的数据流。
输出文件流   内存->外存
输入文件流   外存->内存
 
文件流类
流的名称
  
流的作用
 
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");
}