java readline读到尾后如何从头读

在Java中，读取输入流的方法是通过BufferedReader类中的readLine()方法来实现的。当读取到输入流的末尾时，readLine()方法将返回null。

要从头开始重新读取输入流，可以使用mark()和reset()方法。mark()方法会标记当前输入流的位置，reset()方法会将输入流的位置重置为标记的位置。

以下是一个示例代码，演示如何使用mark()和reset()方法来从头读取输入流：

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

// 读取输入流的第一行
String line = reader.readLine();
while (line != null) {
    // 处理输入流的每一行
    System.out.println(line);
    
    // 标记当前位置
    reader.mark(0);
    
    // 读取下一行
    line = reader.readLine();
    
    // 如果已经读到输入流的末尾，重置输入流的位置为标记的位置
    if (line == null) {
        reader.reset();
        line = reader.readLine();
    }
}

在上面的代码中，我们首先读取输入流的第一行，然后进入一个while循环，处理

相关问题

java多线程实现断点续传

JAVA多线程实现断点续传的思路如下：

1. 将大文件均分成几块，每个线程负责处理一块数据的读取和写入。
2. 每次写入数据时，更新记录的日志文件，记录已经传输的字节数或块数。
3. 当断网或暂停后重新开始传输时，根据日志文件的信息，可以接着读取和写入数据，而不需要从头开始传输。

以下是一个JAVA多线程实现断点续传的示例代码：

import java.io.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FileTransfer {
    private static final int THREAD_COUNT = 4; // 线程数量
    private static final String LOG_FILE = "transfer.log"; // 日志文件名
    private static final String SOURCE_FILE = "source.txt"; // 源文件名
    private static final String TARGET_FILE = "target.txt"; // 目标文件名

    public static void main(String[] args) {
        // 读取日志文件，获取已传输的字节数
        long transferredBytes = readLogFile();

        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);

        // 计算每个线程需要处理的字节数
        long blockSize = new File(SOURCE_FILE).length() / THREAD_COUNT;

        // 创建并执行线程
        for (int i = 0; i < THREAD_COUNT; i++) {
            long start = i * blockSize + transferredBytes;
            long end = (i + 1) * blockSize - 1;
            if (i == THREAD_COUNT - 1) {
                end = new File(SOURCE_FILE).length() - 1;
            }
            executorService.execute(new TransferThread(i, start, end));
        }

        // 关闭线程池
        executorService.shutdown();
    }

    private static long readLogFile() {
        long transferredBytes = 0;
        try {
            File logFile = new File(LOG_FILE);
            if (logFile.exists()) {
                BufferedReader reader = new BufferedReader(new FileReader(logFile));
                String line;
                while ((line = reader.readLine()) != null) {
                    transferredBytes += Long.parseLong(line);
                }
                reader.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return transferredBytes;
    }

    private static void writeLogFile(long transferredBytes) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter(LOG_FILE, true));
            writer.write(String.valueOf(transferredBytes));
            writer.newLine();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class TransferThread implements Runnable {
        private int threadId;
        private long start;
        private long end;

        public TransferThread(int threadId, long start, long end) {
            this.threadId = threadId;
            this.start = start;
            this.end = end;
        }

        @Override
        public void run() {
            try {
                RandomAccessFile sourceFile = new RandomAccessFile(SOURCE_FILE, "r");
                RandomAccessFile targetFile = new RandomAccessFile(TARGET_FILE, "rw");

                sourceFile.seek(start);
                targetFile.seek(start);

                byte[] buffer = new byte[1024];
                int bytesRead;
                long transferredBytes = 0;

                while ((bytesRead = sourceFile.read(buffer)) != -1 && sourceFile.getFilePointer() <= end) {
                    targetFile.write(buffer, 0, bytesRead);
                    transferredBytes += bytesRead;
                }

                writeLogFile(transferredBytes);

                sourceFile.close();
                targetFile.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}