实验八+输入输出流类及文件的读写

合集下载

程序设计原理输入输出流与文件操作

有格式读写，以某种数据类型为单位读写
例如：读一个整数，写一个浮点数等；
无格式读写，以字节为单位读写，不区分其中的内容
例如：读20个字节，写50个字节等；
程序设计原理输入输出流和文件操作
缓冲区刷新
向输出流中写数据时，通常是先向缓冲区中写，当缓冲区写满时，才真正向输出流写；也可以通过函数在程序中主动将缓冲区内容写入输出流。
程序设计原理输入输出流和文件操作
输出流
用成员函数put输出字符 cout .put(‘A’);
put的连续使用 cout .put(‘A’).put(‘a’);
程序设计原理输入输出流和文件操作
输入流
读取运算的返回值重载>>运算符的定义:
istream &operator >>(istream &input, A & a){ ……. return input;
作算子，调用方式不同： cin >> setw(5); 或者 cin.width(5); cout << setw(5); 或者 cout.width(5);
程序设计原理输入输出流和文件操作
设置域宽的流操纵算子
设置域宽(setw,width) 例：int w = 4;
char string[10]; cin.width(5); while(cin >> string){
程序设计原理输入输出流和文件操作
流操纵算子
整数流的基数：流操纵算子dec,oct,hex,setbase 浮点数的精度（precision,setprecision）设置域宽(setw,width) 用户自定义的流操纵算子使用流操纵算子需要 #include <iomanip>

java输入输出流实验报告总结

java输入输出流实验报告总结Java输入输出流是Java中非常重要的概念，也是Java程序设计的基础。

在Java 程序中，输入输出流用于处理与设备之间的数据传输，例如键盘、鼠标、文件等。

Java的输入输出流主要包含两种类型：字节流和字符流。

字节流以字节为最小读写单位，而字符流以字符为最小读写单位。

Java的输入流有很多种类型，例如：InputStream、ByteArrayInputStream、FileInputStream等。

这些输入流的共同特点是读取外部数据到程序中。

Java的输出流也有多种类型，例如：OutputStream、ByteArrayOutputStream、FileOutputStream等。

这些输出流的共同特点是将程序中的数据输出到外部。

下面将以实验报告的形式进行总结，详细介绍Java输入输出流的原理和使用方法。

实验一：字节流输入输出1. 实验目的：掌握字节流输入输出的基本使用方法。

2. 实验内容：编写一个程序，实现从文件中读取数据，然后将数据输出到另一个文件中。

3. 实验步骤：a. 创建一个输入流对象，用于读取原始文件的数据。

b. 创建一个输出流对象，用于将读取到的数据输出到目标文件中。

c. 循环读取输入流中的数据，直到读取到文件末尾。

d. 将读取到的数据写入输出流中。

e. 关闭输入流和输出流。

4. 实验结果：成功读取原始文件中的数据，并将数据输出到目标文件中。

实验二：字符流输入输出1. 实验目的：掌握字符流输入输出的基本使用方法。

2. 实验内容：编写一个程序，实现从键盘输入文字，然后将文字输出到屏幕上。

3. 实验步骤：a. 创建一个字符输入流对象，用于读取键盘输入的文字。

b. 创建一个字符输出流对象，用于将读取到的文字输出到屏幕上。

c. 循环读取输入流中的文字，直到读取到换行符。

d. 将读取到的文字写入输出流中。

e. 关闭输入流和输出流。

4. 实验结果：成功从键盘输入文字，并将文字输出到屏幕上。

Java 输入输出流及文件读写详解

I/O类体系在JDK API中，基础的IO类都位于java.io包，而新实现的IO类则位于一系列以java.nio开头的包名中，这里首先介绍java.io包中类的体系结构。

按照前面的说明，流是有方向的，则整个流的结构按照流的方向可以划分为两类：1、输入流：该类流将外部数据源的数据转换为流，程序通过读取该类流中的数据，完成对于外部数据源中数据的读入。

2、输出流：该类流完成将流中的数据转换到对应的数据源中，程序通过向该类流中写入数据，完成将数据写入到对应的外部数据源中。

而在实际实现时，由于JDK API历史的原因，在java.io包中又实现了两类流：字节流(byte stream)和字符流(char stream)。

这两种流实现的是流中数据序列的单位，在字节流中，数据序列以byte为单位，也就是流中的数据按照一个byte一个byte的顺序实现成流，对于该类流操作的基本单位是一个byte，而对于字节流，数据序列以char为单位，也就是流中的数据按照一个char一个插入的顺序实现成流，对于该类流操作的基本单位是一个char。

另外字节流是从JDK1.0开始加入到API中的，而字符流则是从JDK1.1开始才加入到API中的，对于现在使用的JDK版本来说，这两类流都包含在API的内部。

在实际使用时，字符流的效率要比字节流高一些。

在实际使用时，字符流中的类基本上和字节流中的类对应，所以在开始学习IO类时，可以从最基础的字节流开始学习。

在SUN设计JDK的IO类时，按照以上的分类，为每个系列的类设计了一个父类，而实现具体操作的类都作为该系列类的子类，则IO类设计时的四个体系中每个体系中对应的父类分别是：字节输入流InputStream该类是IO编程中所有字节输入流的父类，熟悉该类的使用将对使用字节输入流产生很大的帮助，下面做一下详细的介绍。

按照前面介绍的流的概念，字节输入流完成的是按照字节形式构造读取数据的输入流的结构，每个该类的对象就是一个实际的输入流，在构造时由API完成将外部数据源转换为流对象的操作，这种转换对程序员来说是透明的。

C中的文件操作和输入输出流

C中的文件操作和输入输出流C语言是一种低级语言，对于文件的操作和输入输出流的处理是其重要的特性之一。

通过文件操作和输入输出流，我们可以读取外部文件的内容、将程序的输出保存到文件中，同时还可以创建、编辑和删除文件。

本文将介绍C语言中的文件操作和输入输出流，帮助读者更好地理解和运用这些功能。

一、文件操作文件操作是指对计算机硬盘中的文件进行读写、创建和删除的操作。

C语言提供了一系列的函数和方法，方便程序员进行文件的操作。

下面是几个常用的文件操作函数：1. fopen()函数：用于打开文件。

该函数接受两个参数，第一个参数是文件名，第二个参数是打开方式（例如，读取、写入、追加等）。

成功打开文件后，该函数会返回一个指向该文件的指针。

2. fclose()函数：用于关闭文件。

当我们不再需要使用打开的文件时，应该使用该函数关闭文件。

关闭文件可以释放系统资源，避免造成内存泄漏。

3. fread()函数：用于读取文件内容。

该函数接受四个参数，分别是指向数据的指针、每个数据的大小、要读取的数据量以及文件指针。

这样我们可以通过该函数从文件中读取指定数量的数据，并存储到指定的内存地址中。

4. fwrite()函数：用于向文件中写入内容。

该函数接受四个参数，分别是指向数据的指针、每个数据的大小、要写入的数据量以及文件指针。

通过该函数，我们可以将指定数量的数据写入到文件中。

5. fseek()函数：用于设置文件指针的位置。

该函数接受三个参数，分别是文件指针、偏移量以及起始位置。

通过使用该函数，我们可以控制文件指针的位置，实现文件的跳转和定位。

二、输入输出流输入输出流是C语言中用于处理文件读写的一种机制。

通过输入输出流，我们可以将程序的输入和输出连接到文件中，实现对文件的读写操作。

C语言中提供了标准输入输出流，分别对应于键盘输入和屏幕输出。

1. 标准输入流（stdin）：标准输入流用于接收用户的输入，通常使用scanf()函数来读取输入的内容。

Java的输入与输出流(实验报告)

成都大学实验报告实验项目名称Java的输入与输出流一、实验目的：1. 理解I/O流的概念，掌握其分类2. 掌握文本文件读写、二进制文件读写二、实验内容（包括源程序及相关说明）：1. 分别使用FileWriter 和BufferedWriter 往文件中写入10万个随机数，比较用时。

源代码如下：（1）import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{long t=System.currentTimeMillis();FileWriter fw =new FileWriter("d:\\Ex1.txt");for(int i=1;i<=100000;i++){fw.write((int)(Math.random()*10000)+" \n");}fw.close();t=System.currentTimeMillis()-t;System.out.println("The elapsed: "+t);}}（2）import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{long t=System.currentTimeMillis();BufferedWriter fw=new BufferedWriter(new FileWriter("d:\\Ex1.txt"));for(int i=1;i<=100000;i++){fw.write((int)(Math.random()*10000)+"\n");}fw.close();t=System.currentTimeMillis()-t;System.out.println("The elapsed: "+t);}}2. 生成一个html文件，使其能显示2的幂次(0~9)的表格如下：代码如下：import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\Ex2.html"));bw.write("<table border=1 align=center width=200 height=250>");bw.newLine();bw.write("<tr><td align=center>Power of 2<td align=center>Value</tr>");for(int i=0;i<=9;i++){bw.write("<tr><td align=center>"+i+"<td align=center>"+Math.pow(i, 2)+"</tr>");}bw.write("</table>");bw.newLine();bw.close();}}3. 在文本文件bigbook.txt中包含有很长篇幅的英语短文，编写程序要求统计文件的所有短文中包含英文字母“A”的个数，并显示统计的时间。

C++实验报告流类库与输入输出

C++实验报告流类库与输入/输出实验八流类库与输入/输出（2学时）一.实验目的：1.熟悉流类库中常用的类及其成员函数使用方法;2.学习标准输入输出及格式控制;3.学习对文件的应用方法(二进制文件,文本文件)二.实验内容与步骤:1.实验题目：(2)：编写程序,用二进制方式打开指定的一个文件,在每一行前加行号.(提示:使用void main(int argc,char*argv[])函数中的参数传递操作的文件名,定义ofstream的对象对文件进行操作.使用getline成员函数读入数据,使用cout输出字符到文件.)2.程序清单：#include<fstream>#include<strstream>#include<cstdlib>using namespace std;void main(){strstream file;ifstream in("f1.txt",ios::binary);file<<in.rdbuf();ofstream out("f1.txt",ios::binary);const int s=255;char l[s];for(int i=1;file.getline(l,s);i++)out<<i<<"."<<l<<endl; }3.测试结果如下:三.实验小结:1,重要的输出流:ostream,ofstream,ostringstream;2,重要的输入流:istream,ifstream,istringstream.。

C语言中的文件操作与输入输出流

C语言中的文件操作与输入输出流文件处理是程序设计中常见的操作之一，而在C语言中，文件操作函数和输入输出流是实现文件处理的主要手段。

本文将介绍C语言中文件操作与输入输出流的基本概念、函数和使用方法。

一、文件操作概述在C语言中，文件被看作是一系列按顺序排列的字节。

文件的打开、读取、写入和关闭都是通过相应的函数来实现的。

C语言提供了一系列的文件操作函数，其中最常用的包括：文件打开函数（fopen）、文件关闭函数（fclose）、文件读取函数（fread）、文件写入函数（fwrite）和文件定位函数（fseek）等。

二、文件打开与关闭文件的打开和关闭是文件操作的基础。

通过文件打开函数（fopen），我们可以打开一个指定的文件，并返回一个文件指针，以便后续对文件的读取和写入操作。

文件关闭函数（fclose）则用于关闭一个已打开的文件。

例如，下面的代码演示了如何打开和关闭一个文件：```c#include <stdio.h>int main() {FILE *file = fopen("example.txt", "r");if (file == NULL) {printf("文件打开失败\n");return 1;}// 对文件的读取和写入操作fclose(file);return 0;}```三、文件读取与写入文件读取与写入是文件操作中常用的功能。

C语言提供了一系列的文件读取函数和文件写入函数，可以根据不同的需求调用适当的函数来完成操作。

常用的文件读取函数包括：getchar（从标准输入读取一个字符）、fgetc（从指定文件读取一个字符）、fgets（从指定文件读取一行字符串）、fscanf（从指定文件读取格式化数据）等。

常用的文件写入函数包括：putchar（向标准输出写入一个字符）、fputc（向指定文件写入一个字符）、fputs（向指定文件写入一行字符串）、fprintf（向指定文件写入格式化数据）等。

C语言中的文件操作与输入输出流处理

C语言中的文件操作与输入输出流处理C语言是一种广泛使用的编程语言，而文件操作与输入输出流处理是C语言中非常重要的一部分。

在C语言中，我们可以通过文件操作来读取和写入文件，以及对文件进行各种处理。

同时，输入输出流处理也可以让我们方便地与外部文件进行交互，实现数据的输入输出。

在C语言中，文件操作主要涉及到文件的打开、关闭、读取和写入等操作。

下面我们来具体了解一下C语言中文件操作的一些常用函数：1. fopen函数：用于打开一个文件，语法为：FILE *fopen(const char *filename, const char *mode)；其中，filename为文件名，mode为打开文件的模式，有"r"（只读）、"w"（写）、"a"（追加）等不同模式。

2. fclose函数：用于关闭一个打开的文件，语法为：int fclose(FILE *stream)；其中，stream为打开文件所返回的指针。

3. fgetc和fputc函数：分别用于读取和写入单个字符，语法为：int fgetc(FILE *stream)和int fputc(int c, FILE *stream)。

4. fgets和fputs函数：分别用于读取和写入一行字符，语法为：char *fgets(char *str, int n, FILE *stream)和int fputs(const char *str, FILE *stream)。

5. fprintf函数：用于向文件中格式化输出数据，语法为：int fprintf(FILE*stream, const char *format, ...)；其中，format为输出格式。

C语言中的输入输出流处理则是通过标准输入输出流来实现的。

通过标准输入输出流，我们可以方便地进行终端输入输出，或与外部文件进行数据交互。

下面是C语言中一些常用的输入输出流处理函数：1. scanf函数：用于从终端输入数据，语法为：int scanf(const char *format, ...)；其中，format为输入格式。

输入输出流及文件操作

第六章输入输出流及文件操作在Java中，应用程序所需要读入的数据和写出的数据是通过I/O操作实现的为进行数据的输入、输出操作，java中把不同的输入、输出源(键盘，文件等)抽象表述为“流”(stream)Java中的输入输出流可以分为两大类：输入流和输出流输入流：只能从中读取字节数据，而不能向其写出数据输出流：只能向其写入字节数据，而不能从中读取数据Java.io包提供了处理各种类型的流：文件流，字节流，字符流等java语言提供3种自动生成的标准流。

System.out是标准输出流System.in是标准输入流System.err是标准异常流在使用输入输出流时，我们需要根据数据格式、操作对象、随机访问能力等因素，来决定选择那种流来实现功能字节流是用来针对ISO的8位字节的读和写。

java字节I/O流的层次。

FileInputStream：一次读取一个字节。

PipedInputStream:大批量读取。

字节I/O流java字节流继承层次字节输入流所有的字节输入流，都是InputStream的子类，InputStream类包含的主要方法有：字节输入流一般来说，字节输入流的数据通常来自二进制文件，所以FileInputStream 通常作为字节输入流的操作类。

例：从文件中读取数据。

import java.io.FileInputStream;public class FileInputStreamTest {public static void main(String argv[]){//构建一个字节流对象，对象要对应文件名try {FileInputStream fin=newFileInputStream("C:/message.txt");//读取文件中含有多少个字节System.out.println(fin.available());byte b[]=new byte[50];//跳过文件中前两个字节fin.skip(2);//把文件中读取的字节放在数组b中fin.read(b);//将数组中b中的内容输出System.out.println(new String(b));fin.close();} catch (Exception e) {e.printStackTrace();}System.out.println();}}所有的字节输出流，都是OutputStream的子类，OutputStream类包含的主要方法有：import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/*** 文件拷贝* 步骤1：把文件读取到输入流中* 步骤2：输入流存入byte数组中*步骤3：建立一个输出流*步骤4：把数组中的信息一次写入输入流*/public class CopeOutputStream {public static void main(String[] args) throws IOException {FileInputStream fin;try {fin = new FileInputStream("C:/message.txt");byte[] b=new byte[fin.available()];fin.read(b);FileOutputStream fon=new FileOutputStream("c:/message1.txt");fon.write(b);fin.close();fon.close();} catch (FileNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}上例中，把图片的数据一次性读入内存，这是很危险的。

输入输出流实验报告

输入输出流实验报告1.编写一个应用程序，读取一个文本文件的内容。

源程序：Work9_1.javaimport java.io.*;public class Work9_1{public static void main(String args[ ]){File readFile=new File("Student.txt"),writeFile=new File("Hello.txt");try{ FileReader inOne=new FileReader("Student.txt");BufferedReader inTwo= new BufferedReader(inOne);FileWriter tofile=new FileWriter("hello.txt");BufferedWriter out= new BufferedWriter(tofile);String s=null;int i=0;while((s=inTwo.readLine())!=null){i++;out.write(s);out.newLine();}out.flush();out.close();tofile.close();inOne=new FileReader("hello.txt");inTwo= new BufferedReader(inOne);while((s=inTwo.readLine())!=null){System.out.println(s);}inOne.close();inTwo.close();}catch(IOException e){System.out.println(e);}}}所读取的文本文件截图：运行界面：2.编写一个应用程序，将用户从键盘输入的10行文字存入文件。

输入输出流和文件

——I/O异常
IO异常
输
– 多数IO方法在遇到错误时会抛出异常，
入
因此调用这些方法时必须
输
出
在方法头声明抛出IOException异常
流
或者在try块中执行IO，然后捕获
IOException
/
24
6.2 文件读写
写文本文件读文本文件写二进制文件读二进制文件 File类处理压缩文件对象序列化随机文件读写
– 通过调用close方法，可以显式关闭任何一个流，
如果流对象不再被引用，Java的垃圾回收机制
也会隐式地关闭它
/
3
6.1.1 I/O流的概念(续)
输入流
– 为了从信息源获取信息，程序打开一个输入流，程序可
输
从输入流读取信息
入
输出流输出流
– 当程序需要向目标位置写信息时，便需要打开一个输出流，程序通过输出流向这个目标位置写信息
输
System.in： InputStream类型的，代表标准
出
输入流，这个流是已经打开了的，默认状态
流
对应于键盘输入。
System.out：PrintStream类型的，代表标准输出流，默认状态对应于屏幕输出
System.err：PrintStream类型的，代表标准错误信息输出流，默认状态对应于屏幕输出
}
}
21
6.1.2 预定义的I/O流类概述(续)
——处理流
/
处理流
输
– 不直接与数据源或目标相连，而是基于另一个
入
流来构造
输
出
– 从流读写数据的同时对数据进行处理
流
– 例6-1中的InputStreamReader和BufferedReader都属

java输入输出流实验报告总结】

java输入输出流实验报告总结】Java输入输出流实验报告总结在本次实验中，我们学习了Java的输入输出流的概念和用法。

输入输出流是Java中用于处理输入和输出操作的工具。

通过输入流，我们可以将外部数据输入到程序中进行处理，通过输出流，我们可以将程序中的数据输出到外部文件或设备上。

在本次实验中，我们通过几个具体的示例来探索输入输出流的不同用法和特性，以期更好地理解和掌握它们的使用。

首先，我们学习了如何使用FileInputStream和FileOutputStream这两个类来进行字节流的输入和输出操作。

这两个类分别用于从指定文件中读取字节数据和将字节数据写入到指定文件中。

通过这两个类，我们可以实现文件的拷贝、移动、创建等功能。

同时，我们还了解了如何使用BufferedInputStream和BufferedOutputStream这两个类来提高读写效率。

这两个类可以通过缓存数据来减少对底层系统的IO操作次数，从而提高读写速度。

接下来，我们学习了如何使用FileReader和FileWriter这两个类进行字符流的输入和输出操作。

这两个类与字节流的输入输出类似，但它们处理的是字符数据。

通过这两个类，我们可以读取和写入文本文件中的字符数据。

我们还了解了字符编码和字符集的概念，并学习了如何使用InputStreamReader和OutputStreamWriter来进行字符流和字节流之间的转换。

除了字节流和字符流，我们还学习了对象流的使用。

对象流可以将Java 对象直接写入到文件中，也可以从文件中读取Java对象。

这在处理一些复杂的对象数据时非常有用。

我们通过使用ObjectInputStream和ObjectOutputStream这两个类，实现了对象的读写操作。

需要注意的是，被写入和读取的对象必须实现Serializable接口，否则会抛出NotSerializableException异常。

在实验过程中，我们还探索了如何使用标准输入输出流。

实验八-输入输出流

实验八输入输出流1.实验目的1、掌握字符输入、输出流的用法2、掌握使用Scanner类解析文件3、掌握Console流的使用2.实验内容1、根据附录里的源代码，按照注释要求，完成代码填空，使程序能够运行得出结果。

1) 实验1举重成绩单2) 实验2统计英文单词3) 实验3密码流4) 实验4学读汉字5）实验5 读取Zip文件2、设计编写程序完成以下任务。

1）修改实验2，要求按字典顺序输出全部不相同的单词。

2）参考实验3编写一个程序，程序运行时，要求用户输入的密码是：hello。

如果用户输入了正确的密码。

程序将输出“你好，欢迎你！”。

程序允许用户2次输入的密码不正确，一旦超过2次，程序将立刻退出。

3）在本机的磁盘系统中，找一个文件夹，利用File类的提供方法，列出该文件夹中的所有文件的文件名和文件的路径，执行效果如下：路径是xxx的文件夹内的文件有：文件名：abc.txt路径名：c:\temp\abc.txt--------------------------------------------文件名：def.txt路径名：c:\temp\def.txt知识点：File管理4）使用java的输入输出流将一个文本文件的内容读出并在控制台将文件中的内容打印出来。

（参考书上Ｐ184页）5）从控制台输入一串字符串，将该串字符串写入到磁盘某位置上的out.txt文件中去。

（参考教材Ｐ183页）6）使用java的输入输出流将一个文本文件的内容按行读取，每读一行就顺序添加行号，并写入到另一个文件中.7）定义一个Person类，包含姓名、年龄、身份证号码属性。

有一个带参数的构造方法用于对所有属性赋值，还有一个study的方法，里面只打印一条“我喜欢学习”的话。

写一个Test类，里面实例化若干个Person对象，并将这些对象写入到obj.txt文件中去。

8）创建c:/test.txt文件并在其中输入"hello world"创建一个输入流读取该文件中的文本并且把小写的l变成大写L再利用输出流写入到d:\test.txt中实现步骤：（1）在本地硬盘C盘下创建一个文件test.txt（2）创建一个包含main()方法的类，并在main中编写代码（3）运行代码并且测试结果实现过滤器的功能效果显示：知识点：IO字符流、String常用方法3.实验步骤略4.评分标准1.A——内容功能完善，编程风格好，人机接口界面好；2.B——内容功能完善，编程风格良好，人机接口界面良好；3.C——完成必做内容；4.D——能完成必做内容；5.E——未按时完成必做内容，或者抄袭（雷同者全部为E）.参照书上实验按模版要求，将【代码】替换为Java程序代码，编写好完整的程序文档，最后运行得到的相关文件，把实验所得文件一起打包上交。

输入输出流、文件及数据库操作

第十二章输入输出流、文件及数据库在前边的实验中，已经看到了图像文件的读取，本章将对磁盘文件进行读写处理。

了解Java中输入输出流、文件的基本概念，掌握Java中文件的基本应用。

12.1 实验一：输入输出流的应用实验目的(1). 了解Java中输入输出流及文件的基本概念和功能。

(2). 使用字节、字符流读写文件，基本掌握磁盘文件的创建及读写处理的方法步骤和技巧。

实验要求编写应用程序，熟悉Java中文件的基本操作，并完善前边的实验示例。

实验内容实验示例12.1.1 创建一个文件操作类，具有创建新文件、存储文件和复制文件的功能。

实现该示例的步骤如下：⑴简要分析⑵根据上述简要分析，可以给出如下参考程序代码(FileOperator.java)：import java.io.*;import javax.swing.*;public class FileOperator{/***建立文件***/public boolean create(String fileName){try{FileOutputStream file=new FileOutputStream(fileName);//创建文件输出流对象 file.close(); //关闭文件流return true;}catch(IOException e){JOptionPane.showMessageDialog(null,e.toString(),"出现错误",0);return false;}}public boolean save(String fileName,String str){try{FileWriter file=new FileWriter(fileName);file.write(str); //将字符串的内容写入输出流file.close(); //关闭输出流return true;}catch(IOException e){JOptionPane.showMessageDialog(null,e.toString(),"出现错误",0);return false;}}/***复制文件方法***/public boolean copy(String fileName1,String fileName2){byte [] data=new byte[8192]; //定义字节数组大小int n=0;try{FileInputStream file1=new FileInputStream(fileName1);//创建文件输入流对象 FileOutputStream file2=new FileOutputStream(fileName2);//创建文件输出流 while((n=file1.available())>0) //当文件中还有字节可读时{file1.read(data); //将文件的内容读入字节数组if(n>=8192) { file2.write(data); } //若文件没读完,将读取的整个数组内容写入 else { file2.write(data,0,n); } //将最后的n个字节写入}file2.close(); //关闭文件输出流file1.close(); //关闭文件输入流}catch (FileNotFoundException e1){int m=JOptionPane.showConfirmDialog(null,fileName1+"文件不存在!重新选择文件吗?","出现错误...",0,1);if(m==0){ fileName1=JOptionPane.showInputDialog("请输入文件名");copy(fileName1,fileName2);}}catch (IOException e){JOptionPane.showMessageDialog(null,e.toString(),"出现错误",0);return false;}return true;} //复制文件方法结束}⑶编译FileOperator.java程序，生成FileOperator.class类文件，以供其他应用程序所用。

文件输入输出流

从程序的角度来确定输入输出
输出流：写文件ofstream
(1)创建文件对象,与具体文件建立关联
ofstream fout; fout.open(“test.txt”); (2)进行写文件操作 int i=10; fout<<i; (3)关闭文件 fout.close();
ofstream fout ("test.txt");
文件打开模式
打开模式 ios::out ios::in ios::ate ios::app ios::trunc ios::nocreate ios::replace ios::binary
含义打开以进行写入打开以进行读取在打开时查找到文件结尾追加到文件结尾如果文件存在则删除如果文件不存在则打开失败如果文件已存在则打开失败打开一个二进制文件
打开一个文件并删除所有内容 ofstream fout("TEST.TXT"); ofstream fout("TEST.TXT",ios::out); ofstream fout("TEST.TXT",ios::out|ios::trunc);
打开一个文件并追加内容 ofstream fout("TEST.TXT",ios::app);
读写操作文本文件：使用<<，>>运算符二进制文件：用函数成员 get、put、read、write等
关闭文件：使用成员函数close，如：fout.close();
打开一个文件进行二进制输出 ofstream fout("TEST.TXT",ios::binary);
检查打开是否成功 if(fout){...}或

JAVA输入输出流和文件操作

JAVA输入输出流和文件操作
1、JAVA输入输出流
Java的输入/输出流机制是Java中最基本的控制机制，它是把Java 程序和外部文件和网络服务之间建立的数据传输通道，是Java程序访问来自外部资源的基本手段。

Java的输入/输出流机制是Java中最基本的控制机制，它是把Java 程序和外部文件和网络服务之间建立的数据传输通道，是Java程序访问来自外部资源的基本手段。

Java的输入/输出流机制是将不同的数据源统一到同一结构，从而使Java程序与各种外部资源（文件、网络服务）之间可以进行输入/输出操作。

普通的Java程序可以使用这些IO流来读取和写入文件，从而实现文件的操作。

Java的输入/输出流系统分为字节流和字符流两种。

字节流是用来处理二进制数据流的，可以用来处理原始数据流；而字符流是用来处理字符流的，可以用来处理文本文件。

2、JAVA文件操作
文件是操作系统中用来存储信息的基本单位，在JAVA编程中，我们使用File来操作文件，File类是java.io包中的类，它是为了访问底层操作系统提供的文件和目录的操作方法。

File类可以用来操作一些文件系统相关的信息，比如：文件名、文件大小、文件是否存在等等，我们可以使用File类来实现文件的创建、删除、复制、移动等操作。

另外，如果要实现文件的读写操作。

输入输出流

输入输出流西安邮电大学（计算机学院）课内实验报告实验名称：输入输出流专业名称：网络工程班级：学生姓名：学号（8位）：指导教师：实验日期：2014年5月29日一. 实验目的及实验环境1. 理解I/O流的概念，掌握其分类2. 掌握文本文件读写、二进制文件读写二. 实验内容1.编写程序，接受用户从键盘输入的一个文件名，然后判断判断该文件是否存在于当前目录。

若存在，则继续输出：文件是否可读可写、文件的大小、文件是一个普通文件还是目录。

2. 编程完成文件复制功能，用命令行方式提供源文件名和目标文件名。

3. 编写一个程序，从键盘输入5个学生的信息（包含学号、姓名、3科成绩），统计各生的总分，然后将学生信息和统计结果分别存入二进制数据文件STUDENT.DA T和文本文件STUDENT.txt中。

并从文件中读取数据，按学生的总分递减排序后，显示前3个学生的学号、姓名和总分。

三．方案设计1.判断文件是否存在，若存在，判断文件是否可读可写，文件是一个普通文件还是目录；若是普通文件，输出文件大小。

2. try{ //读文件BufferedInputStream f1_in=new BufferedInputStream(new FileInputStream(f1)) ;byte[] f1byte=new byte[100];String f1str;int len;while((len=f1_in.read(f1byte))>0){f1str=new String(f1byte,0,len);fstr=fstr+f1str;}f1_in.close();//写文件BufferedOutputStream f2_out=new BufferedOutputStream(new FileOutputStream(f2));f2_out.write(fstr.getBytes(),0,fstr.getBytes().length);f2_out.flush();f2_out.close();}catch(FileNotFoundException fnfe){fnfe.printStackTrace();}catch(IOException ioe){ioe.printStackTrace();}catch(Exception e){e.printStackTrace();}3. for(int i=1; i <= NUM; i++){student=new Student();System.out.println("请输入第" + i + "个学生学号：");student.setNum(scanner.nextInt());System.out.println("请输入第" + i + "个学生姓名：");student.setName(scanner.next());System.out.println("请输入第" + i + "个学生语文成绩：");student.setChineseScore1(scanner.nextFloat());System.out.println("请输入第" + i + "个学生数学成绩：");student.setMathScore2(scanner.nextFloat());System.out.println("请输入第" + i + "个学生英语成绩：");student.setEnglishScore3(scanner.nextFloat());student.setSum(student.getChineseScore1() + student.getMathScore2() + student.getEnglishScore3());dos.writeInt(student.getNum());dos.writeUTF(student.getName());dos.writeFloat(student.getChineseScore1());dos.writeFloat(student.getMathScore2());dos.writeFloat(student.getEnglishScore3());dos.writeFloat(student.getSum());}}catch(Exception e){e.printStackTrace();}}四．测试数据及运行结果1．测试结果如下：2．测试结果如下：3.测试结果如下：五．总结本次实验我们学习了常用I/O流及文件处理方法，File类是对本地文件系统中某个文件或者目录的路径名的一个平台无关的表示，实验可以从控制台输入也可以直接输入，主要是路径要写完整，还有直接在程序中输入时路径要写成如：“D:\\A\\B.txt”形式，不然会报错。

java输入输出流试验

java输入输出流试验输入输出流一、实验目的：熟悉java的文件读写机制，练习输入输出流的使用。

二、实验内容：1.在键盘上输入10个整数，从小到大排序。

2、接收键盘输入的字符串，用fileinputstream类将字符串写入文件，用fileoutputstream类读出文件内容显示在屏幕上。

3.逐行读出文本文件的内容，为读出的每一行添加行号，然后将其写入另一个文件。

3、测试要求：1.通过实验掌握文件输入输出流的使用方法；2.程序必须能够从键盘接收字符串并保存在文件中；3.程序必须能够读出文件内容显示在屏幕上；4.写出实验报告。

四、实验步骤：1.在键盘上输入10个整数，从小到大排序。

包装测试；importjava.io.bufferedreader;importjava.io.ioexception;importjava.io.inputstre amreader;publicclassgui_21{publicstaticvoidmain(string[]args)throwsioexception{//TODOAUATO生成MethodSubbufferedReaderbr=newbufferedreader（newstringstr；intarray[]=newint[10];for(inti=0;i<10;i++){系统出来Println（\请输入一个整数：\）；str=br。

readline（）；array[i]=integer.parseint(str);inputstreamreader（system.in））；}}}对于（intj=0；j<9；j++）{for(intm=0;m<10;m++){}如果（m！=9）system.out.print(array[m]+\);system.out.print(array[m]);else对于（intk=j+1；k<10；k++）{if(array[k]inttemp=数组[k]；数组[k]=数组[j]；数组[j]=temp；}2、接收键盘输入的字符串，用fileinputstream类将字符串写入文件，用fileoutputstream类读出文件内容显示在屏幕上。

实验8输入输出流

实验八输入输出流【目的】①掌握字符输入、输出流的用法；②掌握RandomAccessFil类的使用；【内容】1．学读汉字。

✧实验要求：编写一个Java应用程序，要求如下：（1）可以将一个由汉字字符组成的文本文件读入到程序中；（2）单击名为“下一个汉字”的按钮，可以在一个标签中显示程序读入的一个汉字；（3）单击名为“发音”的按钮，可以听到标签上显示的汉字的读音。

（4）用户可以使用文本编辑器编辑程序中用到的3个由汉字字符组成的文本文件：training1.txt、training2.txt和training.txt，这些文本文件中的汉字需要用空格、逗号或回车分隔。

（）需要自己制作相应的声音文件，比如：training1.txt文件包含汉字“你”，那么在当前应用程序的运行目录中需要有“你.wav”格式的声音文件。

（）用户选择“帮助”菜单，可以查看软件的帮助信息。

✧程序运行效果示例：程序运行效果如下图所示：✧程序模板：ChineseCharacters.javaimport java.io.*;import java.util.StringTokenizer;public class ChineseCharacters{ public StringBuffer getChinesecharacters(File file){ StringBuffer hanzi=new StringBuffer();try{ FileReader inOne=【代码1】 //创建指向文件f的inOne 的对象BufferedReader inTwo=【代码2】//创建指向文件inOne的inTwo的对象String s=null;int i=0;while((s=【代码3】)!=null) //inTwo读取一行{ StringTokenizer tokenizer=new StringTokenizer(s," ,'\n' ");while(tokenizer.hasMoreTokens()){ hanzi.append(tokenizer.nextToken());}}}catch(Exception e) {}return hanzi;}}StudyFrame.javaimport java.awt.*;import java.awt.event.*;import java.io.*;import javax.sound.sampled.*;public class StudyFrame extends Frame implements ItemListener,ActionListener,Runnable{ ChineseCharacters chinese;Choice choice;Button getCharacters,voiceCharacters;Label showCharacters;StringBuffer trainedChinese=null;Clip clip=null;Thread voiceThread;int k=0;Panel pCenter;CardLayout mycard;TextArea textHelp;MenuBar menubar;Menu menu;MenuItem help;public StudyFrame(){ chinese=new ChineseCharacters();choice=new Choice();choice.add("training1.txt");choice.add("training2.txt");choice.add("training3.txt");showCharacters=new Label("",Label.CENTER);showCharacters.setFont(new Font("宋体",Font.BOLD,72));showCharacters.setBackground(Color.green);getCharacters=new Button("下一个汉字");voiceCharacters=new Button("发音");voiceThread=new Thread(this);choice.addItemListener(this);voiceCharacters.addActionListener(this);getCharacters.addActionListener(this);Panel pNorth=new Panel();pNorth.add(new Label("选择一个汉字字符组成的文件"));pNorth.add(choice);add(pNorth,BorderLayout.NORTH);Panel pSouth=new Panel();pSouth.add(getCharacters);pSouth.add(voiceCharacters);add(pSouth,BorderLayout.SOUTH);pCenter=new Panel();mycard=new CardLayout();pCenter.setLayout(mycard);textHelp=new TextArea();pCenter.add("hanzi",showCharacters);pCenter.add("help",textHelp);add(pCenter,BorderLayout.CENTER);menubar=new MenuBar();menu=new Menu("帮助");help=new MenuItem("关于学汉字");help.addActionListener(this);menu.add(help);menubar.add(menu);setMenuBar(menubar);setSize(350,220);setVisible(true);addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0);}});validate();}public void itemStateChanged(ItemEvent e){ String fileName=choice.getSelectedItem();File file=new File(fileName);trainedChinese=chinese.getChinesecharacters(file);k=0;mycard.show(pCenter,"hanzi") ;}public void actionPerformed(ActionEvent e){ if(e.getSource()==getCharacters){ if(trainedChinese!=null){ char c=trainedChinese.charAt(k);k++;if(k>=trainedChinese.length())k=0;showCharacters.setText(""+c);}else{ showCharacters.setText("请选择一个汉字字符文件"); }}if(e.getSource()==voiceCharacters){ if(!(voiceThread.isAlive())){ voiceThread=new Thread(this);}try{ voiceThread.start();}catch(Exception exp){}}if(e.getSource()==help){ mycard.show(pCenter,"help") ;try{ File helpFile=new File("help.txt");FileReader inOne=【代码4】 //创建指向文件helpFile的inOne 的对象BufferedReader inTwo=【代码5】 //创建指向文件inOne的inTwo 的对象String s=null;while((s=inTwo.readLine())!=null){ textHelp.append(s+"\n");}inOne.close();inTwo.close();}catch(IOException exp){}}}public void run(){ voiceCharacters.setEnabled(false);try{ if(clip!=null){ clip.close()}clip=AudioSystem.getClip();File voiceFile=new File(showCharacters.getText().trim()+".wav");clip.open(AudioSystem.getAudioInputStream(voiceFile));}catch(Exception exp){}clip.start();voiceCharacters.setEnabled(true);}}StudyMainClass.javapublic class StudyMainClass{ public static void main(String args[]){ new StudyFrame();}}✧实验后的练习：1. 在StudyFrame类中增加一个按钮previousButton，单击该按钮可以读取前一个汉字。