java快速读取

❶ java中怎样从文件中读取数据

分为读字节，读字符两种读法x0dx0a◎◎◎FileInputStream 字节输入流读文件◎◎◎x0dx0apublic class Maintest {x0dx0ax0dx0apublic static void main(String[] args) throws IOException {x0dx0ax0dx0aFile f=new File("G:\\just for fun\\xiangwei.txt");x0dx0ax0dx0aFileInputStream fin=new FileInputStream(f);x0dx0ax0dx0abyte[] bs=new byte[1024];x0dx0ax0dx0aint count=0;x0dx0awhile((count=fin.read(bs))>0)x0dx0a{x0dx0ax0dx0aString str=new String(bs,0,count);//反复定义新变量：每一次都 重新定义新变量，接收新读取的滚雹数据x0dx0ax0dx0aSystem.out.println(str);//反复输出新变量：察槐每一次都 输出重大没帆新定义的新变量x0dx0a}x0dx0afin.close();x0dx0a}x0dx0a}x0dx0ax0dx0a◎◎◎FileReader 字符输入流读文件◎◎◎x0dx0apublic class Maintest {x0dx0apublic static void main(String[] args) throws IOException {x0dx0ax0dx0aFile f=new File("H:\\just for fun\\xiangwei.txt");x0dx0ax0dx0aFileReader fre=new FileReader(f);x0dx0ax0dx0aBufferedReader bre=new BufferedReader(fre);x0dx0ax0dx0aString str="";x0dx0awhile((str=bre.readLine())!=null)//●判断最后一行不存在，为空x0dx0a{x0dx0aSystem.out.println(str);x0dx0a}x0dx0abre.close();x0dx0a fre.close();x0dx0ax0dx0a}x0dx0ax0dx0a}

❷ java 大量数据如何快速读取

1.将与查询条件相关的字段设置索引
2.建立视图
3.对于频繁查询操作建议使用存储过程
4.优化Sql语句

❸ java如何快速处理大数据

文件读取：首先是一个文件上传，数据入库，10-200万条不等，这里主要考虑到一次性读取，JVM分配出来的栈内存不一定会够（个人对内存这一块还是处于一知半解的状态，所以比较谨慎，若诸位大神有好宽隐的认知，希望评论留下地址分享一下），是依行读取数据，设定一个批量值，当读取的数据达到一定量之后，执行批量入库操作，清空集合，再接着读取。
//读取文件内容
while((s = br.readLine())!=null){
//判断是否达到单次处理量
if(num%leadingNum==0&&num!=0){
int a = stencDao.insertBatch(listBean);
if(a!=leadingNum){
flag = false;
}
//清空集合
listBean.clear();
}
String value = s.trim();
//将读取到的内容放入集合中
if(!value.equals("")){
StencilCustomer bean = new StencilCustomer();
bean.setCustomerPhone(value);
bean.setLinkStencilId(id);
listBean.add(bean);
num ++;
}
}
数据处理：这里的思路也是将数据小化然后处理，这里使用了多线程，设定单个线程处理量，然后开启多个线程处理，这里需要考虑你的服务器的承载能力，如果线程开得太多了，处理不过数敏来，会出现蹦死的情况。慎毕厅例如200万数据，我开了20个线程，单个线程处理600条。
//建立一个线程池 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
minTaskNumber, maxTaskNumber, 3L, TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(minTaskNumber),
new ThreadPoolExecutor.DiscardOldestPolicy());
//当正在执行的线程数达到最大执行线程数的时候等待
boolean flag = true;
while(flag){
Thread.sleep(1000);//休眠2ms查询一次
int c = threadPool.getActiveCount();//线程池中活动中的线程数量
if(c<maxTaskNumber){
flag = false;
}
}
上面的代码是我对线程池的一个控制，控制服务器一直最大线程执行，Thread.sleep(1000);用while的时候，这个休眠最好不要去掉，去掉之后很影响执行效率

❹ 如何利用Java高效读取大文件，利用Java读取文件

可以使用BufferedReader解决高效读取大文件：

具体如下：

例如：BufferedReaderbr=newBufferedReader（newInputStreamReader(inputStream)

❺ 浅谈JAVA读写Excel的几种途径

读写Excel文件需要使用Excel类库，如Free Spire.XLS for Java.

读取Excel内容：

//创建Workbook对象
Workbookwb=newWorkbook();
//加载一个Excel文档
wb.loadFromFile("C:\Users\Administrator\Desktop\test.xlsx");
//获取第一个工作表
Worksheetsheet=wb.getWorksheets().get(0);
//遍历工作表的每一行
for(inti=1;i<sheet.getLastRow()+1;i++){
//遍历工作的每一列
for(intj=1;j<sheet.getLastColumn()+1;j++){
//输出指定单元格的数据
System.out.print(sheet.get(i,j).getText());
System.out.print("	");
}
System.out.print("
");
}

写入内容：

//创建Workbook对象
Workbookwb=newWorkbook();
//加载一个Excel文档
wb.loadFromFile("C:\Users\Administrator\Desktop\test.xlsx");
//获取第一个工作表
Worksheetsheet=wb.getWorksheets().get(0);
//在单元格A1写入新数据
sheet.getCellRange("A1").setText("你好");
//保存文档
wb.saveToFile("写入Excel.xlsx",ExcelVersion.Version2016);

❻ Java 如何读取目录下的文件内容

Java读取目录下的文件内容，使用的是java的文件类，示例如下：

importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.RandomAccessFile;
importjava.io.Reader;

publicclassReadFromFile{
/**
*以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*
*@paramfileName
*文件的名
*/
(StringfileName){
Filefile=newFile(fileName);
InputStreamin=null;
try{
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
//一次读一个字节
in=newFileInputStream(file);
inttempbyte;
while((tempbyte=in.read())!=-1){
System.out.write(tempbyte);
}
in.close();
}catch(IOExceptione){
e.printStackTrace();
return;
}
try{
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
//一次读多个字节
byte[]tempbytes=newbyte[100];
intbyteread=0;
in=newFileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while((byteread=in.read(tempbytes))!=-1){
System.out.write(tempbytes,0,byteread);
}
}catch(Exceptione1){
e1.printStackTrace();
}finally{
if(in!=null){
try{
in.close();
}catch(IOExceptione1){
}
}
}
}

/**
*以字符为单位读取文件，常用于读文本，数字等类型的文件
*
*@paramfileName
*文件名
*/
(StringfileName){
Filefile=newFile(fileName);
Readerreader=null;
try{
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
//一次读一个字符
reader=newInputStreamReader(newFileInputStream(file));
inttempchar;
while((tempchar=reader.read())!=-1){
//对于windows下，
这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉
，或者屏蔽
。否则，将会多出很多空行。
if(((char)tempchar)!='
'){
System.out.print((char)tempchar);
}
}
reader.close();
}catch(Exceptione){
e.printStackTrace();
}
try{
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
//一次读多个字符
char[]tempchars=newchar[30];
intcharread=0;
reader=newInputStreamReader(newFileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while((charread=reader.read(tempchars))!=-1){
//同样屏蔽掉
不显示
if((charread==tempchars.length)
&&(tempchars[tempchars.length-1]!='
')){
System.out.print(tempchars);
}else{
for(inti=0;i<charread;i++){
if(tempchars[i]=='
'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}

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

/**
*以行为单位读取文件，常用于读面向行的格式化文件
*
*@paramfileName
*文件名
*/
(StringfileName){
Filefile=newFile(fileName);
BufferedReaderreader=null;
try{
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader=newBufferedReader(newFileReader(file));
StringtempString=null;
intline=1;
//一次读入一行，直到读入null为文件结束
while((tempString=reader.readLine())!=null){
//显示行号
System.out.println("line"+line+":"+tempString);
line++;
}
reader.close();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
}

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

/**
*显示输入流中还剩的字节数
*
*@paramin
*/
(InputStreamin){
try{
System.out.println("当前字节输入流中的字节数为:"+in.available());
}catch(IOExceptione){
e.printStackTrace();
}
}

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