Java实现按行读取大文件

Java实现按行读取大文件

String file = "F:" + File.separator + "a.txt";
FileInputStream fis = new FileInputStream(file);
RandomAccessFile raf = new RandomAccessFile(new File(file),"r");
String s ;
while((s =raf.readLine())!=null){
System.out.println(s);
}
raf.close();
fis.close();

网上流行的那个俩while版本不靠谱

可考虑bufferedinputstream和bufferedoutputstream来字节读取，这个代码太简单了，适用于非频繁操作。或采用nio的FileChannel，比较适合于高并发操作，如下为filechannel的部分代码

File inFile = new File("D:\\error");
File outFile = new File("D:\\to.txt");

FileChannel inFileChannel = new FileInputStream(inFile).getChannel();
FileChannel outFileChannel = new FileOutputStream(outFile).getChannel();

ByteBuffer buffer = ByteBuffer.allocate(1024);
while(-1 != inFileChannel.read(buffer)){
 buffer.flip();
 outFileChannel.write(buffer);
 buffer.clear();
}
outFileChannel.close();
inFileChannel.close();

随机读取文件内容

public class ReadFromFile {
 /**
  * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
  */
 public static void readFileByBytes(String fileName) {
   File file = new File(fileName);
   InputStream in = null;
   try {
     System.out.println("以字节为单位读取文件内容，一次读一个字节：");
     // 一次读一个字节
     in = new FileInputStream(file);
     int tempbyte;
     while ((tempbyte = in.read()) != -1) {
       System.out.write(tempbyte);
     }
     in.close();
   } catch (IOException e) {
     e.printStackTrace();
     return;
   }
   try {
     System.out.println("以字节为单位读取文件内容，一次读多个字节：");
     // 一次读多个字节
     byte[] tempbytes = new byte[100];
     int byteread = 0;
     in = new FileInputStream(fileName);
     ReadFromFile.showAvailableBytes(in);
     // 读入多个字节到字节数组中，byteread为一次读入的字节数
     while ((byteread = in.read(tempbytes)) != -1) {
       System.out.write(tempbytes, 0, byteread);
     }
   } catch (Exception e1) {
     e1.printStackTrace();
   } finally {
     if (in != null) {
       try {
         in.close();
       } catch (IOException e1) {
       }
     }
   }
 }

/**
  * 以字符为单位读取文件，常用于读文本，数字等类型的文件
  */
 public static void readFileByChars(String fileName) {
   File file = new File(fileName);
   Reader reader = null;
   try {
     System.out.println("以字符为单位读取文件内容，一次读一个字节：");
     // 一次读一个字符
     reader = new InputStreamReader(new FileInputStream(file));
     int tempchar;
     while ((tempchar = reader.read()) != -1) {
       // 对于windows下，\r\n这两个字符在一起时，表示一个换行。
       // 但如果这两个字符分开显示时，会换两次行。
       // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
       if (((char) tempchar) != '\r') {
         System.out.print((char) tempchar);
       }
     }
     reader.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
   try {
     System.out.println("以字符为单位读取文件内容，一次读多个字节：");
     // 一次读多个字符
     char[] tempchars = new char[30];
     int charread = 0;
     reader = new InputStreamReader(new FileInputStream(fileName));
     // 读入多个字符到字符数组中，charread为一次读取字符数
     while ((charread = reader.read(tempchars)) != -1) {
       // 同样屏蔽掉\r不显示
       if ((charread == tempchars.length)
           && (tempchars[tempchars.length - 1] != '\r')) {
         System.out.print(tempchars);
       } else {
         for (int i = 0; i < charread; i++) {
           if (tempchars[i] == '\r') {
             continue;
           } else {
             System.out.print(tempchars[i]);
           }
         }
       }
     }

} catch (Exception e1) {
     e1.printStackTrace();
   } finally {
     if (reader != null) {
       try {
         reader.close();
       } catch (IOException e1) {
       }
     }
   }
 }

/**
  * 以行为单位读取文件，常用于读面向行的格式化文件
  */
 public static void readFileByLines(String fileName) {
   File file = new File(fileName);
   BufferedReader reader = null;
   try {
     System.out.println("以行为单位读取文件内容，一次读一整行：");
     reader = new BufferedReader(new FileReader(file));
     String tempString = null;
     int line = 1;
     // 一次读入一行，直到读入null为文件结束
     while ((tempString = reader.readLine()) != null) {
       // 显示行号
       System.out.println("line " + line + ": " + tempString);
       line++;
     }
     reader.close();
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     if (reader != null) {
       try {
         reader.close();
       } catch (IOException e1) {
       }
     }
   }
 }

/**
  * 随机读取文件内容
  */
 public static void readFileByRandomAccess(String fileName) {
   RandomAccessFile randomFile = null;
   try {
     System.out.println("随机读取一段文件内容：");
     // 打开一个随机访问文件流，按只读方式
     randomFile = new RandomAccessFile(fileName, "r");
     // 文件长度，字节数
     long fileLength = randomFile.length();
     // 读文件的起始位置
     int beginIndex = (fileLength > 4) ? 4 : 0;
     // 将读文件的开始位置移到beginIndex位置。
     randomFile.seek(beginIndex);
     byte[] bytes = new byte[10];
     int byteread = 0;
     // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
     // 将一次读取的字节数赋给byteread
     while ((byteread = randomFile.read(bytes)) != -1) {
       System.out.write(bytes, 0, byteread);
     }
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     if (randomFile != null) {
       try {
         randomFile.close();
       } catch (IOException e1) {
       }
     }
   }
 }

/**
  * 显示输入流中还剩的字节数
  */
 private static void showAvailableBytes(InputStream in) {
   try {
     System.out.println("当前字节输入流中的字节数为:" + in.available());
   } catch (IOException e) {
     e.printStackTrace();
   }
 }

public static void main(String[] args) {
   String fileName = "C:/temp/newTemp.txt";
   ReadFromFile.readFileByBytes(fileName);
   ReadFromFile.readFileByChars(fileName);
   ReadFromFile.readFileByLines(fileName);
   ReadFromFile.readFileByRandomAccess(fileName);
 }
}

将内容追加到文件尾部

public class AppendToFile {
 /**
  * A方法追加文件：使用RandomAccessFile
  */
 public static void appendMethodA(String fileName, String content) {
   try {
     // 打开一个随机访问文件流，按读写方式
     RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
     // 文件长度，字节数
     long fileLength = randomFile.length();
     //将写文件指针移到文件尾。
     randomFile.seek(fileLength);
     randomFile.writeBytes(content);
     randomFile.close();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }

/**
  * B方法追加文件：使用FileWriter
  */
 public static void appendMethodB(String fileName, String content) {
   try {
     //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
     FileWriter writer = new FileWriter(fileName, true);
     writer.write(content);
     writer.close();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }

public static void main(String[] args) {
   String fileName = "C:/temp/newTemp.txt";
   String content = "new append!";
   //按方法A追加文件
   AppendToFile.appendMethodA(fileName, content);
   AppendToFile.appendMethodA(fileName, "append end. \n");
   //显示文件内容
   ReadFromFile.readFileByLines(fileName);
   //按方法B追加文件
   AppendToFile.appendMethodB(fileName, content);
   AppendToFile.appendMethodB(fileName, "append end. \n");
   //显示文件内容
   ReadFromFile.readFileByLines(fileName);
 }
}

以上所述就是本文的全部内容了，希望大家能够喜欢。