int d; long start = System.currentTimeMillis(); while ((d = fis.read()) != -1){ fos.write(d); }

这是 Java 代码，实现了将一个文件输入流 fis 中的内容复制到一个文件输出流 fos 中。具体来说，代码中的 while 循环会不断读取 fis 中的数据，直到读取到文件末尾（即返回值为 -1）。每次读取到一个字节（即一个 int 类型的数据），就将其写入到输出流 fos 中。这样就完成了文件的复制操作。

另外，代码中的 start 变量记录了文件复制操作开始的时间，可以用来计算文件复制所花费的时间。

相关问题

import java.io.IOException; import java.io.FileOutputStream; import java.io.FileInputStream; import java.io.BufferedInputStream; public class fileDemo { public static void main(String[] args) throws IOException { method1(); method2(); method3(); method4(); } // 一次读取一个字节 public static void method1() throws IOException { FileInputStream fis=new FileInputStream("D:\\bbb.mp4"); FileOutputStream fos = new FileOutputStream("copy.mp4"); long start1 = System.currentTimeMillis(); int b=0; while((b=fis.read())!=-1) { //System.out.println((char)b); fos.write((char)b); } long end1 = System.currentTimeMillis(); System.out.println("使用FileInputStream的read()方法复制时间：" + (end1 - start1) + "ms"); fis.close(); fos.close(); } // 一次读取一个字节数组 public static void method2() throws IOException { FileInputStream fis=new FileInputStream("D:\\bbb.mp4"); FileOutputStream fos = new FileOutputStream("copy.mp4"); long start1 = System.currentTimeMillis(); int b=0; byte[] bs=new byte[1024]; while((b=fis.read(bs))!=-1) { //System.out.println(new String(bs)); fos.write(bs,0,b); } long end1 = System.currentTimeMillis(); System.out.println("使用FileInputStream的readread(byte[] b)方法复制时间：" + (end1 - start1) + "ms"); fis.close(); fos.close(); } // 缓冲流+一次读一个字节 public static void method3() throws IOException { BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\bbb.mp4")); FileOutputStream fos = new FileOutputStream("copy.mp4"); long start1 = System.currentTimeMillis(); int b=0; while((b=bis.read())!=-1) { //System.out.println((char)(b)); fos.write((char)b); } long end1 = System.currentTimeMillis(); System.out.println("使用BufferedInputStream的read()方法复制时间：" + (end1 - start1) + "ms"); bis.close(); fos.close(); } //缓冲流＋一次读一个字节数组 public static void method4() throws IOException { BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\bbb.mp4")); FileOutputStream fos = new FileOutputStream("copy.mp4"); long start1 = System.currentTimeMillis(); int len=0; byte[] bs=new byte[1024]; while((len=bis.read(bs))!=-1) { //System.out.println(new String(bs,0,len)); fos.write(bs,0,len); } long end1 = System.currentTimeMillis(); System.out.println("使用BufferedInputStream的read(byet[] b)方法复制时间：" + (end1 - start1) + "ms"); bis.close(); fos.close(); } } 给出每一行代码的注释

import java.io.IOException; 	// 导入IOException类
import java.io.FileOutputStream; // 导入FileOutputStream类
import java.io.FileInputStream; // 导入FileInputStream类
import java.io.BufferedInputStream; // 导入BufferedInputStream类

public class fileDemo { // 定义fileDemo类

	public static void main(String[] args) throws IOException { // 主函数，抛出IOException异常
		method1(); // 调用method1函数
		method2(); // 调用method2函数
		method3(); // 调用method3函数
		method4(); // 调用method4函数
	}

	// 一次读取一个字节
	public static void method1() throws IOException { // 定义method1函数，抛出IOException异常
		FileInputStream fis=new FileInputStream("D:\\bbb.mp4"); // 创建FileInputStream对象fis，打开文件D:\bbb.mp4
		FileOutputStream fos = new FileOutputStream("copy.mp4"); // 创建FileOutputStream对象fos，打开文件copy.mp4
		long start1 = System.currentTimeMillis(); // 获取当前时间
		int b=0; // 定义整型变量b并初始化为0
		while((b=fis.read())!=-1) { // 当读取到的字节不等于-1时，执行循环
			//System.out.println((char)b); // 输出读取到的字节
			fos.write((char)b); // 将读取到的字节写入文件
		}
		long end1 = System.currentTimeMillis(); // 获取当前时间
		System.out.println("使用FileInputStream的read()方法复制时间：" + (end1 - start1) + "ms"); // 输出复制所用时间
		fis.close(); // 关闭文件输入流
		fos.close(); // 关闭文件输出流
	}

	// 一次读取一个字节数组
	public static void  method2() throws IOException { // 定义method2函数，抛出IOException异常
		FileInputStream fis=new FileInputStream("D:\\bbb.mp4"); // 创建FileInputStream对象fis，打开文件D:\bbb.mp4
		FileOutputStream fos = new FileOutputStream("copy.mp4"); // 创建FileOutputStream对象fos，打开文件copy.mp4
		long start1 = System.currentTimeMillis(); // 获取当前时间
		int b=0; // 定义整型变量b并初始化为0
		byte[] bs=new byte[1024]; // 创建1024字节的字节数组bs
		while((b=fis.read(bs))!=-1) { // 当读取到的字节不等于-1时，执行循环
			//System.out.println(new String(bs)); // 输出读取到的字节
			fos.write(bs,0,b); // 将读取到的字节写入文件
		}
		long end1 = System.currentTimeMillis(); // 获取当前时间
		System.out.println("使用FileInputStream的readread(byte[] b)方法复制时间：" + (end1 - start1) + "ms"); // 输出复制所用时间
		fis.close(); // 关闭文件输入流
		fos.close(); // 关闭文件输出流
	}

	// 缓冲流+一次读一个字节
	public static void method3() throws IOException { // 定义method3函数，抛出IOException异常
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\bbb.mp4")); // 创建BufferedInputStream对象bis，打开文件D:\bbb.mp4
		FileOutputStream fos = new FileOutputStream("copy.mp4"); // 创建FileOutputStream对象fos，打开文件copy.mp4
		long start1 = System.currentTimeMillis(); // 获取当前时间
		int b=0; // 定义整型变量b并初始化为0
		while((b=bis.read())!=-1) { // 当读取到的字节不等于-1时，执行循环
			//System.out.println((char)(b)); // 输出读取到的字节
			fos.write((char)b); // 将读取到的字节写入文件
		}
		long end1 = System.currentTimeMillis(); // 获取当前时间
		System.out.println("使用BufferedInputStream的read()方法复制时间：" + (end1 - start1) + "ms"); // 输出复制所用时间
		bis.close(); // 关闭缓冲输入流
		fos.close(); // 关闭文件输出流
	}

	// 缓冲流＋一次读一个字节数组
	public static void method4() throws IOException { // 定义method4函数，抛出IOException异常
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\bbb.mp4")); // 创建BufferedInputStream对象bis，打开文件D:\bbb.mp4
		FileOutputStream fos = new FileOutputStream("copy.mp4"); // 创建FileOutputStream对象fos，打开文件copy.mp4
		long start1 = System.currentTimeMillis(); // 获取当前时间
		int len=0; // 定义整型变量len并初始化为0
		byte[] bs=new byte[1024]; // 创建1024字节的字节数组bs
		while((len=bis.read(bs))!=-1) { // 当读取到的字节数不等于-1时，执行循环
			//System.out.println(new String(bs,0,len)); // 输出读取到的字节
			fos.write(bs,0,len); // 将读取到的字节数组写入文件
		}
		long end1 = System.currentTimeMillis(); // 获取当前时间
		System.out.println("使用BufferedInputStream的read(byet[] b)方法复制时间：" + (end1 - start1) + "ms"); // 输出复制所用时间
		bis.close(); // 关闭缓冲输入流
		fos.close(); // 关闭文件输出流
	}

}

1.（1） 分别使用FileWriter 和 BufferedWriter 往文件exp5_1.txt和文件exp5_2.txt中写入1万个随机整数（数与数之间用空格隔开），并在控制台上显示程序运行的时间。（exp5_1.java） （提示：用时采用方法System.currentTimeMillis()求时间差。）2.（2） 请使用字节流的方式读出文件exp5_1.txt中内容，然后将文件中的所有奇数写入文件ex5_3.txt中，使用字符流的方式读出文件exp5_2.txt中内容，然后将文件中的所有偶数写入文件exp5_4.txt中。（exp4_2.java）3.（3） 请使用File类的相关方法，遍历（1）、（2）两题所读写的文件所在的目录下的所有文件。（exp5_3.java）

好的，你的第一个问题有三个小问题，我来一一回答。

1. 首先，使用FileWriter往文件exp5_1.txt中写入1万个随机整数（数与数之间用空格隔开）可以这样实现：

import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;

public class Exp5_1 {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis(); // 记录开始时间
        FileWriter fw = new FileWriter("exp5_1.txt");

        Random random = new Random();
        for (int i = 0; i < 10000; i++) {
            fw.write(random.nextInt() + " ");
        }

        fw.close();
        long end = System.currentTimeMillis(); // 记录结束时间
        System.out.println("使用FileWriter写入文件exp5_1.txt用时：" + (end - start) + "ms");
    }
}

使用BufferedWriter往文件exp5_2.txt中写入1万个随机整数（数与数之间用空格隔开）可以这样实现：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;

public class Exp5_1 {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis(); // 记录开始时间
        BufferedWriter bw = new BufferedWriter(new FileWriter("exp5_2.txt"));

        Random random = new Random();
        for (int i = 0; i < 10000; i++) {
            bw.write(random.nextInt() + " ");
        }

        bw.close();
        long end = System.currentTimeMillis(); // 记录结束时间
        System.out.println("使用BufferedWriter写入文件exp5_2.txt用时：" + (end - start) + "ms");
    }
}

2. 接着，使用字节流的方式读出文件exp5_1.txt中内容，然后将文件中的所有奇数写入文件exp5_3.txt中，使用字符流的方式读出文件exp5_2.txt中内容，然后将文件中的所有偶数写入文件exp5_4.txt中可以这样实现：

import java.io.*;

public class Exp5_2 {
    public static void main(String[] args) throws IOException {
        // 读取exp5_1.txt中的所有奇数，写入exp5_3.txt中
        FileInputStream fis = new FileInputStream("exp5_1.txt");
        FileOutputStream fos = new FileOutputStream("exp5_3.txt");

        int num;
        while ((num = fis.read()) != -1) {
            if (num % 2 != 0) { // 判断是否为奇数
                fos.write(num);
            }
        }

        fis.close();
        fos.close();

        // 读取exp5_2.txt中的所有偶数，写入exp5_4.txt中
        FileReader fr = new FileReader("exp5_2.txt");
        FileWriter fw = new FileWriter("exp5_4.txt");

        int n;
        while ((n = fr.read()) != -1) {
            if (n % 2 == 0) { // 判断是否为偶数
                fw.write(n);
            }
        }

        fr.close();
        fw.close();
    }
}

3. 最后，使用File类的相关方法，遍历（1）、（2）两题所读写的文件所在的目录下的所有文件可以这样实现：

import java.io.File;

public class Exp5_3 {
    public static void main(String[] args) {
        // 遍历exp5_1.txt所在目录下的所有文件
        File file1 = new File("exp5_1.txt");
        File dir1 = file1.getParentFile(); // 获取目录
        System.out.println("exp5_1.txt所在目录下的所有文件：");
        File[] files1 = dir1.listFiles(); // 获取目录下的所有文件
        for (File f : files1) {
            System.out.println(f.getName());
        }

        // 遍历exp5_2.txt所在目录下的所有文件
        File file2 = new File("exp5_2.txt");
        File dir2 = file2.getParentFile(); // 获取目录
        System.out.println("exp5_2.txt所在目录下的所有文件：");
        File[] files2 = dir2.listFiles(); // 获取目录下的所有文件
        for (File f : files2) {
            System.out.println(f.getName());
        }
    }
}

希望我的回答能够帮到你！