请教怎样从文件读到的内容一行行分析

Question

需要读取一行时，设计到ascii码判断，所以建议不要使用NIO，使用io包里的BufferedReader中的readLine方法读取

Answer 1

NIO不能一行一行 readline吗？

Answer 2

这个是我目前测试的最快读取文本文件的方式了。不过没法看啊
不像bufferreader那样，readline很方便

Answer 3

A FileInputStream obtains input bytes from a file in a file system. What files are available depends on the host environment. FileInputStream is meant for reading streams of raw bytes such as image data. For reading streams of characters, consider using FileReader.public void getFile2(){
try {
File file = new File("E:\\a.txt");
BufferedReader br = new BufferedReader(new FileReader(file));
BufferedWriter bw = new BufferedWriter(new FileWriter(new File("E:\\b.txt"))); String line = "";
while ((line = br.readLine()) != null) {
System.out.println(line);
bw.write(line);
}
} catch (Exception e) {
e.printStackTrace();
}
}

Answer 4

楼主用的方法不常用。不评论，发一种常用的方法，可以一行一行的读取。package com.briup.ch11;
//第一个
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.Buffer;public class FileInputOutputTest {
public static void main(String[] args) {
//声明流，
FileInputStream fis=null;
//包装流
BufferedInputStream bis=null;

FileOutputStream fos=null;
BufferedOutputStream bos=null;
//初始化并且包装流
try {
//要存储的源文件
fis=new FileInputStream("src/com/briup/ch11/FileInputOutputTest.java");
bis = new BufferedInputStream(fis);
//要保存的文件的位置
fos=new FileOutputStream("src/com/briup/ch11/FileInputOutputTest.txt");
bos = new BufferedOutputStream(fos);
//输入流读取文件
byte[] buff=new byte[128];
int len=0;
while((len=bis.read(buff))!=-1){
System.out.println(new String(buff,0,len));
bos.write(buff,0,len);
}
//输出流需要刷新缓冲区
bos.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
//关闭释放流
if(bis!=null)bis.close();
if(fis!=null)bis.close();
if(bos!=null)bos.close();
if(fos!=null)fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}
}

Answer 5

直接看java一下BufferedReader中的readLine方法源代码，自己分析一下，就OK了。

Answer 6

另外FileInputStream这个流貌似不提供定位的功能。
分批读取的意思是一次读取一部分，这样多线程读取大数据量的信息是么？
如果那样的需要用到
PipedInputStream
PipedOutputStream
管道流，记得还有一个是可以定位读取的流，临时忘了，帮你查查API吧

Answer 7

import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.charset.Charset;List<String> lines = Files.readAllLines(Paths.get("D:/Temp", "examples.txt"), Charset.defaultCharset());

Answer 8

谢谢，测试了你的第二种方法，很慢，比bufferreader慢3.5倍

Answer 9

public static void main(String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("1.txt", "r");
FileChannel fileChannel = file.getChannel();
ByteBuffer buffer = fileChannel.map(MapMode.READ_ONLY, 0, fileChannel.size());
CharBuffer charBuffer = Charset.forName("utf-8").decode(buffer);
file.close();
BufferedReader bufferedReader = new BufferedReader(new StringReader(charBuffer.toString()));
String str = null;
while((str = bufferedReader.readLine()) != null){
System.out.println(str);
}
}用BufferedReader包装一下就行了,
不过文件大了受不了，
你可以考虑每次读定长，
然后再往后一直读到换行符为止

Answer 10

这样能比BUFFERRADER快吗？如果不能快，就没意思了
文件有1.2G吧

Answer 11

谢谢，能不能把那个allocatedirect 也就是 direct
 buffer也包装进去？
谢谢

Answer 12

什么叫做比BufferedReader慢，
你说的慢是因为平时用的时候，它的底层数据是从FileInputStream里面来的，
BufferedReader本身是跟Stream什么都没有关系的，
它只负责操作你给它的数据，
你给它数据的时候慢，当然它给你结果就慢
你把一个内存里面的字符串直接让BufferedReader读，那还会觉得慢？

Answer 13

另外想再请教一下，readline 后
怎样以最快的方式判断这一行是否含有比如：“你”，“我”等字符串？
特征是“你”“我”等字符串总是出现在行的比较靠右边的位置，比如"8457TRGDF","FSAFDFFDF","FSFKJDHFSF","哦你好啊","AA"

Answer 14

谢谢，我的意思是和下面代码比，哪个更快？BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
       reader.readLine();
       String line = null;
       String item[];
       for (String line = null; (line = reader.readLine()) != null;)
       {
       }

Answer 15

public static void main(String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("1.txt", "r");
FileChannel fileChannel = file.getChannel();
//这个地方要按文件大小来，如果实在要定长就只能按先前说的，继续往后读到换行符
//或者把已经读过但是没有凑成正行的put回去，然后compact，再继续读
ByteBuffer buffer = ByteBuffer.allocateDirect((int) fileChannel.size());
fileChannel.read(buffer);
buffer.flip();
CharBuffer charBuffer = Charset.forName("utf-8").decode(buffer);
file.close();
BufferedReader bufferedReader = new BufferedReader(new StringReader(charBuffer.toString()));
String str = null;
while((str = bufferedReader.readLine()) != null){
System.out.println(str);
}
}你是要这样？

Answer 16

当然用nio的更快咯，他是一整块内存直接读的
new FileReader("test.txt"))这个是按stream读的
底层操作会比nio的多很多

Answer 17

我已经糊涂了，NIO,DIRECT BUFFER(ALLOCATEDIRET)
CHANNEL简单说吧，如下代码是我目前知道的最快的方式了，是否有更快的？
NIO结合channel我测试了，比下面的快13%，但是是读到buffer，然后从buffer解码，再读成一行一行，貌似反而更慢了
BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
       reader.readLine();
       String line = null;
       String item[];
       while ((line = reader.readLine()) != null)
       {
       }

Answer 18

不只是判断一个字符，有好几个，如果正则是很慢的，不考虑
但是如果 indexOf N次，就会遍历字符串N次，也慢

Answer 19

你是怎么测的？
我刚试过了，一个11M的小说txt文件，
读出来转码并存到ArrayList,
用nio只用50ms左右
用FileReader花了235ms
代码在下面你可以试试看？nio的 RandomAccessFile file = new RandomAccessFile("b.txt", "r");
FileChannel fileChannel = file.getChannel();
ByteBuffer buffer = ByteBuffer.allocateDirect((int) fileChannel.size());
fileChannel.read(buffer);
buffer.flip();
CharBuffer charBuffer = Charset.forName("utf-8").decode(buffer);
file.close();
BufferedReader bufferedReader = new BufferedReader(new StringReader(charBuffer.toString()));
List<String> list = new ArrayList<String>();
long time = System.currentTimeMillis();
String str = null;
while((str = bufferedReader.readLine()) != null){
list.add(str);
}
System.out.println(System.currentTimeMillis() - time);
FileReaderBufferedReader bufferedReader = new BufferedReader(new FileReader("b.txt"));
String str = null;
long time = System.currentTimeMillis();
List<String> list = new ArrayList<String>();
while((str = bufferedReader.readLine()) != null){
list.add(str);
}
System.out.println(System.currentTimeMillis() - time);

Answer 20

NIO:是文件映射内存的方式，可以方便你处理大文件。不用担心由于文件过大一次读到内存中造成内存溢出
BufferedReader ，这个方式应该比没有缓冲区的读速度快。因为他是从文件中分批读取内容的。
传统的没有缓冲区的文件读取速度最慢。
如果是小文件很显然BufferedReader要更快，但是大文件我想目前只能用NIO去处理了。