Java程序设计实验7 | IO流

已于 2024-01-27 15:01:03 修改
阅读量949 收藏 20
点赞数 26
分类专栏： 专业课 文章标签： java 实验报告 河南大学 软件学院 学习
于 2024-01-27 11:28:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyd_333/article/details/135862249
版权

*本文是博主对Java各种实验的再整理与详解，除了代码部分和解析部分，一些题目还增加了拓展部分（⭐）。拓展部分不是实验报告中原有的内容，而是博主本人自己的补充，以方便大家额外学习、参考。

目录

一、实验目的

二、实验内容

1、判断E盘指定目录下是否有后缀名为.jpg的文件，如果有就输出此文件名称。

 2、分别使用字节流和字节缓冲流的两种读取方式实现对图片文件的复制操作并比较两种方式在复制时间上的效率。

3、编写一个程序，分别使用转换流、字符流和缓冲字符流拷贝一个文本文件。

4、编程序实现下列功能

5、复制指定目录中的指定类型（如.java）的文件到另一个目录中。

6、已知s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”，请编写程序读取数据内容，把数据排序后写入ss.txt中。

三、实验总结

一、实验目的

1、理解字节流和字符流的含义，掌握IO流的分类；

2、掌握File类的使用；

3、掌握文件字节流FileInputStream、FileOutputStream和文件字符流FileReader、FileWriter的使用；

4、掌握字符缓冲流BufferedReader、BufferedWriter的使用；

5、了解转换流OutputStreamWriter和InputStreamReader的使用；

6、能够灵活使用IO流完成数据的处理。

二、实验内容

1、判断E盘指定目录下是否有后缀名为.jpg的文件，如果有就输出此文件名称。

由于博主电脑没设E盘，因此路径改为D盘。路径下内容为：

通过Java的文件操作来实现。File类是 Java 中抽象表示文件和目录路径名的一个类，它提供了一系列方法，可以用于创建、删除、重命名等文件和目录的基本操作，以及获取文件信息。在实现该练习时，用到了如下几个方法：

  1. File directory = new File(directoryPath)    这是根据目录路径创建File对象，目录路径是我们事先指定的目标路径，指定的路径是哪个，后续就对哪个路径进行操作。可以把File对象理解成我们要进行文件操作的遥控器。操作系统是对文件系统的直接管理，而我们用户要操作文件，是通过创建File对象、调用File对象中的各种方法实现的。（这个形式和socket操作网卡，thread操作线程类似。）
  2. File[] files = directory.listFiles()    获取目录下的所有文件，用File数组来接收。在博主本人的程序中，获取到的就是test.jpg和fox.png这两个文件。获取目录下所有文件的操作往往和遍历数组配合使用，以搭配条件语句对目录下的文件进行过滤，如： 
    File[] files = directory.listFiles(); // 获取目录下的文件和子目录列表
for (File file : files) {
    // 处理每个文件或目录
}
  3. file.isFile()    用于判断file对象是否是一个文件。
  4. file.getName().toLowerCase().endsWith(".jpg")    用于判断file对象名是否以“.jpg”结尾。getName()获取到file对象的文件名（是一个字符串），后面的toLowerCase().endsWith(".jpg")是字符串String的方法。

源代码：

import java.io.File;

public class S7_1 {
    public static void main(String[] args) {
        // 指定目录路径
        String directoryPath = "D:\\ASSIGNMENT\\code\\javacode\\leetcode-test\\imgdir";
        
        // 创建File对象
        File directory = new File(directoryPath);
        
        // 获取目录下所有文件
        File[] files = directory.listFiles();
        
        // 遍历文件列表
        if (files != null) {
            for (File file : files) {
                // 判断文件是否以.jpg结尾
                if (file.isFile() && file.getName().toLowerCase().endsWith(".jpg")) {
                    // 输出文件名称
                    System.out.println(file.getName());
                }
            }
        } else {
            System.out.println("指定目录不存在或不是一个目录！");
        }
    }
}

列出测试数据和实验结果截图：

 2、分别使用字节流和字节缓冲流的两种读取方式实现对图片文件的复制操作并比较两种方式在复制时间上的效率。

字节流和字节缓冲流是 Java 中用于处理二进制数据的输入输出流类，用于进行字节级别的数据读写操作。

1、字节流：

  • 字节流以字节为单位进行数据传输，适用于处理二进制数据，如图片、音频、视频等文件。
  • InputStream 和 OutputStream 是 Java 中用于操作字节流的抽象基类。
  • 常见的字节流类包括 FileInputStream、FileOutputStream、ByteArrayInputStream、ByteArrayOutputStream 等。

2、字节缓冲流：

  • 字节缓冲流是对字节流的一种包装，在读写过程中加入了缓冲区，以提高读写效率。
  • 通过使用缓冲区，可以减少实际读写硬盘的次数，从而提高了数据传输的效率。
  • 常见的字节缓冲流类包括 BufferedInputStream 和 BufferedOutputStream。

理解一下“缓冲区”：可以想象有一个工人正在开卡车搬运箱子，他的任务是把箱子从A厂转移到B厂。箱子有很多，如果此时他一个一个搬运，每在A厂将一个箱子放上卡车就开车运到B厂，这样的效率是非常低的且有很多不必要的开销；而如果他先在A厂把所有要搬的箱子都放到一辆卡车上，等要搬运的箱子都放上卡车后一趟直接开到B厂，那么这样他只需要跑一趟就能一块搬运完所有的箱子，这样是效率更高也更节约资源的。

使用字节缓冲流相比直接使用字节流，可以提高读写效率（特别是在处理大文件时）。因为字节缓冲流会将数据先写入内存缓冲区，待缓冲区满或达到一定条件时再一次性写入文件，减少了频繁的硬盘读写操作。

如果需要处理二进制数据且关注性能和效率，通常会选择使用字节缓冲流来进行文件读写操作。

其他细节处理如下：

  1. 如何比较时间效率？经典的方法是分别记录下程序执行前的时间戳和程序执行完毕后的时间戳，二者的时间间隔即程序运行的时间。常用代码如下： 
    long startTime1 = System.currentTimeMillis();
// do something...
long endTime1 = System.currentTimeMillis();
long timeByByteStream = endTime1 - startTime1;
  2. 分别定义方法copyFileByByteStream（字节流复制文件）和copyFileByBufferedStream（字节缓冲流）复制文件。两个方法的逻辑相同，即分别创建输入对象in和输出对象out，通过调用in的read方法读取source.jpg到一个变量，再通过out的write方法将该变量中的内容写入输出目录。
  3. 在try中申请资源，这样在在try块结束时会自动关闭这些资源，以确保资源被正确释放，避免资源泄露。
  4. source.jpg存放的位置：必须在工程项目Project目录下时，创建文件对象才能直接使用文件名（也即相对路径），否则必须使用绝对路径。如：

源代码：

import java.io.*;

public class S7_2 {
    public static void main(String[] args) {
        String sourceFilePath = "source.jpg"; // 源文件路径
        String destFilePath1 = "dest1.jpg";   // 目标文件路径（字节流复制）
        String destFilePath2 = "dest2.jpg";   // 目标文件路径（字节缓冲流复制）

        // 使用字节流复制图片文件并计时
        long startTime1 = System.currentTimeMillis();
        copyFileByByteStream(sourceFilePath, destFilePath1);
        long endTime1 = System.currentTimeMillis();
        long timeByByteStream = endTime1 - startTime1;

        // 使用字节缓冲流复制图片文件并计时
        long startTime2 = System.currentTimeMillis();
        copyFileByBufferedStream(sourceFilePath, destFilePath2);
        long endTime2 = System.currentTimeMillis();
        long timeByBufferedStream = endTime2 - startTime2;

        // 输出复制时间
        System.out.println("使用字节流复制图片文件耗时：" + timeByByteStream + " 毫秒");
        System.out.println("使用字节缓冲流复制图片文件耗时：" + timeByBufferedStream + " 毫秒");
    }

    // 使用字节流复制文件的方法
    private static void copyFileByByteStream(String sourcePath, String destPath) {
        try (InputStream in = new FileInputStream(sourcePath);
             OutputStream out = new FileOutputStream(destPath)) {
            int byteRead;
            while ((byteRead = in.read()) != -1) {
                out.write(byteRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 使用字节缓冲流复制文件的方法
    private static void copyFileByBufferedStream(String sourcePath, String destPath) {
        try (InputStream in = new BufferedInputStream(new FileInputStream(sourcePath));
             OutputStream out = new BufferedOutputStream(new FileOutputStream(destPath))) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

列出测试数据和实验结果截图： 

3、编写一个程序，分别使用转换流、字符流和缓冲字符流拷贝一个文本文件。

要求：

• 分别使用InputStreamReader、OutputStreamWriter类和FileReader、FileWriter类用两种方式（字符和字符数组）进行拷贝。

• 使用BufferedReader、BufferedWriter类的特殊方法进行拷贝。

源代码：

import java.io.*;

public class S7_3 {
    public static void main(String[] args) {
        String sourceFilePath = "source.txt";
        String destFilePath = "destination.txt";

        // 使用转换流拷贝文件（字符方式）
        copyFileWithInputStreamReader(sourceFilePath, destFilePath);

        // 使用转换流拷贝文件（字符数组方式）
        copyFileWithInputStreamReaderAndCharArray(sourceFilePath, destFilePath);

        // 使用字符流拷贝文件
        copyFileWithFileReader(sourceFilePath, destFilePath);

        // 使用字符流拷贝文件（字符数组方式）
        copyFileWithFileReaderAndCharArray(sourceFilePath, destFilePath);

        // 使用缓冲字符流拷贝文件
        copyFileWithBufferedReader(sourceFilePath, destFilePath);
    }

    // 使用转换流拷贝文件（字符方式）
    private static void copyFileWithInputStreamReader(String sourceFilePath, String destFilePath) {
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream(sourceFilePath));
             OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(destFilePath))) {
            int data;
            while ((data = reader.read()) != -1) {
                writer.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 使用转换流拷贝文件（字符数组方式）
    private static void copyFileWithInputStreamReaderAndCharArray(String sourceFilePath, String destFilePath) {
        try (InputStreamReader reader = new InputStreamReader(new FileInputStream(sourceFilePath));
             OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(destFilePath))) {
            char[] buffer = new char[1024];
            int length;
            while ((length = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 使用字符流拷贝文件
    private static void copyFileWithFileReader(String sourceFilePath, String destFilePath) {
        try (FileReader reader = new FileReader(sourceFilePath);
             FileWriter writer = new FileWriter(destFilePath)) {
            int data;
            while ((data = reader.read()) != -1) {
                writer.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 使用字符流拷贝文件（字符数组方式）
    private static void copyFileWithFileReaderAndCharArray(String sourceFilePath, String destFilePath) {
        try (FileReader reader = new FileReader(sourceFilePath);
             FileWriter writer = new FileWriter(destFilePath)) {
            char[] buffer = new char[1024];
            int length;
            while ((length = reader.read(buffer)) != -1) {
                writer.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 使用缓冲字符流拷贝文件
    private static void copyFileWithBufferedReader(String sourceFilePath, String destFilePath) {
        try (BufferedReader reader = new BufferedReader(new FileReader(sourceFilePath));
             BufferedWriter writer = new BufferedWriter(new FileWriter(destFilePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 列出测试数据和实验结果截图： 

生成的目标文件：

建议：同学们在完成该程序时，让每种方法保存的文件名都不相同。我这里因为所有的目标文件名都指定成了destination.txt，所以存在覆盖保存的情况，最终就只有一个目标文件了。

4、编程序实现下列功能

• 向指定的txt文件中写入键盘输入的内容，然后再重新读取该文件的内容，显示到控制台上。

• 键盘录入5个学生信息(姓名, 成绩)，按照成绩从高到低追加存入上述的文本文件中。

首先进行准备工作，在Project目录下创建两个txt文件备用：

确保这两个文件是空的，然后编写代码。几个关键步骤说明：

  1. 为了让代码更加规范，建议将文件名定义成只读常量，以static final修饰。
  2. 定义writeToFile()和readFromFile()方法，分别用于向指定的txt文件中写入键盘输入的内容以及重新读取文件内容并显示到控制台上（题目的第一个要求）。代码如下： 
        // 向指定的txt文件中写入键盘输入的内容
    private static void writeToFile() {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_PATH1))) {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String line;
            System.out.println("请输入要写入文件的内容（输入exit结束）：");
            while (!(line = reader.readLine()).equalsIgnoreCase("exit")) {
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
        // 重新读取文件内容并显示到控制台上
    private static void readFromFile() {
        try (BufferedReader reader = new BufferedReader(new FileReader(FILE_PATH1))) {
            System.out.println("\n从文件中读取的内容：");
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

  3. 题干第二个要求：如何实现成绩排序？推荐使用自定义的Comparator比较器。首先定义List<String>用于接收读取出来的结果，然后调用List对象的sort()进行排序，这里要传入的就是比较器。比较器中可以定义比较规则。

                lines.sort(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    int score1 = Integer.parseInt(o1.split(" ")[1]);
                    int score2 = Integer.parseInt(o2.split(" ")[1]);
                    return Integer.compare(score2, score1);
                }
            });

    注意，由于我们要比较的学生的成绩，也即我们输入内容的第2列，因此比较器或者说比较规则是一定要设置的，否则sort()方法并不知道我们要依据哪个内容来进行排序。关于比较器的内容这里不作补充，有需要的同学可以自行搜索Java的Comparator类进行了解。

源代码：

import java.io.*;
import java.util.*;

public class S7_4 {
    private static final String FILE_PATH1 = "test.txt";
    private static final String FILE_PATH2 = "students.txt";

    public static void main(String[] args) {
        // 向指定的txt文件中写入键盘输入的内容
        writeToFile();

        // 重新读取文件内容并显示到控制台上
        readFromFile();

        // 键盘录入5个学生信息，并按成绩从高到低追加存入文件
        appendStudentInfoToFile();
    }

    // 向指定的txt文件中写入键盘输入的内容
    private static void writeToFile() {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_PATH1))) {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String line;
            System.out.println("请输入要写入文件的内容（输入exit结束）：");
            while (!(line = reader.readLine()).equalsIgnoreCase("exit")) {
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 重新读取文件内容并显示到控制台上
    private static void readFromFile() {
        try (BufferedReader reader = new BufferedReader(new FileReader(FILE_PATH1))) {
            System.out.println("\n从文件中读取的内容：");
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 键盘录入5个学生信息，并按成绩从高到低追加存入文件
    private static void appendStudentInfoToFile() {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_PATH2, true))) {
            Scanner scanner = new Scanner(System.in);
            for (int i = 0; i < 5; i++) {
                System.out.println("\n请输入学生信息（姓名 成绩）：");
                String name = scanner.next();
                int score = scanner.nextInt();
                writer.write(name + " " + score);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 按成绩从高到低排序学生信息
        sortStudentInfoByScore();
    }

    // 按成绩从高到低排序学生信息
    private static void sortStudentInfoByScore() {
        List<String> lines = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new FileReader(FILE_PATH2))) {
            String line;
            while ((line = reader.readLine()) != null) {
                lines.add(line);
            }
            // 使用自定义的比较器按成绩从高到低排序
            lines.sort(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    int score1 = Integer.parseInt(o1.split(" ")[1]);
                    int score2 = Integer.parseInt(o2.split(" ")[1]);
                    return Integer.compare(score2, score1);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 将排序后的学生信息重新写入文件
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_PATH2))) {
            for (String line : lines) {
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意每次运行前，最好都确认一下两个提前准备好的文件是空的，或者没有格式非法的数据。 

列出测试数据和实验结果截图：

控制台

文件 

输入的内容
已排完序

5、复制指定目录中的指定类型（如.java）的文件到另一个目录中。

提前在Project目录下准备好要复制的文件：

 源代码：

import java.io.*;

public class S7_5 {
    public static void main(String[] args) {
        String sourceDirectory = "source_directory"; // 源目录路径
        String destinationDirectory = "destination_directory"; // 目标目录路径
        String fileExtension = ".java"; // 要复制的文件类型

        copyFilesByExtension(sourceDirectory, destinationDirectory, fileExtension);
    }

    // 复制指定目录中指定类型的文件到另一个目录中
    private static void copyFilesByExtension(String sourceDirectory, String destinationDirectory, String fileExtension) {
        File sourceDir = new File(sourceDirectory);
        File destDir = new File(destinationDirectory);

        // 确保目标目录存在
        if (!destDir.exists()) {
            destDir.mkdirs();
        }

        // 检查源目录是否存在
        if (sourceDir.exists() && sourceDir.isDirectory()) {
            File[] files = sourceDir.listFiles(new FilenameFilter() {
                @Override
                public boolean accept(File dir, String name) {
                    return name.endsWith(fileExtension);
                }
            });

            if (files != null) {
                for (File file : files) {
                    File destFile = new File(destDir, file.getName());
                    try (InputStream in = new FileInputStream(file);
                         OutputStream out = new FileOutputStream(destFile)) {
                        byte[] buffer = new byte[1024];
                        int length;
                        while ((length = in.read(buffer)) > 0) {
                            out.write(buffer, 0, length);
                        }
                        System.out.println("复制文件成功: " + destFile.getAbsolutePath());
                    } catch (IOException e) {
                        System.out.println("复制文件失败: " + file.getAbsolutePath());
                        e.printStackTrace();
                    }
                }
            } else {
                System.out.println("源目录中没有指定类型的文件");
            }
        } else {
            System.out.println("源目录不存在或不是目录");
        }
    }
}

列出测试数据和实验结果截图：

6、已知s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”，请编写程序读取数据内容，把数据排序后写入ss.txt中。

s.txt内容：

源代码： 

import java.io.*;
import java.util.Arrays;

public class S7_6 {
    public static void main(String[] args) {
        String sourceFileName = "s.txt"; // 源文件名
        String destinationFileName = "ss.txt"; // 目标文件名

        // 读取数据内容
        String data = readDataFromFile(sourceFileName);

        if (data != null && !data.isEmpty()) {
            // 排序数据内容
            String sortedData = sortString(data);

            // 写入到目标文件中
            writeDataToFile(destinationFileName, sortedData);
        } else {
            System.out.println("源文件中没有数据或文件不存在");
        }
    }

    // 读取数据内容
    private static String readDataFromFile(String fileName) {
        StringBuilder content = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return content.toString();
    }

    // 对字符串进行排序
    private static String sortString(String input) {
        char[] chars = input.toCharArray();
        Arrays.sort(chars);
        return new String(chars);
    }

    // 将数据写入文件中
    private static void writeDataToFile(String fileName, String data) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {
            writer.write(data);
            System.out.println("数据已写入文件 " + fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

列出测试数据和实验结果截图：

三、实验总结

本次实验中我编写了Java程序实现IO控制，如利用File类和FileInputStream/FileOutputStream类实现了复制指定目录中指定类型的文件到另一个目录中的功能；使用BufferedReader/BufferedWriter类和OutputStreamWriter/InputStreamReader类完成从指定文件中读取数据内容，对其进行排序后写入到另一个文件中的任务的功能等。以下是我的总结：
1. 我学会了如何使用Java中的File类来进行文件和目录的操作，包括创建文件、删除文件、获取文件信息等。
2. 我掌握了如何使用FileInputStream和FileOutputStream类来进行文件的读取和写入操作，实现了文件的复制功能。
3. 我理解了BufferedReader和BufferedWriter类的作用，学会了如何利用它们来提高文件读写的效率。
4. 我了解了OutputStreamWriter和InputStreamReader的使用方法，学会了如何使用转换流来进行字符流和字节流之间的转换操作。
5. 初次接触OutputStreamWriter和InputStreamReader时，我对字符流和字节流之间的转换操作不太理解，特别是如何正确地使用转换流进行转换的过程。在实验中我也遇到了一些异常处理方面的问题，如捕获并处理文件操作出现的IOException。
6. 我通过阅读官方文档和查阅相关资料加深了对OutputStreamWriter和InputStreamReader的理解，解决了以上遇到的困难，同时结合实际代码练习，逐步掌握了它们的正确使用方法。

碳基肥宅
关注
  • 26
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
韶关学院2016《Java语言程序设计》实验大纲
12-12
Java 运行环境的安装与测试、Java基本语句练习、面向对象程序设计、异常处理的练习、多线程的编程、常用组件的使用方法、事件处理方法的设计、菜单与工具栏与状态栏的设计、IO流与文件存取、Java网络编程等10个实验...
Java综合实验---学生信息管理系统
10-01
编写一个程序，综合运用集合、IO流等相关操作，编程实现以下要求： 1) 定义一个父类，并定义多个不同子类，子类分别以不同方式重写父类的方法； 2) 定义多个类型的对象，编写方法实现多态效果； 3) 将多个对象存放在...
Java IO流动（实战操作）
朱大虾
08-27 153
java IO流原理、IO流的分类。FileInputStream、FileOutputStream、BufferInputStream等常用输入输出流的代码实操。流的常用使用场景，怎么将文件从前端传输给后台，后台将文件返回给前端。
Java基础IO流综合实例
高级程序猿一枚，多年前后端经验。记录分享遇到问题，了解最新知识。
10-20 654
一，问题描述 有五个学生，每个学生有3门课的成绩 从键盘输入以上数据(包括姓名，三门课成绩) 输入的格式：如：zhangsan,30,40,50计算出总成绩 并把学生的信息和计算出的总分数从高到底顺序存放在磁盘文件“Stud.txt”中二，思路 1、首先我们需要一个学生对象(Student)，再需要一个容器来存储这些学生对象，由于学生对象需要按总分数排序，所以需要一个能排序的容器，这...
实验7：Java IO操作
m0_58355897的博客
12-30 911
实验7：Java IO操作
Java实验三报告IO流
david2000999的博客
05-02 4701
实验目的： 了解Java IO，掌握IO处理的设计方法。重点掌握Java IO主要的类如下： 1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。 2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。 3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。 4.FileOutputStr
Java-IO流实验
害怕也得前进
06-14 767
IO流实验
西南科技大学Java程序设计与实践 实验五 IO实验--记事本
06-14
西南科技大学Java程序设计与实践 实验五 IO实验--记事本 一、实验目的：练习输入/输出流的创建、转换及数据访问设计方法。 二、实验内容：设计一个类似Windows记事本的Application应用程序。 三、实验要求：1、采用...
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_07 IO输入输出（共30页）.ppt
12-26
完整版 杭州电子科技大学JAVA语言程序设计 JAVA_07 IO输入输出（共30页）.ppt 完整版 杭州电子科技大学JAVA语言程序设计 JAVA_08 AWT图形界面编程 JFC AWT Swing（共56页）.ppt 完整版 杭州电子科技大学JAVA语言程序...
java语言程序设计教程与上机实训
11-11
教程与上机实训相结合 更利于掌握java程序设计
java实验十三io_java第14周实验（IO流）
weixin_31533357的博客
03-08 151
0. 字节流与二进制文件###我的代码public class WriterStu {public static void main(String[] args) {DataOutputStream dos = null;Student[] stus = new Student[100];Student d1 = new Student(1, "x", 18, 99.5);Student d2 =...
Java实验5 IO流 第四题
葉蕖的博客
11-28 2443
设计学生类Student，属性：学号（整型）；姓名（字符串），选修课程（名称）及课程成绩（整型）。编写一个控制台程序，能够实现Student信息的保存、读取。具体要求：（1）提供Student信息的保存功能：通过控制台输入若干个学生的学号、姓名以及每个学生所修课程的课程名和成绩，将其信息保存到data.dat中；（2）数据读取显示：能够从data.dat文件中读取学生及其课程成绩并显示于控制台。 ...
Java的IO流大总结
鲜橙的思维空间
02-26 342
Java中的流，可以从不同的角度进行分类。按照数据流的方向不同可以分为：输入流和输出流。 按照处理数据单位不同可以分为：字节流和字符流。 按照功能不同可以分为：节点流和处理流。字节流：一次读入或读出是8位二进制（也就是一个字节） 字符流：一次读入或读出是16位二进制（char在Java中是16位的，因为Java用的是Unicode） Stream是字节流，Reader，Writer是字符流。
android高斯模糊填充imageview背景
cf8833的博客
05-21 568
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
Spring Bean Map之舞
m0_51176516的博客
05-23 508
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 241
1，引入核心关键依赖。
深入理解Java的垃圾回收机制（GC）实现原理
最新发布
微笑听雨
05-25 866
GC是Java虚拟机的重要组成部分，通过自动内存管理，GC提高了Java程序的稳定性和安全性。理解GC的工作原理和不同收集器的特点，有助于选择合适的GC策略，优化应用性能。通过合理配置JVM参数，可以提高GC效率，减少应用停顿时间，提升系统的整体性能。
微信小程序uniapp+django洗脚按摩足浴城消费系统springboot
QQ1304979694的博客
05-24 519
Python语言官方规范访问数据库的统一接口规范(Python DB-API)，防止在使用不同数据库时，由于底层数据库技术不同造成接口程序紊乱的问题。（3）项目初期开发，美工设计，前端实现，开发信息系统的用户功能的实现，完善界面排版，实现信息提取发送等一系列功能。项目系统最后阶段的修改及最终测试运行。当然，在研究过程中也可以直接调查，对调查搜集到的资料进行综合分析、比较，调查法是科学研究中普遍的研究方法。（5）系统测试：对设计好的程序进行最终调试，通过调试发现存在的问题并解决，从而达到完善系统的目的。
java程序设计实验
08-25
Java程序设计实验需要具备以下几个基本条件： 1. 熟悉Java应用程序的编写、编译和运行流程。 2. 熟悉Java程序的基本结构，能够编写最简单的Java程序。 3. 掌握一种Java的标准输入输出处理方法。 4. 学会编写包含选择与循环结构的简单Java程序。 在实验环境中，可以使用Java编程语言进行实验。在Java中，通常需要在主类中定义一个名为"main"的方法作为程序的入口点。该方法的声明通常是"public static void main(String[] args)"，其中"args"是用于接收命令行参数的字符串数组。在实验中，需要在该方法中实现具体的功能代码。 在实验中，可以使用Java的输入输出流来实现对数据的输入和输出操作。可以使用"java.io"包中提供的类和方法来处理标准输入和输出。 总之，Java程序设计实验需要具备编写和运行Java程序的基本知识，同时还需要了解Java的输入输出处理方法。可以在实验环境中运行具有选择和循环结构的简单Java程序。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [【JAVA程序设计】实验一：简单程序设计](https://blog.csdn.net/w_1106/article/details/108922536)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [java程序设计——实验三](https://blog.csdn.net/weixin_48388330/article/details/122494479)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [undefined](undefined)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值