利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇一：Java语言与WWW技术作业部分答案

Java语言与WWW技术作业1

一、单选题

DBADB 二、填空题 1. C/C++、C++ 2. 1995 3. class、java

4. 封装性、多态性、继承性 5. javac.exe、java.exe 6. 声明、使用 7. const、goto 8. 小写、大写 9. 类、数据成员、方法 10. 2、8 11. 长整型 四、程序设计题

1. 编写小程序，求1到100之间所有整数之和，并在小程序坐标（100,100）处显示。

import java.awt.*; import java.applet.*;

public class MySum extends Applet { int sum;

public void init() { sum=0; for(int i=1;i<=100;i++) sum+=i; }

public void paint(Graphics g) { g.drawString(sum+"", 100, 100 ); } }

Java语言与WWW技术作业2

一、单选题

AABAD 二、填空题

1. 定义对象格式的模板 2. 数据、方法 3. 实例 4. 实例变量 5. 数据类型 6. .(点运算符) 7. new 8. 构造器 9. 垃圾回收机制 10. 当前方法

11. int[] arr=new int[n]; // n是指数据组

的长度 12. 面向对象 13. length

14. String str=”this is a test!”; 或 String

str=new String(“this is a test!”); 15. 4 16. „b‟ 17. private 18. public 19. 对象类型 20. 相同、不同 21. 编译器 22. 多态性

23. static 24. 共享 25. extends 26. 超类、子类 27. 超类

28. 普通成员和构造器

29. super(参数列表)、super.成员[(参数列

表)]; 30. 多继承

31. 子类、该类的超类、该类的子类 32. 可以访问哪些成员、执行哪个版本 33. 相同、相同、覆盖 34. 重载 35. 运行期

36. 抽象类、abstract 37. abstract

38. 方法声明、类声明、变量声明 39. 类，封装、命名 40. 名字，package 41. 默认的、public 42. import

43. 方法实现、多、implements 44. public final static

四、程序填空

1、 A.java extends super abstract

2、完成下面程序的填空。程序的输出结果是： 5 6 A public 五、程序设计

1. 定义一个描述长方体的类Box，类中有三个整型的实例变量：length,width和heihgt，

分别表示长方体的长宽和高。定义构造函数，初始化这三个变量。定义方法求长方体的体积并返回整型结果。定义方法求长方体的表面积整型结果。定义方法把长方体的体积转化成字符串并返回字符串。 class Box{ int length; int width; int height; Box(){ length=width=height=0; }

Box(int l,int w,int h){ length=l; width=w; height=h; }

int vol(){ return length*width*height; }

public String toString(){ return vol()+""; }

}

2. 定义一个描述平面坐标系统中的点及操作的类Point。它有两个double型私有属性x

和y描述点坐标系中的位置。该类包含如下方法：初始化x和y的构造函数;返回x和y值的方法getX()和getY();将给定坐标平移w（水平）和h（垂直）的方法void shiftPoint(double w,double h);判断调用该方法的点的坐标和方法中的参数点的坐标是否相等的方法boolean pointEquals(Point p)。

编写应用程序，测试类Point，使用上面定义的各个方法并将其结果输出。 class Point{

private double x; private double y; Point(){ x=y=0; }

Point(double x, double y){ this.x=x; this.y=y; }

double getX(){ return x; }

void shiftPoint(double w,double h){ x+=w; y+=h; }

boolean pointEquals(Point p){ return (this.x==p.x && this.y==p.y); } }

class Test{

public static void main(String[] args){ Point p1=new Point(1,2); Point p2=new Point(3,4); p2.shiftPoint(-2,-2); System.out.println(p1.pointEquals(p2)); } }

3. 定义一个接口，接口中有三个抽象方法：

long factorial(int m); //求参数的阶乘

long myPower(int m, int n); //求参数m的n次方

Boolean findFactorSum(int m, int n); //判断参数中较小数是否是较大数的因子 编写一个类Test实现该接口。 interface MyMath{ long factorial(int m);

long myPower(int m, int n);

boolean findFactorSum(int m, int n); }

class impleMyMath{

public long factorial(int m){ long fact=1; for(int i=1;i<=m;i++) fact*=i; return fact; }

public long myPower(int m, int n){ long power=m; for(int i=1;i<n;i++) power*=m; return power; }

public boolean findFactorSum(int m, int n){ if(m>n){ return m%n==0; } else return n%n==0; } }

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇二：第10讲输入输出流与文件操作

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇三：杰瑞教育Java练习题库——拷贝文件

烟台杰瑞教育科技有限公司

杰瑞教育Java练习题库——拷贝文件

功能描述： 利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过控制台输入。

运行结果：

源代码参考：案例1_拷贝文件

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇四：第15章输入输出流与文件操作

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇五：Java程序设计课件(高晓黎)第15章输入输出流与文件操作

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇六：文 件 复 制 程 序

《汇编语言程序设计》课程设计报告

课题： 文 件 复 制 程 序________

信息工程学院

一、课程设计目的

本课程设计是在学完教学大纲规定的全部内容、完成所有实践环节的基础

上，旨在深化学生学习的《汇编语言程序设计》课程基本知识，进一步掌握汇编语言程序设计方法，提高分析问题、解决问题的综合应用能力。

二、课程设计的内容

设计题1：文件复制程序

程序功能要求：程序运行后，分别提示输入源文件和目标文件路径名，然后进行磁盘文件的复制。复制完成后显示“文件复制完成”信息。若复制失败，则能给出“源文件不存在” 、“目标路径不存在” 、“目标文件已存在”等信息。

三、程序功能及使用说明

1、程序运行后，分别提示输入源文件和目标文件路径名，然后进行磁盘文件的复制。

2、能拷贝任意英文目录下的英文名文件到任意英文目录下，可指定任意目标英文文件名。在输入拷贝的源文件名时如果检查出该文件是否存在，若不存在，则能给出源文件不存在信息。

3、在输入目标文件名时能检查出该目录下有没有已存在的同名文件，如果存在同名文件，则能给出目标文件已存在的信息。

4、文件复制完成后能显示“文件复制成功”信息，并重新回到主菜单，操作者可以根据需要进行相关选择，以决定退出还是继续操作。 使用方法：直接双击“0710604116.exe”图标即可运行。 具体操作步骤介绍如下：

1、 运行程序后，按照提示信息输入：选择‘A’进入文件复制功能，选择‘B’直接退出程序。运行程序后，按照提示信息输入即可（程序运行截图如下）。

显示主菜单

2、进入文件复制功能后，会马上提示输入源文件路径名，这时可以输入源文 件路径名。

3、源文件路径名输入正确后，会马上提示输入目标文件路径名，这时可以输入

目标文件路径名。

4、目标文件路径名输入正确后，会马上提示复制成功信息，并重新回到主菜单。（程序运行截图如下）

复制成功 回到主菜单

备注：如果源文件不存在、目标文件已存在、路径名不正确都会给出相应的错误提示信息，并重新回到主菜单

四、程序各功能模块实现说明

针对题目的各个功能要求，本人将程序分为一个主程序main和六个子程序分别为getch、closefile、openfile、clear、newfile、copyfile。显然这是一个典型的使用子程序结构的程序。所有独立功能的部分都采用子程序结构，因而主程序设计的使人一目了然。

下面将介绍主程序和各子程序的运用特点和参数说明，并给出他们的流程图。

main主程序调用各子程序表示着整个系统的菜单，每次操作完成一

个次操作后，将退回主界面，操作者可以根据需要进行相关选择，以决定退出还是继续操作

main主程序的流程图

copyfie 子程序实现文件复制的功能，由main主程序调用。 本子程序用到的DOS系统功能调用（INT 21H）

1、AH=09H，功能：显示字符串,调用参数: DS：DX=串地址 、字符串以‘$’结尾，返回参数：无

2、AH=3FH ,功能:读文件或设备, 调用参数:DS=数据缓冲区的段地址 AX=实际读入的字节数、BX=文件代号、CX=读取的字节数，返回参数： CF=0操作成功、AX=实际读入的字节数、AX=0文件结束、CF=1出现错误、AX=错误代码。

3、AH=40H,功能:写文件或设备 , 调用参数: DS=数据缓冲区的段地址 AX=实际读入的字节数、BX=文件代号、CX=写入的字节数，返回参数：CF=0读成功、AX=实际读入的字节数、CF=1出现错误、AX=错误代码。

copyfile 子程序的流程图

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇七：java实验 (9)

Java程序设计课程实验报告

实验序号 10

实验名称 java中多线程的实现、文件输入输出流的使用

课程名称 Java程序设计 实 验 室

2

方正计算机 文祥E330 指 导 书 Java程序设计（第二版） 编 者 实验类别 专业课 实验类型 实践操作 实验要求 必修

面向专业 计算机专业 实施者 学 时 数 实验仪器

实验目的：学会java中多线程的实现方法，掌握文件输入输出流的使用。 实验内容：

1、编写一个类MyThread，它继承自Thread类，该类有两个变量：线程的名字str(String类型)和整型变量delay，该类的构造函数有两个参数，分别初始化str和delay，类的run方法实现操作如下：线程休眠delay毫秒后，打印线程的名字。编写应用程序，创建MyThread类的三个对象t1、t2和t3，分别指定线程名字为“线程A”、“线程B”和“线程C”，休眠时间为1000ms、2000ms、3000ms，并启动这三个线程。

提示：参考课本P197例5.4

程序：

public class TestThread{

public static void main( String[ ] args ) {

Thread t1 = new MyThread("线程A",1000);//创建线程对象 Thread t2 = new MyThread("线程B",2000);//创建线程对象 Thread t3 = new MyThread("线程C",3000);

t1.start( );//启动线程

t2.start( );//启动线程

t3.start( );

System.out.println("当前活动线程的数目:"+Thread.activeCount()); System.out.println("main()\t"+"运行完毕！");

1

}

}

class MyThread extends Thread { //自定线程子类SubThread

String s;

int delay;

public MyThread(String s,int delay)

{

this.s=s;

this.delay=delay;

}

public void run( ) { //覆盖Thread类的run方法：线程启动后将执行该方法

try { sleep(delay); //线程休眠delay毫秒的随机值 } catch(InterruptedException e){ e.printStackTrace(); }

System.out.println(s+":\t结束！");

}

}

结果：

2

2、编写一个类A，并实现Runnable接口，该类有两个变量：str（String类型）和delay（int类型），该类的构造方法有两个参数，分别初始化str和delay。类中的run方法如下实现，休眠delay毫秒后，打印str。编写应用程序，分别用类A的两个对象作为参数创建两个线程对象t1、t2；类A的两个对象的str分别指定为“A类对象1”、“A类对象2”，休眠时间为1000ms、2000ms，并启动这两个线程，当两个线程运行完毕后显示字符串“线程运行完毕！”

提示：参考课本P199例5.5、5.6

程序：

public class TestRunnable{

public static void main( String[ ] args ) {

Runnable ra=new MyClass("MyClass类对象1",1000);

Runnable rb=new MyClass("MyClass类对象2",2000);

Thread t1 = new Thread(ra,"线程A");//创建线程对象，名字为"线程A"

Thread t2 = new Thread(rb,"线程B");//创建线程对象，名字为"线程B"

t1.start( );//启动线程

3

t2.start( );//启动线程

System.out.println("当前活动线程的数目:"+Thread.activeCount()); System.out.println("main()\t"+"运行完毕！");

}

}

class MyClass implements Runnable

{

String s;

int delay;

public MyClass(String s,int delay) {//定义构造方法

this.s=s;

this.delay=delay;

}

public void run( ) {//覆盖Runnable接口的run方法：线程启动后将执行该方法

try {

Thread. currentThread().sleep(delay);

}

catch(InterruptedException e){

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+":\t结束！");

}

}

结果：

4

3、利用文件输入/输出流编写一个实现文件拷贝的应用程序，路径名以及源文件名和目标文件名通过命令行参数传入。

提示：参考课本P211例6.3

程序：

import java.io.*;

public class CopyFile {

public static void main( String[ ] args ){

if( args.length<2 ){//提示正确的用法,传入两个参数

System.out.println( "java CopyFile sourceFile destinationFile" ); System.exit(0);

}

try {

FileInputStream filein=new FileInputStream(args[0]);//创建文件输入流

FileOutputStream fileout=new FileOutputStream(args[1]);//创建文件输处流

copyFile(filein,fileout);//调用自定义的拷贝文件的方法,实现文件拷贝

}

catch(IOException e){

e.printStackTrace();

}

5

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇八：自考Java语言程序设计(一)第八章Java异常处理及输入输出流简介课后

（自考Java语言程序设计（一）第八章Java异常处理及输入输出流简介课后习题八、Java异常处理及输入输出流简介　　1．列出5个常见的异常。　　2．写出Java语言的异常处理机制的优点。　　3．为什么异常处理技术不应该用于常规的程序控制？　　4．引起异常产生的条件是什么？　　5．异常没有被捕获将会发生什么？　　6．编写一个程序，以说明catch（Exception e）如何捕获各种异常。　　7．下面的代码段中finally语句块会被执行吗？　　public class ExceptionExam3　　{　　public static void main(String [] args)　　{　　try　　{　　int [] a=new int[3];　　System.exit(0);　　}　　catch(ArrayIndexOutOfBoundsException e)　　{System.out.println("发生了异常");}　　finally　　{System.out.println("Finally");}　　}　　}　　8．throws的作用是什么？　　9．应在程序的什么地方使用异常处理？　　10．下面的代码有什么错误吗？　　class ExceptionExam{…}　　throw new ExceptionExam();　　11．异常类型匹配的处理方式。程序功能：首先输出“这是一个异常处理的例子”，然后在你程序中主动地产生一个 ArithmeticException 类型被0 除而产生的异常，并用catch 语句捕获这个异常。最后通过ArithmeticException类的对象e的方法getMessage 给出异常的具体类型并显示出来。　　12．根据所给创建自定义异常类的使用格式，编写一个自定义异常的小程序。　　13．什么叫流？流式输入输出有什么特点？　　14．Java流被分为字节流、字符流两大流类，两者有什么区别？　　15．File类有哪些构造函数和常用方法？　　16．利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。　　17．编写一个程序，在当前目录下创建一个子目录test，在这个新创建的子目录下创建一个文件，并把这个文件设置成只读。　　18．位置指针的作用是什么？RandomAccessFile类提供了哪些方法实现对指针的控制？　　19．编写一个程序，从键盘输入一串字符，统计这串字符中英文字母、数字、其他符号的字符数。　　20．编写一个程序，从键盘输入一串字符，从屏幕输出并将其存入a.txt文件中。采集者退散　　21．编写一个程序，从键盘输入10个整数，并将这些数据排序后在标准输出上输出。　　参考答案　　1．答：内存耗尽、数组下标超出边界、被0除、非法的方法参数、算法溢出处。来源：考试大的美女编辑们　　2．答：（1）Java通过面向对象的方法进行异常处理，

把各种异常事件进行分类，体现了良好的层次性，提供了良好的接口，这种机制对于具有动态特 性的复杂提供了强有力的控制方式。（2）Java的异常处理机制使得处理异常的代码和“常规”代码分开，减少了代码的数量，增强了程序的可读性。（3） Java的异常处理机制使得异常事件可以沿调用栈自动向上传播，而不是C语言中通过函数的返回值来传播，这样可以传递更多的信息，并且简化了代码的编写。 （4）由于把事件当成事件处理，利用类的层次性我们可以把多个具有相同父类的异常统一处理，也可以区分不同的异常分别处理，使用非常灵活。　　3．答：a. 异常处理用于不经常发生但通常导致程序终止的情况，因此要求编程人员为编译器的优化执行实现异常处理。b. 常规控制结构的控制流程通常比异常的更为清晰、交流更高。c. 在发生异常，并且没有释放异常发生之前分配的资源时，堆栈是展开的，所以会出现一些问题。d.“额外的”异常会妨碍真正错误类型的异常。这种使程序员更难 以跟踪大量的异常。　　4．答：异常产生的方式有3种。第一种是在某些内部错误时，Java虚拟机可以产生异常，该异常不在你的程序控制范围内，通常不作处理。第二种是由程序代码中的错误引起，这种异常需要你的程序处理。第三种是通过使用throw语句手动生成的异常。　　5．答：未捕获的异常最终会导致程序非正常终止。　　6．public class ExceptionExam　　{　　public static void main(String [] args)　　{　　try　　{　　int i=0;　　i=3/i;//将产生算术异常。　　}　　catch(ArithmeticException e)//找到了匹配的异常，执行该catch块。　　{　　System.out.println("发生了ArithmeticException异常");　　}　　catch(AarryIndexOutOfBoundsException e)//不是匹配的异常，且不会再捕获　　//异常，如果发生数组索引超出范围所产生的异常，将执行该catch块。　　{　　System.out.println("发生了AarryIndexOutOfBoundsException异常");　　}　　catch(Exception e)　　//前两个catch块均无法捕获try块中发生的异常时，才会执行该catch块。　　{　　System.out.println("发生了异常");　　} 　　finally　　{ System.out.println("执行d Finally"); }　　}　　}　　7．答：无论是出于何种原因，只要执行离开try/catch代码块，就会执行finally代码块。即无论try是否正常结束，都会执行 finally定义的最后的代码。如果try代码块中的任何代码或它的任何catch语句从方法返回，也会执行finally代码块。但本题中在try代 码块中执行了“System.exit(0);”语句，执行了这一语句后，Java虚拟机（JVM）将被终止。那么finally语

句块一定不会被执行。　　8．答：在某些情况下，如果一个方法产生自己不处理或无法处理的异常，它就必须在throws子句中声明该异常。　　9．答：通常，可以采用两种方式来报告错误：返回值和异常。在Java中异常处理很常用，虽然返回错误代码在某些情况下是一种有效的方式，但是异常处理可以提供强大的结构化方法来处理异常。所以需要处理代码中的错误时就可以采用异常的方法进行处理。　　10．答：ExceptionExam不是继承（扩展）Throwable的子类，只有Throwable的子类可以由throw抛出。所以，这一段代码会出错。　　11．　　public class ExceptionExam1　　{　　public static void main(String [] args)　　{　　try　　{int i=0;　　i=3/i;　　}　　catch(ArithmeticException e)　　{　　System.out.println("异常是："+e.getMessage());　　}　　finally　　{　　System.out.println("finally 语句被执行");　　}　　}　　}　　注意：如果在catch 语句中声明的异常类是Exception，catch 语句也能正确地捕获，这是因为Exception 是ArithmeticException 的父类。如果不能确定会发生哪种情况的异常，那么最好指定catch的参数为Exception，即说明异常的类型为Exception。　　12．　　class Excp1 extends Exception　　{}　　class Excp2 extends Excp1　　{}　　public class ExceptionExam7　　{　　public static void main(String [] args) throws Exception　　{　　try　　{　　throw new Excp2();　　}　　catch(Excp2 e)　　{　　System.out.println("catch1");　　throw new Excp1();　　}　　catch(Excp1 e)　　{　　System.out.println("catch2");　　throw new Exception();　　}　　catch(Exception e)　　{　　System.out.println("catch3");　　}　　finally　　{　　System.out.println("finally");　　}　　}　　}　　说明：自定义异常类，关键是选择继承的超类——必须是Exception或者其子类。用异常代表错误，而不要再使用方法返回值。　　13．答：所谓流是指同一台计算机或网络中不同计算机之间有序运动着的数据序列，Java把这些不同来源和目标的数据都统一抽象为数据流。数据流可分为输入流和输出流，输入流代表从其他设备流入计算机的数据序列，输出流代表从计算机流向外部设备的数据序列。　　流式输入输出的特点是数据的获取和发送沿数据序列的顺序进行，即每一个数据都必须等待排在它前面的数据，等前面的数据读入或送出之后才能被读写。所以流和队列一样，只能以“先进先出”的方式对其中的数据进行读写，而不能随意选择读写的位置。　　14．答：两者都作为Object类的直接子类，基本输入流（无效Stream

）和基本输出流（OutputStream）是处理以8位字节为基本单位的字节流类；Reader和Writer类是专门处理16位字符流的类。　　15．答：构造函数有：　　（1）public File(String pathname)：创建一个对应于参数pathname的File类对象。参数pathname是包含目录和文件名的字符串。如果没有文件名，则代表目录。　　（2）public File(String parent , String child)：该构造函数将pathname分成两部分parent和child，参数parent表示目录或文件所在路径，参数child表示目录或文件名称。　　（3）public File(File parent, String child)：该构造函数与上面一个不同在于将parent的参数类型由String变为File，代表parent是一个已经创建的File类文件对象（指向目录）。　　常用方法有：　　（1）public boolean canWrite( )：返回文件是否可写。　　（2）public boolean canRead( )：返回文件是否可读。　　（3）public boolean createNewFile( )：当文件不存在时创建文件。　　16．　　import java.io.*;　　class CopyFile{　　public static void main(String[] args) {　　String file1,file2 ;　　int ch = 0 ;　　try {　　file1=args[0];　　file2=args[1];　　File无效Stream fis = new File无效Stream(file1);　　FileOutputStream fos=new FileOutputStream(file2);　　while ((ch=fis.read())!=-1)　　fos.write(ch);　　fis.close();　　fos.close();　　}　　catch(FileNotFoundException e){　　System.out.println("源文件:未找到!");　　}catch(ArrayIndexOutOfBoundsException e){　　System.out.println("缺少运行参数！");　　System.exit(-1);　　}　　catch (IOException e){　　System.out.println(e.toString());　　}　　}　　}　　17．答：　　import java.io.*;　　public class NewFile{　　public static void main(String args[]){　　File f=new File("test");　　if(f.exists()&&f.isDirectory())　　System.err.println("目录："+f.toString()+"已经存在!");　　else{　　if(f.mkdir()){　　System.out.println("目录"+f.getAbsolutePath()+"创建结束!");　　File f2=new File(f,"my.txt");　　try{　　f2.createNewFile();　　f2.setReadOnly();　　}catch(IOException e){　　System.out.println(e.toString());　　}　　System.out.println("文件："+f2.getAbsoluteFile()+"创建结束!");　　}　　else 　　System.out.println("目录"+f.getAbsoluteFile()+"创建失败!");　　}　　}　　}　　18．答：要实现对文件的随机读取，也就是在文件的任何位置执行读写数据的操作，需要一个指针来指定读写的位置。在创建 RandomAccessFile类对象的同时，系统自动创建了一个指向这个文件开头的指针，当执行读写操作后，指针自动指向被读写数据之后的第一个字节 处。指针初始值是0，每读/写一个字节，指针自动增加1

。RandomAccessFile类提供了一些控制指针移动的方法。　　public long getFilePointer();获取当前指针指向文件的位置。考试大论坛　　pulbic void seek(long pos);将指针移动到参数pos指定的位置。　　public int skipBytes(int n);指针从当前位置向后移动n个字节位置，并返回指针实际移动的字节数。　　19．答：　　import java.io.*;　　public class Count{　　public static void main(String[] args)　　{　　int x=0,y=0,z=0;　　int ch;　　try{　　while((ch=System.in.read())!='\r'){　　if(ch>='A'&&ch<='Z'||ch>='a'&&ch<='z')　　x++;　　else if(ch>='0'&&ch<='9')　　y++;　　else　　z++;　　}　　}catch(IOException e){　　System.out.println(e.toString());　　}　　System.out.println("英文字母："+x);　　System.out.println("数字字符："+y);　　System.out.println("其它字符："+z);　　}　　}　　20．答：　　import java.io.*;　　public class InFile{　　public static void main(String[] args)　　{　　int ch;　　try{　　FileOutputStream out=new FileOutputStream("a.txt");　　while((ch=System.in.read())!='\r'){　　System.out.write(ch);　　out.write(ch);　　}　　out.close();　　System.out.write('\n');　　}catch(IOException e){　　System.out.println(e.toString());　　}　　System.out.println("输出至文件完毕！");　　}　　}　　21．答：　　import java.io.*;　　public class Sort{　　public static void main(String args[])　　{　　int a[]=new int[10];　　byte b[]=new byte[10];　　int t;　　String str;　　System.out.println("请输入10个整数：");　　try{　　for(int i=0;i<10;i++)　　{System.out.print("No. "+(i+1)+": ");　　System.in.read(b);　　str=new String(b);　　str=str.trim();　　a[i]=Integer.parseInt(str);　　}　　}catch(IOException e){　　System.out.println(e.toString());　　}　　catch(NumberFormatException e){　　System.out.println(e.toString());　　}　　for(int i=0;i<9;i++)　　for(int j=i+1;j<10;j++)　　{ 　　if(a[i]>a[j]){　　t=a[i];　　a[i]=a[j];　　a[j]=t;　　}　　}　　for(int i=0;i<10;i++)　　System.out.println(a[i]+"\t");　　}　　}

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇九：流式输入输出与文件处理

实验5 流式输入输出与文件处理

1 实验目的

(1) 掌握字节流和字符流的特点和处理差异；

(2) 掌握过滤流的使用；

(3) 掌握File类的使用；

(4) 掌握随机文件的使用。

(5) 掌握对象系列化的概念以及访问文件时对象读写方法。

2 知识要点

2.1 面向字节的输入/输出流

（1）类InputStream是面向字节的输入流的根。其主要方法见表13-1。

表13-1 类InputStream的方法

（2） 数据过滤流DataInputStream

该流实现DataInput接口，主要方法有：readByte()，readBoolean()、readShort()、readChar()、readInt() 、readLong()、readFloat()、readDouble()、readUTF()等。

（3）类OutputStream是面向字节输出流的根，其主要方法有：

 void write(int b) ：将参数b的低字节写入输出流

 void write(byte b[]) ：将字节数组全部写入输出流

 void write(byte b[],int offset, int len)：将字节数组中从b[offset]开始处的len个字节写入至输出流。

（4）类DataOutputStream实现各种类型数据的输出处理，它实现了DataOutput接口，主要方法有：writeByte(int)、writeBytes(String)、writeBoolean(boolean)、

writeChars(String)、writeInt(int) 、writeLong()、writeFloat(float)、

writeDouble(double)、writeUTF(String)等。

2.2 面向字符的输入与输出流

类Reader是面向字符的输入流的根，其提供的方法与InputStream类似，只是将基于Byte的参数改为基于Char。

类Writer是面向字符的输出流类的根，其提供的方法与OutputStream类似，只是将基于Byte的参数改为基于Char。

类InputStreamReader是一个特殊的流，用来将面向字节的数据流包装转换为面向字符的流。常用于从键盘获取输入数据。例如，从键盘输入一行字符串，可以用BufferedReader的readLine()方法，但在此前必须使用InputStreamReader将字节流转化为字符流。

BufferedReader in=new BufferedReader(new InputStreamReader(System.in)); String x=in.readLine()

2.3 文件的顺序读写

（1）面向字节的文件访问

 以二进制文件作为数据源。FileInputStream类和FileOutputStream类分别用于文件的读、写访问。

 利用InputStream和OutputStream的方法可实现文件的读写操作。

 可用DataInputStream对FileInputStream流进行过滤；用DataOuputStream对FileOutputStream流进行过滤,以实现特定数据类型数据的读写。

（2）面向字符的文件访问

 以字符文件作为数据源。包括：FileReader类和FileWriter类分别用于字符文件的读、写访问。

 基于字符流的数据读写方法与基于字节流的类似，只是将读写的单位由字节改为字符，方法中的字节数组参数相应改为字符数组。例如:

int read(char b[])表示从文件读数据填满数组，返回读到的字符数。

 可用BufferedReader对FileReader流进行过滤；用BufferedWriter对FileWriter流进行过滤，其中包含newLine()方法可写入一个换行。

2.4 File类

借助File对象，可以获取文件和相关目录的属性信息。其主要方法见表13-2。

表13-2 File类的主要方法

2.5 随机文件

创建随机访问文件对象时要指定文件访问的“rw”参数，也就是它可以对同一打开文件进行读写两种访问。RandomAccessFile类实现了DataInput和DataOutput接口，为支持流的随机读写，RandomAccessFile类还添加定义了如下方法：

 long getFilePointer()：返回当前指针；

 void seek(long pos)：将文件指针定位到一个绝对地址；

 long length()：返回文件的长度

注意：地址是相对于文件头的偏移量。地址0表示文件的开头。

2.6 对象序列化

（1）对象输入流ObjectInputStream和对象输出流ObjectOutputStream将Java流系统扩充到能输入输出对象，它们提供的writeObject（）和readObject()方法实现了对象的串行化（Serialized）和反串行化(Deserialized)。

（2）用对象输入流的readObject()方法必须捕捉ClassNotFoundException异常。

（3）为了实现用户自定义对象的串行化，相应的类必须实现Serializable接口，否则，不能以对象形式正确写入文件。Serializable接口是一个不含任何具体内容的接口。

3 样例程序

样例1: 编写一个程序实现任意文件的拷贝功能，源文件和目的文件名由命令行参数提供。

【参考程序】

import java.io.*;

public class CopyFile {

public static void main(String args[]) {

if ( args.length<2) {

System.out.println("usage: java CopyFile sourcefile targetfile"); System.exit(0);

}

byte[] b = new byte[1024];

try {

FileInputStream infile = new FileInputStream(args[0]);

FileOutputStream targetfile = new FileOutputStream(args[1]); while (true) {

int byteRead=infile.read(b); //从文件读数据给字节数组

if (byteRead==-1) //在文件尾，无数据可读

break; //退出循环

targetfile.write(b,0,byteRead); //将读到的数据写入目标文件 }

targetfile.close();

System.out.println("copy success! ");

} catch(IOException e) { }

}

}

注：本样例演示面向字节的输入输出流的进行文件读写的方法。

【编程技巧】

(1) 创建一个字节数组存放从文件读取的数据；

(2) 利用FileInputStream对象的带字节数组参数的read方法从文件读数据，返回读到的字节数；利用FileOutputStream对象的带字节数组的write方法可将字节数组中指定的字节写入到目标文件。

(3) 利用循环控制文件的连续读写操作，在处理到文件结尾时，read方法返回-1，退出循环。

样例2：编写一个程序统计一个文本文件中字符A的个数，文件名由命令行参数提供。

【参考程序】

import java.io.*;

public class readtxt {

static String s;

/* 方法find查找字符串in中A的个数 */

public static int find(String in) {

int n=0;

int counter = 0;

while(n!=-1) {

n = in.indexOf((int)'A',n+1);

counter++;

}

return counter-1;

}

public static void main(String[] args) {

try{

int n=0;

FileReader file =new FileReader(args[0]);

BufferedReader in=new BufferedReader (file);

boolean eof=false;

while(!eof) {

String x=in.readLine(); //从文件读一行

if(x==null) { //判是否文件结束

eof=true;

}

else

s=s+x; //将内容拼接到字符串s上

}

System.out.print("the number of A is :"+find(s));

利用文件输入输出流编写一个实现文件拷贝的程序，源文件名和目标文件名通过命令行参数传入。篇十：C编程实现文件复制

操作系统实验之linux系统调用实现文件拷贝

(2009-04-28 19:50:30)

转载

标签：

it 分类： 大学课程

呵呵，想了想，为了防止写的东西丢了，还是将它们备份新浪的服务器上了吧。实验一看标题也就会知道了，就是在linux下通过系统调用来实现文件的copy功能，程序代码也是比较简单，还是贴出来吧，同时也和网上的朋友们分享下吧：

#include<unistd.h>

#include<fcntl.h>

#include <stdio.h>

#include<sys/types.h> // contain some defined types

#include<sys/stat.h> // contain some mod

#include<errno.h> // err stream

int main( int argc, char* argv[ ] )

{

const int Buffer_Size=20;

char buffer[Buffer_Size];

int from_fd,to_fd ;

int write_bytes;

if(argc!=3)

{

fprintf(stderr,"Wrong Format !\n");

return -1;

}

//Sys call to open the source file

from_fd=open( argv[1],O_RDONLY );

//if fail in open the source file

if(from_fd==-1)

{

fprintf(stderr,"fail in open the source file\n");

return -1;

}

//open the destnation file ,and if file exsits ,to_fd will be ok

to_fd=open(argv[2], );

char ch;

if(to_fd!=-1)

{

fprintf(stderr,"destnation file exists!Do you Want To OverWrite

It!(Y/N)\n");

scanf("%c",&ch);

if(ch=='n' || ch=='N')

{

fprintf(stderr,"copy failed !\n");

return -1;

}

}

to_fd=open(argv[2],O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR );

if(to_fd==-1)

{

fprintf(stderr,"fail in open destnation file!\n");

return -1;

}

while( (write_bytes=read(from_fd,buffer,Buffer_Size))>0)

{

if(write(to_fd,buffer,write_bytes)<0)

{

break;

}

}

fprintf(stderr,"Copy File Successfully !\n");

return 1;

}

文件系统相关的调用

文件是用来保存数据的，而文件系统则可以让用户组织，操纵以及存取不同的文件。内核允许用户通过一个严格定义的过程性接口与文件系统进行交互，这个接口对用户屏蔽了文件系统的细节，同时指定了所有相关系统调用的行为和语义。Linux支持许多中文件系统，如ext2，msdos, ntfs, proc, dev, ufs, nfs等等，这些文件系统都实现了相同的接口，因此给应用程序提供了一致性的视图。但每种文件系统在实现时可能对某个方面加以了一定的限制。如：文件名的长度，是否支持所有的文件系统接口调用。

为了支持多文件系统，sun提出了一种vnode/vfs接口，SVR4中将之实现成了一种工业标准。而Linux作为一种Unix的clone体，自然也实现了这种接口，只是它的接口定义和SVR4的稍有不同。Vnode/Vfs接口的设计体现了面向对象的思想，Vfs（虚拟文件系统）代表内核中的一个文件系统，Vnode（虚拟节点）代表内核中的一个文件，它们都可以被视为抽象基类，并可以从中派生出不同的子类以实现不同的文件系统。

由于篇幅原因，这里只是大概的介绍一下怎样通过Vnode/Vfs结构来实现文件系统和访问文件。

在Linux中支持的每种文件系统必须有一个file_system_type结构，此结构的核心是read_super函数，该函数将读取文件系统的超级块。Linux中支持

的所有文件系统都会被注册在一条file_system_type结构链中，注册是在系统初始化时调用regsiter_filesystem()完成，如果文件系统是以模块的方式实现，则是在调用init_module时完成。

当mount某种块设备时，将调用系统调用mount，该调用中将会首先检查该类文件系统是否注册在系统种中，如果注册了则先给该文件系统分配一个super_block，并进行初始化，最后调用这种文件系统的read_super函数来完成super_block结构私有数据的赋值。其中最主要的工作是给super_block的s_ops赋值，s_ops是一个函数向量表，由文件系统各自实现了一组操作。

struct super_operations {

void (*read_inode) (struct inode *);

void (*write_inode) (struct inode *);

void (*put_inode) (struct inode *);

void (*delete_inode) (struct inode *);

void (*put_super) (struct super_block *);

void (*write_super) (struct super_block *);

int (*statfs) (struct super_block *, struct statfs *);

int (*remount_fs) (struct super_block *, int *, char *);

void (*clear_inode) (struct inode *);

void (*umount_begin) (struct super_block *);

};

由于这组操作中定义了文件系统中对于inode的操作，所以是之后对于文件系统中文件所有操作的基础。

在给super_block的s_ops赋值后，再给该文件系统分配一个vfsmount结构，将该结构注册到系统维护的另一条链vfsmntlist中，所有mount上的文件系统都在该链中有一项。在umount时，则从链中删除这一项并且释放超级块。

对于一个已经mount的文件系统中任何文件的操作首先应该以产生一个inode实例，即根据文件系统的类型生成一个属于该文件系统的内存i节点。这首先调用文件定位函数lookup_dentry查找目录缓存看是否使用过该文件，如果还没有则缓存中找不到，于是需要的i接点则依次调用路径上的所有目录I接点的lookup函数，在lookup函数中会调用iget函数，该函数中最终调用超级块的s_ops->read_inode读取目标文件的磁盘I节点（这一步再往下就是由设备驱动完成了，通过调用驱动程序的read函数读取磁盘I节点），read_inode函数的主要功能是初始化inode的一些私有数据(比如数据存储位置，文件大小等等)以及给inode_operations函数开关表赋值，最终该inode被绑定在一个目录缓存结构dentry中返回。

在获得了文件的inode之后，对于该文件的其它一切操作都有了根基。因为可以从inode 获得文件操作函数开关表file_operatoins，该开关表里给出了标准的文件I/O接口的实现，包括read, write, lseek, mmap, ioctl等等。这些函数入口将是所有关于文件的系统调用请求的最终处理入口，通过这些函数入口会向存储该文件的硬设备驱动发出请求并且由驱动程序返回数据。当然这中间还会牵涉到一些关于buffer的管理问题，这里就不赘述了。

通过讲述这些，我们应该明白了为什么可以使用统一的系统调用接口来访问不同文件系统类型的文件了：因为在文件系统的实现一层，都把低层的差异屏蔽了，用户可见的只是高层可见的一致的系统调用接口。

5.与module相关的系统调用

Linux中提供了一种动态加载或卸载内核组件的机制——模块。通过这种机制Linux用户可以为自己可以保持一个尽量小的内核映像文件，另外，往内核中加载和卸载模块不需要重新编译整个内核以及引导机器。可以通过一定的命令或者调用在一个运行的系统中加载模块，在不需要时卸载模块。模块可以完成许多功能，比如文件系统、设备驱动，系统支持的执行文件格式，甚至系统调用和中断处理都可以用模块来更新。

Linux中提供了往系统中添加和卸载模块的接口，create_module()，init_module (), delete_module()，这些系统调用通常不是直接为程序员使用的，它们仅仅是为实现一些系统命令而提供的接口，如insmod, rmmod，（在使用这些系统调用前必须先加载目标文件到用户进程的地址空间，这必须由目标文件格式所特定的库函数(如：libobj.a中的一些函数)来完成）。

Linux的核心中维护了一个module_list列表，每个被加载到核心中的模块都在其中占有一项，系统调用create_module()就是在该列表里注册某个指定的模块，而init_module则是使用模块目标文件内容的映射来初始化核心中注册的该模块，并且调用该模块的初始化函数，初始化函数通常完成一些特定的初始化操作，比如文件系统的初始化函数就是在操作系统中注册该文件系统。delete_module则是从系统中卸载一个模块，其主要工作是从module_list中删除该模块对应的module结构并且调用该模块的cleanup函数卸载其它私有信息。

Back

 Linux中怎样编译和定制内核

1.编译内核前注意的事项

检查系统上其它资源是否符合新内核的要求。在linux/Document目录下有一个叫Changes的文件，里面列举了当前内核版本所需要的其它软件的版本号，

- Kernel modutils 2.1.121 ; insmod -V

- Gnu C 2.7.2.3 ; gcc --version

- Binutils 2.8.1.0.23 ; ld -v

- Linux libc5 C Library 5.4.46 ; ls -l /lib/libc*

- Linux libc6 C Library 2.0.7pre6 ; ls -l /lib/libc*

- Dynamic Linker (ld.so) 1.9.9 ; ldd --version or ldd -v

- Linux C++ Library 2.7.2.8 ; ls -l /usr/lib/libg++.so.*

. . . . . .

其中最后一项是列举该软件版本号的命令，如果不符合要求先给相应软件升级，

这一步通常可以忽略。

2.配置内核

使用make config或者make menuconfig, make xconfig配置新内核。其中包括选择块设备驱动程序、网络选项、网络设备支持、文件系统等等，用户可以根据自己的需求来进行功能配置。每个选项至少有“y”和“n”两种选择，选择“y”表示把相应的支持编译进内核，选“n”表示不提供这种支持，还有的有第三种选择“m”，则表示把该支持编译成可加载模块，即前面提到的module，怎样编译和安装模块在后面会介绍。

这里，顺便讲述一下如何在内核中增加自己的功能支持。

假如我们现在需要在自己的内核中加入一个文件系统tfile，在完成了文件系统的代码后，在linux/fs下建立一个tfile目录，把源文件拷贝到该目录下，然后修改linux/fs下的Makefile，把对应该文件系统的目标文件加入目标文件列表中，最后修改linux/fs/Config.in文件，加入

bool 'tfile fs support' CONFIG_TFILE_FS或者

tristate ‘tfile fs support' CONFIG_TFILE_FS

这样在Make menuconfig时在filesystem选单下就可以看到

< > tfile fs support一项了

3.编译内核

在配置好内核后就是编译内核了，在编译之前首先应该执行make dep命令建立好依赖关系，该命令将会修改linux中每个子目录下的.depend文件，该文件包含了该目录下每个目标文件所需要的头文件（绝对路径的方式列举）。

然后就是使用make bzImage命令来编译内核了。该命令运行结束后将会在linux/arch/asm/boot/产生一个名叫bzImage的映像文件。

4.使用新内核引导

把前面编译产生的映像文件拷贝到/boot目录下（也可以直接建立一个符号连接，这样可以省去每次编译后的拷贝工作），这里暂且命名为vmlinuz-new，那么再修改/etc/lilo.conf，在其中增加这么几条：

image = /boot/vmlinuz-new

root = /dev/hda1

label = new

read-only

并且运行lilo命令，那么系统在启动时就可以选用新内核引导了。

5.编译模块和使用模块

在linux/目录下执行make modules编译模块，然后使用命令make modules_install来安装模块（所有的可加载模块的目标文件会被拷贝到/lib/modules/2.2.12/），这样之后就可以通过执行insmod 〈模块名〉和rmmod〈模块名〉命令来加载或卸载功能模块了。

linux下的C编程实现文件复制的方法