实训项目九:文件与数据流
文件和数据流
![文件和数据流](https://img.taocdn.com/s3/m/9ba492c4aef8941ea76e05da.png)
文件和路径名的信息、管理方面的类如: – File:提供用于创建、复制、删除、移动和打开 文件的静态方法 – FileInfo:提供创建、复制、删除、移动和打 开文件的实例方法 – Directory:提供用于创建、移动和枚举目录和 子目录的静态方法。 – DirectoryInfo:提供用于创建、移动和枚举目 录和子目录的实例方法
注:利用这些类可以操作文件或路径。
文件内容(数据)操作方面的类,如:
Stream(二进制字节格式,为基类) FileStream(二进制字节格式并可以随机操作) BinaryWriter/BinaryReader(二进制字节格式) StreamReader/StreamWriter(字符格式)等。
文件拷贝、删除、移动示例 .doc P14
3、FileInfo类编程
功能: 获得文件信息的FileInfo类编程(当然也可以利 用File类来达到)。
目的: 在获得文件的数据之前,可能需要获得文件的属 性,可以通过FileInfo类来达到。
编程要点: 它与File的差别在于:其方法不是静态方法,需 要实例化其对象来操作
"+stAccessTime); Console.WriteLine("最后一次写时间:
"+stWriteTime ); Console.ReadLine();
练习1:
设计一个能够读写磁盘文件的程序。
练习2:
设计一个能够获得某一文件夹下的各个文件的 信息程序。
5、文件数据(流)的基本知识
1〉建立新文件夹
Directory.CreateDirectory(path) 2〉删除文件夹
Directory.Delete(path) 3〉判断文件夹是否存在
第6章 文件与数据流
![第6章 文件与数据流](https://img.taocdn.com/s3/m/2f82fbfe910ef12d2af9e704.png)
2、字节流 ——基类:例子
把输入流中的所有内容复制到输出流中
public void copy(InputStream in, OutputStream out) throws IOException { byte[] buf = new byte[4096]; int len = in.read(buf); while (len != -1) { out.write(buf, 0, len); len = in.read(buf); } }
File f1 = new File(“file1.txt”); File f2 = new File(“file2.txt”); FileInputStream in=new FileInputStream(f1); FileOutputStream out=new FileOutputStream(f2); FileOutputStream out=new FileOutputStream(“file3.txt”); 输入流的参数是用于指定输入的文件名,输出流的参数则 是用于指定输出的文件名。
2、字节流
例2: 把一个文件的内容加到另一个文件后
import java.io.*; class Filestream { public static void cat(String fsrc, String fdest) { try { InputStream in = new FileInputStream(fsrc); OutputStream out = new FileOutputStream(fdest, true); int c; while((c=in.read())!=-1) out.write(c); public static void main(String args[]) out.close(); { in.close(); cat("file2.txt", "file1.txt"); } } catch (IOException ex) { System.err.println(ex); } }
文件与数据流
![文件与数据流](https://img.taocdn.com/s3/m/bd5b38f8ba0d4a7302763ac6.png)
第8章文件与数据流一、文件和流的概念文件是指在各种驱动器上(硬盘、可移动磁盘等)永久或临时存储的数据的有序集合,是进行数据读/写操作的基本对象。
文件通常具有文件名、路径、访问权限等属性。
流从概念上来说类似于单独的磁盘文件,它也是进行读/写操作的对象。
流提供了连续的字节存储空间,通过流可以向后备的存储器写入数据,也可以从后备存储器读取数据。
与磁盘文件直接相关的流称为“文件流”。
除此之外,还有网络流、内存流等其他类型的流。
流用于传输数据时,有两个传输方向:读:将数据从外部数据源传输到程序中,这是读取流。
写:将数据从程序传输到外部数据源,这是写入流。
二、相关知识1.流的创建FileStream fs = new FileStream( "test1.dat",FileMode.Create, FileAccess.Write);一般格式:FileStream fs = new FileStream( string path,FileMode mode, FileAccess access);参数含义:path:指定当前FileStream对象将封装的文件的相对路径或绝对路径。
可以只是文件名(在程序所在目录下创建或打开文件)mode:指定如何打开或创建文件,它的值必须是FileMode枚举中的值。
access:指定如何访问文件,它的值必须是FileAccess枚举中的值。
2)将数据写入流fs.write(byte[] array,int offset,int count);参数含义:array:要写入文件流的字节数组offset:array数组中开始写入文件流的字节的下标。
count:将要写入流的最大字节数3)从流中读取数据fs.ReadByte()从流中读取一个字节(返回已转换为int的字节),并将流内的位置向前推进一个。
如果已经到达流的末尾,则返回-1。
在读之前,用canRead属性确定当前对象是否支持读取操作。
文件和数据流课件
![文件和数据流课件](https://img.taocdn.com/s3/m/7a23646d443610661ed9ad51f01dc281e53a5615.png)
文件写入的常见方式
使用内置的`open()`函数
使用`write()`方法
除了可以打开文件外, `open()`函数还支持写入模式 ,我们可以使用这个模式来写 入文件。
write()方法用于将文本写入文件中。
使用`writelines()…
writelines()方法一次写入多行文本到文
件中。
使用`seek()`方法改变文 …
使用文件对象的write()方法还可 以将数据追加到文件末尾。追加 数据时,需要以追加模式打开文 件(使用'a'作为打开模式)。
数据流的常见问题及解决方案
数据流丢失
在读取或写入数据流时,可能会 遇到数据流丢失的问题。为了避 免数据流丢失,可以使用备份文
件或进行数据备份。
数据流冲突
多个程序同时访问同一个文件时, 可能会产生数据流冲突。为了避免 数据流冲突,可以使用锁机制来控 制对文件的访问。
写入权限
允许用户修改文件的内容。
执行权限
允许用户执行文件,如可执行 程序等。
访问权限的设定
可以通过文件属性或操作系统 权限设置来限制用户对文件的
访问权限。
02
文件读取和写入
文件读取的基本方法
使用内置的`open()`函数
使用`read()`方法
使用`readline()`方法
使用`readlines()`…
数据流分词实例
总结词
将数据流分割成独立的词汇或词组,以便进行后续的数据处理和分析。
详细描述
数据流分词是一种常见的预处理技术,用于将数据流中的连续字符或符号分割成独立的词汇或词组。分词算法通 常基于规则、词典和统计方法来实现。通过对数据流进行分词,可以方便地对数据进行后续的处理和分析,如情 感分析、主题建模等。
java 文件与数据流报告
![java 文件与数据流报告](https://img.taocdn.com/s3/m/a702f6036c85ec3a87c2c547.png)
文件与数据流实习报告一文件的性质:(1用来长期保存大量的数据在程序结束后长期(永久)存在,件一般位于外存储设备上(硬盘、光盘、磁带)比较:内存中的变量或数组中的数据是临时性数据,程序结束时就会丢失。
(2)位流:计算机中的数据是以0与1的方式存储在两个装置间存取数据, 以1或0的方式进行,ava将数据在目的地与来源之间的流动抽象化为一个流,即位流。
(3)数据流:数据流是一系列的数据,循环处理每个数据单元,直到遇到结束符或出现异常(Exception)。
二输入输出流:Java中输入输出流主要分为字节流和字符流。
所有字节流都继承java.io.InputStream ,和java.ioOutputStream它们两个都是抽象类。
(1)输入字节流:a 所有字节流都继承java.io.InputStream .b 类InputStream的成员方法read( )读入单个无符号字节(unsigned byte)的数据,并返回一个整数类型(int)的值(与读入的无符号字节数据相对应)正常返回: 介于0和255之间的一个数如果遇到数据流结束,则返回-1c public int read(byte[ ] data) throws IOException 和public int read(byte[ ] data, intoffset, int length) throws IOException的用法。
read(byte[ ] data) t从输入流中读取一定数量的字节,并将其存储在缓冲区数组data 中。
以整数形式返回实际读取的字节数。
在输入数据可用、检测到文件末尾或者抛出异常前,此方法一直阻塞。
如果data 的长度为0,则不读取任何字节并返回0;否则,尝试读取至少一个字节。
如果因为流位于文件末尾而没有可用的字节,则返回值-1;否则,至少读取一个字节并将其存储在data 中。
read(byte[ ] data, int offset, int length)是将长度是从offset开始读length个字节。
第9章输入输出流和文件操作精品PPT课件
![第9章输入输出流和文件操作精品PPT课件](https://img.taocdn.com/s3/m/751bae9b0066f5335b812172.png)
* parent指定目录名,目录名可以是字符串,也可以 是File对象。
9.4.1 文件类File
例如: * = new File("my"); //在当前目录中,以指定文件名创建一个文件对象 * = new File(".",""); //目录也是以文件形式保存的,称为目录文件,创建 一个目录文件对象,表示当前目录 * = new ,"my"); //在dir目录中,以指定文件名创建一个文件对象
文件或目录的路径名由“/“或者“\“分割; * = new File("C:",""); //表示C盘根目录 * = new File("C:/",""); * = new File("C:\\","");
9.4.1 文件类File
2. File类提供的方法
创建一个文件对象后,可以用File类提供的方法来 获得文件的属性信息。
9.1.1 操作系统中的文件和目录概念
1. 文件与文件系统 2. 目录结构与文件检索 3. 文件的逻辑结构
9.1.1 操作系统中的文件和目录概念
4. 文件的存取方法
5. 文件的使用
9.1.2 程序设计语言中的文件类型
1. 文件类型概念
2. 文件与数组的区别
9.1.3 流的概念
1. 流的定义和作用
9.2.3 Java的标准输入/输出
【例9.1】 标准输入/输出.
9.2.4 文件字节输入/输出流类
1. 类
2. 类
9.2.4 文件字节输入/输出流类
第八章数据流和文件
![第八章数据流和文件](https://img.taocdn.com/s3/m/7978f422be1e650e52ea99d8.png)
sw.Close();
8.1.4 案例思考
通过对备忘录功能的代码分析,我们发现在对日志文件进行读写 时,做法都是先构造实例,之后将StreamReader或 StreamWriter关联到这个流上。读者可以尝试修改代码,使之直 接用文件名作为参数构造StreamReader或StreamWriter实例, 并分析修改前后的区别。
fs = new ("Log.txt", , , );
对于,如果要求的模式与文件的现有状态不一致,就会抛出一个异常。 和枚举是按位标志,所以这些值可以与C#的按位OR运算符|合并使用。
流的关闭
使用完一个流后,就应关闭它,如案例中代码:
fs.Close();
关闭流会释放与它相关的资源,允许其他应用程序为同一个文件 设置流。在打开和关闭流之间,可以读写其中的数据,有许多方 法可以进行这样的读写。
、和枚举
构造实例的后三个参数值分别取、和枚举的枚举值。
枚举
值 Append、Create、CreateNew、Open、OpenOrCreate和Truncate Read、ReadWrite和Write Inheritable、None、Read、ReadWrite和Write
示例:构造实例方式
类
要构造实例,需要以下4条信息:
✓ 要访问的文件。 ✓ 表示如何打开文件的模式。例如,创建一个新文件或打开一个现
有的文件。如果打开一个现有的文件写入操作是覆盖文件原来的 内容,还是添加到文件的末尾? ✓ 表示访问文件的方式——是只读、只写,还是读写? ✓ 共享访问——表示是否独占访问文件。如果允许其他流同时访问 文件,则这些流是只读、只写还是读写文件?
第05章 文件与数据流-小结
![第05章 文件与数据流-小结](https://img.taocdn.com/s3/m/2c406327b4daa58da0114a6e.png)
第05章文件与数据流●java语言提供了很多类来处理目录、文件、文件数据,这些类主要位于包“java.io”中。
5.1 输入流与输出流●输入流:外部设备>> 内存InputStream及其子类●输出流:内存>> 外部设备OutputStream及其子类5.1.1 InputStream和FileInputStream●InputStream -处理输入流的类,抽象类例题:第132页例题要点:-control+Z :windows操作系统中流的结束标记public abstract int read() 方法:从输入流读入一个字节,若没有字节可读,则返回-1。
System.in:对应于标准输入,即键盘的输入。
是指向InputStream类型实例的应用。
InputStream类还有其他成员方法:public int available() 返回当前输入流中有效的字节数public int read(byte[] b) 一次读入多个字符,并存放在字节数组b中●FileInputStream -处理文件输入流的类,InputStream的子类对文件内容进行操作的基本步骤:1. 创建文件所对应的实例;public FileInputStream(String name) 构造方法2. 对文件进行读写操作;父类InputStream中继承3. 关闭文件:public void close()5.1.2 OutputStream和FileOutputStream●OutputStream -处理输出流的类,抽象类例题:第138页例题要点:public abstract int write(byte[] b) 方法:输出内容b。
System.out:对应于标准输出,即输出到屏幕。
是指向OutputStream类型实例的应用。
public void flush() 强制立即输出缓存中的数据●FileOutputStream -处理文件输出流的类,OutputStream的子类对文件内容进行操作的基本步骤:1. 创建文件所对应的实例;构造方法:public FileOutputStream(String name)public FileOutputStream(String name,boolean append)2. 对文件进行读写操作;父类InputStream中继承public void write(byte[] b)public void write(byte[] b, int off, int len)public void write(int b)3. 关闭文件:public void close()5.1.3 PrintStream●非常重要的输出流,System.out就是PrintStream的实例的一个引用。
java课实验报告-文件与数据流
![java课实验报告-文件与数据流](https://img.taocdn.com/s3/m/ff0abd00eff9aef8941e0646.png)
文件与数据流一.实验目的:1.掌握输入输出流类的层次关系和类中的方法2.输入输出流类的编程方法二、实验内容:1.从输入或输出流类或子类创建输入或输出流对象.2.利用输入或输出流对象的方法读或写文件。
三.实验内容:1.从键盘上输入10个整数,然后将它们从小到大排序并写入文件c1.txt,然后将文件中的内容读出,输出到屏幕上。
程序如下:import java.io.*;import java.util.Scanner;public class FileIOStream {public static void main(String[] args) throws IOException { int temp = 0;int[] s=new int[10];String str="";Scanner sc = new Scanner(System.in);FileOutputStream out=new FileOutputStream("c1.txt");PrintStream p=new PrintStream(out);System.out.print("请连续输入10个整数:");for(int i =0;i<s.length;i++){s[i]=sc.nextInt();}for(int i=0;i<s.length;i++){str=s[i]+"";}byte b[]=str.getBytes();out.write(b);out.flush();out.close();for (int i = 0; i < s.length-1; i++) {for (int j = 0; j < s.length - i - 1; j++) {if (s[j] > s[j + 1]) {temp = s[j];s[j] = s[j + 1];s[j + 1] = temp;}}}System.out.println("10个数字从小到大排列:");for (int i = 0; i <s.length; i++) {System.out.print(s[i]+",");}}}运行结果:C1.txt文档内容:2.将文件f1.txt的内容加密(加密算法自己设计)后存放到f2.txt中。
9-2 文件和文件流
![9-2 文件和文件流](https://img.taocdn.com/s3/m/d870f627a5e9856a56126055.png)
《9.2 文件和文件流》1. 目标概述[5分钟] (2)2. 回顾[5分钟] (2)3. 课程知识点讲解 (2)3.1. 文件的基本概念[5分钟] (2)3.2. 文件流类与文件流对象[3分钟] (3)3.3. 文件的打开与关闭[20分钟] (3)3.4. 文本文件的读写[20分钟] (5)3.5. 二进制文件的读写[15分钟] (6)3.6. 文件指针[15分钟] (7)3.7. 随机访问二进制文件[15分钟] (7)3.8. 任务解决[30分钟] (8)4. 精练[45分钟] (8)5. 小结[2分钟] (8)6. 技能提升[90分钟] (10)7. 考核点 (11)8. 作业答案 (11)9. 扩展练习 (11)10. 学生问题汇总 (11)11. 教学后记 (12)本节目标⏹本节中将讲述如下主要内容:✧文件的基本知识✧文件流的基本知识✧文件的打开与关闭✧文本文件的读写✧二进制文件的读写✧随机访问二进制文件⏹通过教学使学生掌握文件和文件流的使用。
本节重点⏹文件和文件流的基本知识⏹文件的打开与关闭和读写⏹二进制文件的读写⏹随机访问二进制文件本节难点⏹文件的读写授课课时⏹6课时教法建议1.目标概述 [5分钟]本节主要讲述文件和文件流。
提出本节的任务。
2.回顾 [5分钟]回顾上一节的相关内容。
3.课程知识点讲解3.1.文件的基本概念[5分钟]引入:前面的程序设计中,都是以系统的标准设备进行输入/输出,但这种方式最大的缺点就是无法长久保存数据,实际应用中,通常需要利用磁盘等存储介质,以文件的形式来保存数据。
什么是“文件”(File)?主题:文件是指以一定格式存储在外部存储器(相对于CPU而言)上的数据集合。
这里的“外部存储器”可以是指硬盘、光盘、U盘等各类存储介质,因此可以根据存储介质的不同的将文件分为硬盘文件、光盘文件、U盘文件等。
这里的“一定格式”是指文件存储时的组织方式,通常可分为ASCII码文件与二进制文件两种方式。
java课实验报告-文件与数据流
![java课实验报告-文件与数据流](https://img.taocdn.com/s3/m/ff0abd00eff9aef8941e0646.png)
文件与数据流一.实验目的:1.掌握输入输出流类的层次关系和类中的方法2.输入输出流类的编程方法二、实验内容:1.从输入或输出流类或子类创建输入或输出流对象.2.利用输入或输出流对象的方法读或写文件。
三.实验内容:1.从键盘上输入10个整数,然后将它们从小到大排序并写入文件c1.txt,然后将文件中的内容读出,输出到屏幕上。
程序如下:import java.io.*;import java.util.Scanner;public class FileIOStream {public static void main(String[] args) throws IOException { int temp = 0;int[] s=new int[10];String str="";Scanner sc = new Scanner(System.in);FileOutputStream out=new FileOutputStream("c1.txt");PrintStream p=new PrintStream(out);System.out.print("请连续输入10个整数:");for(int i =0;i<s.length;i++){s[i]=sc.nextInt();}for(int i=0;i<s.length;i++){str=s[i]+"";}byte b[]=str.getBytes();out.write(b);out.flush();out.close();for (int i = 0; i < s.length-1; i++) {for (int j = 0; j < s.length - i - 1; j++) {if (s[j] > s[j + 1]) {temp = s[j];s[j] = s[j + 1];s[j + 1] = temp;}}}System.out.println("10个数字从小到大排列:");for (int i = 0; i <s.length; i++) {System.out.print(s[i]+",");}}}运行结果:C1.txt文档内容:2.将文件f1.txt的内容加密(加密算法自己设计)后存放到f2.txt中。
实验三 文件与数据流 实验报告
![实验三 文件与数据流 实验报告](https://img.taocdn.com/s3/m/95950f060b4e767f5acfceed.png)
实验三文件与数据流实验报告一、实验目的1. 掌握输入输出流类的层次关系和类中的方法及输入输出流的编程方法。
2. 理解对象序列化。
二、实验要求1. 利用InputStream(抽象类)的子类FileInputStream以及BufferedInputStream类对文件进行读入操作。
BufferedInputStream相对于FileInputStream类而言增加了缓存,减少了IO 操作,在一定程序上提升了程序的性能。
同理,利用OutputStream的子类FileOutputStream 和BufferedOutputStream类进行文件的输出操作。
2. 通过DataInputStream和DataOutputStream对象进行基本数据类型的写入文件和从文件读出的操作。
3. 通过ObjectInputStream和ObjectOutputStream可以直接把对象写入到文件或者从文件中读出。
同时,如果要使对象能够通过这个类写入到文件中,这个类需要实现Serializable 接口。
三、实验内容1. 将文件f1.txt的内容加密(字母’A’ 变为’C’,字母’B’ 变为字母‘D’,…,字母‘Z’ 变为’B’)后存放到f2.txt中。
读出f2.txt文件的内容,并显示解密后的内容。
import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;public class FileExperiment00 {public static void main(String[] args) {try {encrypt();decrypt();} catch (Exception e) {e.printStackTrace();}}public static void encrypt() throws Exception {File f1 = new File("f1.txt");File f2 = new File("f2.txt");if (!f1.exists()) {System.out.println("文件不存在");return;}if (!f2.exists()) {f2.createNewFile();}FileInputStream in = new FileInputStream(f1);BufferedInputStream bis = new BufferedInputStream(in);FileOutputStream out = new FileOutputStream(f2);BufferedOutputStream bos = new BufferedOutputStream(out);int b;while ((b = bis.read()) != -1) {bos.write(Encrypt.encrypt((byte) b));}bos.close();bis.close();}public static void decrypt() throws Exception {File file = new File("f2.txt");if (!file.exists()) {System.out.println("文件不存在!");return;}FileInputStream in = new FileInputStream(file);BufferedInputStream bis = new BufferedInputStream(in);byte[] buffer = new byte[2];while (bis.read(buffer) > 0) {buffer[0] = Encrypt.decrypt(buffer[0]);buffer[1] = Encrypt.decrypt(buffer[1]);System.out.print(new String(buffer));}bis.close();}}class Encrypt {public static byte encrypt(byte b) {if ((b >= 65 && b <= 88) || (b >= 97 && b <= 120)) {return (byte) (b + 2);} else if ((b >= 89 && b <= 90) || (b >= 121 && b <= 122)) { return (byte) (b - 24);} else {return b;}}public static byte decrypt(byte b) {if ((b >= 67 && b <= 90) || (b >= 99 && b <= 122)) {return (byte) (b - 2);} else if ((b >= 65 && b <= 66) || (b >= 97 && b <= 98)) { return (byte) (b + 24);} else {return b;}}}2. 从键盘中输入若干个实数(以-999999.999结束),按大小顺序存放到d1.txt,并从该文件中读取数据,在屏幕上显示(每行输出5个数)import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.EOFException;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.util.Arrays;import java.util.LinkedList;import java.util.Scanner;public class FileExperiment01 {public static void main(String[] args) {try {getData();readData();} catch (Exception e) {e.printStackTrace();}}public static void readData() throws Exception {File file = new File("d1.txt");DataInputStream in =new DataInputStream(new FileInputStream(file));double d = 0;while (true) {try {d = in.readDouble();System.out.println(d);} catch (EOFException e) {break;}}in.close();}public static void getData() throws Exception {LinkedList<Double> numbers = new LinkedList<Double>();Scanner s = new Scanner(System.in);while (true) {try {double value = s.nextDouble();if (value == -999999.999) {break;}numbers.add(value);} catch (Exception e) {throw new RuntimeException(e);}}double[] array = new double[numbers.size()];for (int i = 0; i < array.length; i++) {array[i] = numbers.get(i);}Arrays.sort(array); // 系统自带的 sort 方法进行排序DataOutputStream out =new DataOutputStream(new FileOutputStream(new File("d1.txt")));for (double d : array) {out.writeDouble(d);}if (out != null) {out.close();}}}3. 定义一个学生类(成员变量有学号、姓名和成绩),从键盘输入若干学生的信息(学号为’000’结束),并将学生信息存入到文件stu.txt中。
数据流、缓冲区、文件类型、文件存取方式
![数据流、缓冲区、文件类型、文件存取方式](https://img.taocdn.com/s3/m/a5811963a517866fb84ae45c3b3567ec102ddc93.png)
数据流、缓冲区、⽂件类型、⽂件存取⽅式1.1 数据流:指程序与数据的交互是以流的形式进⾏的。
进⾏C语⾔⽂件的存取时(例如从数据库读取内容到txt⽂本,从txt数据读取数据到数据库等),都会先进⾏“打开⽂件”操作,这个操作就是在打开数据流,⽽“关闭⽂件”操作就是关闭数据流。
1.2 缓冲区(Buffer):指在程序执⾏时,所提供的额外内存,可⽤来暂时存放做准备执⾏的数据。
它的设置是为了提⾼存取效率,因为内存的存取速度⽐磁盘驱动器快得多。
因为程序是具有局部性的,包括时间的局部和空间的局部,Cache从内存存取数据时会预取⼀个Cache Line缓存起来,操作系统从硬盘读取数据时会预读⼏个页⾯缓存起来,都是希望这些数据以后会被程序访问到。
⼤多数的程序⾏为都有局部性的特点:它们会花费⼤量的时间反复执⾏⼀⼩段的代码(例如循环),或者反复访问⼀个很⼩的地址范围中的数据(例如数组)。
其实CPU取数据就是这样之⾏的,先从寄存器⾥取值,没有了再从⼀级缓存⾥⾯取值,有⼆级缓存的在从⼆级缓存⾥⾯取值,再从物理内存⾥取数据,最后如果都没有了再从硬盘中去数据。
C语⾔中带缓冲区的⽂件处理:C语⾔的⽂件处理功能依据系统是否设置“缓冲区”分为两种:⼀种是设置缓冲区,另⼀种是不设置缓冲区。
由于不设置缓冲区的⽂件处理⽅式,必须使⽤较低级的I/O函数(包含在头⽂件io.h和fcntl.h中)来直接对磁盘存取,这种⽅式的存取速度慢,并且由于不是C的标准函数,跨平台操作时容易出问题。
下⾯只介绍第⼀种处理⽅式,即设置缓冲区的⽂件处理⽅式:当使⽤标准I/O函数(包含在头⽂件stdio.h中)时,系统会⾃动设置缓冲区,并通过数据流来读写⽂件。
当进⾏⽂件读取时,不会直接对磁盘进⾏读取,⽽是先打开数据流,将磁盘上的⽂件信息拷贝到缓冲区内,然后程序再从缓冲区中读取所需数据,如下图所⽰:事实上,当写⼊⽂件时,并不会马上写⼊磁盘中,⽽是先写⼊缓冲区,只有在缓冲区已满或“关闭⽂件”时,才会将数据写⼊磁盘,如下图所⽰。
第 7章 文件与数据流
![第 7章 文件与数据流](https://img.taocdn.com/s3/m/89f2c543b307e87101f696df.png)
什么是数据流?
• 数据流是一系列的数据
– 例如: System.in、System.out或 System.err 所处理的对象是数据流
• • • • System.in - 标准输入 (从键盘) System.out – 标准输出 (到屏幕) S键盘改为从数据文件)
要有异常机制,处理异常!
2013-7-31 9
方法 read( )
• 下面的两个方法可以一次读入多个字节到数 组中 • java.io.InputStream
public int read(byte[ ] data) throws IOException
public int read(byte[ ] data, int offset, int length) throws
2013-7-31
4
处理数据流的核心思想 • 处理数据流的核心思想
– 能循环处理每个数据单元,直到遇到结束符 或出现异常(Exception)
• 结束符
– 在Unix操作系统下, 键入Control-D表示数据 流的结束 – 在Windows操作系统下, 键入Control-Z表示 数据流的结束
2013-7-31 5
•
• •
• • • •
catch(IOException e) {System.err.print(e);
} }
os.write(buff,0,len);}
}
2013-7-31
14
PrintStream 数据流
• 类 java.io.PrintStream 是类 FilterOutputStream的子类
2013-7-31
20
示例
文件与流操作
![文件与流操作](https://img.taocdn.com/s3/m/8f8690ba65ce050877321309.png)
2013/10/23 金旭亮Java编程系列(2013) 21
流的基类
字节流的两个基类 InputStream和OutputStream:以字节为 单位,是所有字节输入与输出流的父类 字符流的两个基类 Reader和Writer:以字符(2个字节)为单 位
2013/10/23
金旭亮Java编程系列(2013)
2013/10/23
金旭亮Java编程系列(2013)
25
流的相关示例
输入流的示例 1. FileInputStreamTest.java 2. FileReaderTest.java 输出流的示例 1. FileOutputStream.java:通过字节流实现 文件复制 2. FileWriterTest.java:向文件中输入字符。
金旭亮Java编程系列(2013) 28
2013/10/23
流对象链示例
按字符读写文本文件
FileWriter out=new FileWriter(“output.txt”);
相当于
FileWriter out=new FileWriter( new FileOutputStream(“output.txt”))
FileFinder示例重写了SimpleFileVisitor<> 类的visitFile方法,在内部使用 PathMatcher查找所有Java源码文件。
金旭亮Java编程系列(2013) 14
2013/10/23
编程练习
使用Files. walkFileTree()找出指定文件夹下 所有大于指定大小(比如1M)的文件。 使用Files. walkFileTree()找出指定文件夹下 所有扩展名为.txt和.java的文件。 使用Files. walkFileTree()找出指定文件夹下 所有包容指定字符串的txt文件。
C#篇基础知识6——文件和流
![C#篇基础知识6——文件和流](https://img.taocdn.com/s3/m/44ea980fb6360b4c2e3f5727a5e9856a5612267e.png)
C#篇基础知识6——⽂件和流计算机以⽂件的形式把数据存储在磁盘、光盘等存储设备上。
⽂件的管理和操作是操作系统的⼀个重要组成部分,.NET 框架提供了⼀组功能强⼤的类,可以⽅便地对⽂件进⾏操作和管理。
1.⽂件操作相关的类⽤于⽂件操作的类位于System.IO 命名空间中,⽤这些类可以⽅便地对⽂件进⾏创建、读写、复制、删除、移动、打开等操作。
2.File类和FileInfo类命名空间 System.IO 中的File 类⽤于对⽂件进⾏创建、打开、复制、移动、删除、重命名等典型操作,并能获取或设置⽂件的属性信息。
File 类中所有的⽅法都是静态的,使⽤起来⾮常简单,File 类的部分⽅法如下图所⽰:File类的⽅法使⽤起来⾮常⽅便:using System;using System.IO;static void Main(string[] args){ string path = @"D:\test.txt";if(File.Exists(path)) //如果⽂件已经存在,则读取⽂件内容{ //读取⽂件string contents = File.ReadAllText(path);Console.WriteLine("读取⽂件:\n" + contents); }else //如果⽂件不存在,则创建⽂件并写⼊内容{ string contents = "⽆可奈何花落去,\n 似曾相识燕归来,\n ⼩园⾹径独徘徊。
";File.WriteAllText(path, contents); //写⼊⽂件Console.WriteLine("⽂件已写⼊。
" ); }}注意 WriteAllText()、WriteAllLines()和WriteAllBytes()⽅法都会覆盖以前的⽂件,使⽤时要特别⼩⼼。
要想在⽂件尾部追加新⽂本,请使⽤AppendAllText()⽅法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实训项目九:文件与数据流一、实训目的1.理解数据流的概念;2.理解Java流的层次结构;3.理解文件的概念;二、实训要求1.掌握字节流的基本使用方法;2.掌握字符流的基本使用方法;3.能够创建、读写、更新文件;三、实训内容(一)使用标准数据流的应用程序标准数据流指在字符方式下(如DOS 提示符)程序与系统进行输入输出的方式,键盘和显示器屏幕是标准输入输出设备,数据输入的起点为键盘,数据输出的终点是屏幕,输出的数据可以在屏幕上显示出来。
1.程序功能:将键盘上输入的字符在屏幕上显示出来2.编写Stdio_1.java 程序文件,源代码如下。
public class Stdio_1{public static void main(String[] args) throws java.io.IOException {byte buffer[]=new byte[10];System.out.println("从键盘输入不超过10 个字符,按回车键结束输入:");int count =System.in.read(buffer);//读取输入的字符并存放在缓冲区buffer 中System.out.println("保存在缓冲区buffer 中元素的个数为:"+count);System.out.println("buffer 中各元素的值为:");for (int i=0;i<count;i++){System.out.print(" "+ buffer[i]);//在屏幕上显示buffer 元素的值}System.out.println();System.out.println("输出buffer 字符元素:");System.out.write(buffer, 0, buffer.length);}}3.编译、运行Stdio_1.java 文件。
(二)使用文件输入输出流的应用程序1. 程序功能:将保存在本地机当前文件夹中的File1.html 文本文件的内容在屏幕上显示出来,然后将其另存为File2.txt 文件。
2. 编写FileIO_2.java 程序文件,源代码如下import java.io.*;public class FileIO_2 {public static void main(String[] args) throws IOException {FileReader in=new FileReader("File1.html");//建立文件输入流BufferedReader bin=new BufferedReader(in);//建立缓冲输入流FileWriter out=new FileWriter(" File2.txt",true);//建立文件输出流String str;while ((str=bin.readLine())!=null) {//将缓冲区内容通过循环方式逐行赋值给字符串strSystem.out.println(str);//在屏幕上显示字符串strout.write(str+"\n");//将字符串str 通过输出流写入File2.txt 中}in.close();out.close();}}3. 编译、运行程序(三)使用随机文件类的应用程序使用文件输入类FileReader 只能将文件内容全部读入。
如果要选择读入文件的内容,可使用随机文件类RandomAccessFile。
1.程序功能:建立数据流,通过指针有选择的读入文件内容。
2.编写RandomFile.java 程序文件,源代码如下。
import java.io.*;public class RandomFile {public static void main(String args[]) {String str[]={"First line\n","Second line\n","Last line\n"};try {RandomAccessFile rf=new RandomAccessFile("File2.txt", "rw");System.out.println("\n 文件指针位置为:"+rf.getFilePointer());System.out.println("文件的长度为:"+rf.length());rf.seek(rf.length());System.out.println("文件指针现在的位置为:"+rf.getFilePointer());for (int i=0; i<3; i++)rf.writeChars(str[i]); // 字符串转为字节串添加到文件末尾rf.seek(10);System.out.println("\n 选择显示的文件内容:");String s;while ((s=rf.readLine())!=null)System.out.println(s);rf.close();}catch (FileNotFoundException fnoe) {}catch (IOException ioe) {}}}3.编译并运行程序(四)使用数据输入输出流与文件输入输出流类的应用程序使用数据输入流DataOutputStream 和数据输出流DataInputStream 可以读取或写入任何Java 类型的数据,不用关心它们的实际长度是多少字节。
一般与文件输入流FileInputStream 和输出流类FileOutputStream 一起使用。
1.程序功能:将整型数据和字符串对象通过数据输出流写到文件中。
将文件中的整型数据和字符串对象通过数据输出流读出,并在屏幕上显示文件中的内容。
2.编写DataIO.java 程序文件,源代码如下。
import java.io.*;public class DataIO{public static void main(String arg[]){try{ //添加方式创建文件输出流FileOutputStream fout = new FileOutputStream("File4.txt",true);DataOutputStream dout = new DataOutputStream(fout);dout.writeInt(1);dout.writeChars("罗马"+"\n");dout.writeInt(2);dout.writeChars("北京"+"\n");dout.close();}catch (IOException ioe){}System.out.println(“写文件内容完成!”);try{Thread.sleep(3000);}catch(Exception e){}try{FileInputStream fin = new FileInputStream("File4.txt");DataInputStream din = new DataInputStream(fin);int i = din.readInt();while (i!=-1) //输入流未结束时,输入流结束时i 为-1{System.out.print(i+" ");char ch ;while ((ch=din.readChar())!='\n') //字符串未结束时System.out.print(ch);System.out.println();i = din.readInt();}din.close();}catch (IOException ioe){}}}3.编译并运行程序(五)使用对象输入输出流的应用程序使用对象流可以直接写入或读取一个对象。
由于一个类的对象包含多种信息,为了保证从对象流中能够读取到正确的对象,因此要求所有写入对象流的对象都必须是序列化的对象。
一个类如果实现了Serializable 接口,那么这个类的对象就是序列化的对象。
Serializable 接口没有方法,实现该接口的类不需要实现额外的方法。
1.程序功能:保存对象信息到文件,并将文件中的对象信息显示出来。
2.编写Student.java 程序文件,源代码如下。
import java.io.*;public class Student implements Serializable {private String name=null;private String sex=null;private int age=0;public Student(){}public Student(String name,String sex,int age){=name;this.sex=sex;this.age=age;}public String getName() {return name;}public void setName(String name) { = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}void save(String fname)//保存到文件中的方法{try{FileOutputStream fout = new FileOutputStream(fname);//输出文件流ObjectOutputStream out = new ObjectOutputStream(fout);//输出对象流out.writeObject(this); //写入对象out.close();}catch (FileNotFoundException fe){}catch (IOException ioe){}}void display(String fname)//显示文件中对象信息的方法{try{FileInputStream fin = new FileInputStream(fname);//输入文件流ObjectInputStream in = new ObjectInputStream(fin);//输入对象流Student OO = (Student)in.readObject(); //读取对象System.out.println(" 类名:"+OO.getClass().getName()+""+OO.getClass().getInterfaces()[0]);System.out.println(" "+OO.getName()+" "+OO.getSex()+""+OO.getAge());in.close();}catch (FileNotFoundException fe){}catch (IOException ioe){}catch (ClassNotFoundException ioe) {}}public static void main(String[] args){String fname="Student.obj";Student stu=new Student("张三","男",19);stu.save(fname);stu.display(fname);//下面请自己编写代码查看该文件的内容,即以文本方式显示出文件内容}}(六)使用File对象的应用程序File对象能完成操作系统下的文件和目录的操作,实现了文件和目录的属性查看和目录文件的创建、读写、更新。