Qual é o caminho mais rápido para ler um grande número de pequenos arquivos em memória?
https://stackoverflow.com/questions/625420
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu preciso ler ~ 50 arquivos em cada inicialização do servidor e colocá-representação de cada arquivo de texto na memória. Cada arquivo de texto terá sua própria string (que é o melhor tipo a ser usado para o titular da corda?).
O que é a maneira mais rápida para ler os arquivos na memória, e qual é a melhor estrutura de dados / tipo para manter o texto de modo que eu possa manipulá-lo na memória (procurar e substituir principalmente)? ??
Graças
Solução
Um arquivo de memória mapeada será mais rápido ... algo como isto:
final File file;
final FileChannel channel;
final MappedByteBuffer buffer;
file = new File(fileName);
fin = new FileInputStream(file);
channel = fin.getChannel();
buffer = channel.map(MapMode.READ_ONLY, 0, file.length());
e, em seguida, proceder a lido a partir do tampão de byte.
Esta será significativamente mais rápido do que FileInputStream ou FileReader.
EDIT:
Depois de um pouco de investigação com este verifica-se que, dependendo do seu sistema operacional, você pode ser melhor fora de usar um novo BufferedInputStream(new FileInputStream(file)) vez. No entanto ler a coisa toda de uma só vez em um char [] o tamanho dos sons de arquivo como o pior caminho.
Assim BufferedInputStream deve proporcionar um desempenho mais ou menos consistente em todas as plataformas, enquanto o arquivo de memória mapeada pode ser lenta ou rápida, dependendo do sistema operacional subjacente. Tal como acontece com tudo o que é desempenho crítico você deve testar seu código e ver o que funciona melhor.
EDIT:
Ok, aqui estão alguns testes (o primeiro é feito duas vezes para obter os arquivos no cache de disco).
Eu corri-lo sobre os arquivos de classe rt.jar, extraído para o disco rígido, este é sob o Windows 7 beta x64. Isso é 16784 arquivos com um total de 94,706,637 bytes.
Primeiro os resultados ...
(lembre-se o primeiro é repetido para obter a configuração do cache de disco)
-
ArrayTest
- tempo = 83016
- bytes = 118641472
-
ArrayTest
- tempo = 46570
- bytes = 118641472
-
DataInputByteAtATime
- tempo = 74735
- bytes = 118641472
-
DataInputReadFully
- tempo = 8953
- bytes = 118641472
-
MemoryMapped
- tempo = 2320
- bytes = 118641472
Aqui está o código ...
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.HashSet;
import java.util.Set;
public class Main
{
public static void main(final String[] argv)
{
ArrayTest.main(argv);
ArrayTest.main(argv);
DataInputByteAtATime.main(argv);
DataInputReadFully.main(argv);
MemoryMapped.main(argv);
}
}
abstract class Test
{
public final void run(final File root)
{
final Set<File> files;
final long size;
final long start;
final long end;
final long total;
files = new HashSet<File>();
getFiles(root, files);
start = System.currentTimeMillis();
size = readFiles(files);
end = System.currentTimeMillis();
total = end - start;
System.out.println(getClass().getName());
System.out.println("time = " + total);
System.out.println("bytes = " + size);
}
private void getFiles(final File dir,
final Set<File> files)
{
final File[] childeren;
childeren = dir.listFiles();
for(final File child : childeren)
{
if(child.isFile())
{
files.add(child);
}
else
{
getFiles(child, files);
}
}
}
private long readFiles(final Set<File> files)
{
long size;
size = 0;
for(final File file : files)
{
size += readFile(file);
}
return (size);
}
protected abstract long readFile(File file);
}
class ArrayTest
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new ArrayTest();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
InputStream stream;
stream = null;
try
{
final byte[] data;
int soFar;
int sum;
stream = new BufferedInputStream(new FileInputStream(file));
data = new byte[(int)file.length()];
soFar = 0;
do
{
soFar += stream.read(data, soFar, data.length - soFar);
}
while(soFar != data.length);
sum = 0;
for(final byte b : data)
{
sum += b;
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputByteAtATime
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new DataInputByteAtATime();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
DataInputStream stream;
stream = null;
try
{
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++)
{
sum += stream.readByte();
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadFully
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new DataInputReadFully();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
DataInputStream stream;
stream = null;
try
{
final byte[] data;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
data = new byte[(int)file.length()];
stream.readFully(data);
sum = 0;
for(final byte b : data)
{
sum += b;
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadInChunks
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new DataInputReadInChunks();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
DataInputStream stream;
stream = null;
try
{
final byte[] data;
int size;
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
data = new byte[512];
size = 0;
sum = 0;
do
{
size += stream.read(data);
sum = 0;
for(int i = 0; i < size; i++)
{
sum += data[i];
}
}
while(size != fileSize);
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class MemoryMapped
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new MemoryMapped();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
FileInputStream stream;
stream = null;
try
{
final FileChannel channel;
final MappedByteBuffer buffer;
final int fileSize;
int sum;
stream = new FileInputStream(file);
channel = stream.getChannel();
buffer = channel.map(MapMode.READ_ONLY, 0, file.length());
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++)
{
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
Outras dicas
A maneira mais eficiente é:
- Determine o tamanho do arquivo (
File.length()) - Criar um tampão de carvão animal com o mesmo tamanho (ou ligeiramente maior)
- Determine o codificação do arquivo
- Use
new InputStreamReader (new FileInputStream(file), encoding)para ler - Leia o arquivo enquanto no buffer com uma única chamada para read (). Note-se que read () pode retornar cedo (não ter lido o arquivo inteiro). Nesse caso, ligue-o novamente com um deslocamento para ler o próximo lote.
- Criar a string:
new String(buffer)
Se você precisa pesquisar e substituir uma vez na inicialização, uso String.replaceAll ().
Se você precisa fazê-lo repetidamente, você pode considerar usar StringBuilder. Não tem nenhum replaceAll (), mas você pode usá-lo para manipular a matriz de caracteres no lugar. (-> nenhuma alocação de memória)
Dito isto:
- Faça o seu código mais curto e simples possível.
- Medir o desempenho
- Ele é muito lento, corrigi-lo.
Não há nenhuma razão para desperdiçar muito tempo em fazer este código correr rápido se leva apenas 0.1s para executar.
Se você ainda tiver um problema de desempenho, considere colocar todos os arquivos de texto em um JAR, adicioná-lo para o classpath e uso Class.getResourceAsStream () para ler os arquivos. Carregando as coisas desde o classpath Java é altamente otimizado.
Ele depende muito da estrutura interna de seus arquivos de texto e o que você pretende fazer com eles.
(arquivos ou seja, "Propriedades") são os dicionários arquivos de chave-valor? XML? JSON? Você tem estruturas padrão para aqueles.
Se eles têm uma estrutura formal, você também pode usar JavaCC para construir uma representação de objeto dos arquivos.
Caso contrário, se eles são apenas bolhas de dados, bem, ler os arquivos e colocá-los em uma string.
Editar: sobre a busca e uso juste substituição de Cordas função replaceAll .
Depois de pesquisar no Google para para testes em velocidade IO existentes em Java, devo dizer caso de teste de TofuBear completamente abriu meus olhos. Você tem que executar o seu teste em sua própria plataforma para ver o que é mais rápido para você.
Depois de executar o teste, e adicionando alguns de minha própria (crédito para TofuBear para postar seu código original), parece que você pode obter ainda mais velocidade usando seu próprio padrão personalizado vs. usando o BufferedInputStream.
Para meu espanto o NIO ByteBuffer não executar bem.
NOTA: O static byte [] Buffer raspado alguns ms, mas os ByteBuffers estáticos actualy aumentou o tempo de processo! Existe errado nada com o código ??
Eu adicionei alguns testes:
-
ArrayTest_CustomBuffering (Ler dados diretamente em meu próprio buffer)
-
ArrayTest_CustomBuffering_StaticBuffer (Ler dados em um buffer estático que é criado apenas uma vez no início)
-
FileChannelArrayByteBuffer (uso NIO ByteBuffer e envolvendo a sua própria matriz byte [])
-
FileChannelAllocateByteBuffer (uso NIO ByteBuffer com .allocate)
-
FileChannelAllocateByteBuffer_StaticBuffer (o mesmo que 4, mas com um tampão estática)
-
FileChannelAllocateDirectByteBuffer (uso NIO ByteBuffer com .allocateDirect)
-
FileChannelAllocateDirectByteBuffer_StaticBuffer (o mesmo que 6, mas com um tampão estática)
Aqui estão meus resultados :, usando o Windows Vista e jdk1.6.0_13 na rt.jar extraído:
ArrayTest
time = 2.075
bytes = 2120336424
ArrayTest
time = 2.044
bytes = 2120336424
ArrayTest_CustomBuffering
time = 1.903
bytes = 2120336424
ArrayTest_CustomBuffering_StaticBuffer
time = 1.872
bytes = 2120336424
DataInputByteAtATime
time = 2.668
bytes = 2120336424
DataInputReadFully
time = 2.028
bytes = 2120336424
MemoryMapped
time = 2.901
bytes = 2120336424
FileChannelArrayByteBuffer
time = 2.371
bytes = 2120336424
FileChannelAllocateByteBuffer
time = 2.356
bytes = 2120336424
FileChannelAllocateByteBuffer_StaticBuffer
time = 2.668
bytes = 2120336424
FileChannelAllocateDirectByteBuffer
time = 2.512
bytes = 2120336424
FileChannelAllocateDirectByteBuffer_StaticBuffer
time = 2.590
bytes = 2120336424
A minha versão do código de TofuBear hackeado:
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.MappedByteBuffer;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(final String[] argv) {
ArrayTest.mainx(argv);
ArrayTest.mainx(argv);
ArrayTest_CustomBuffering.mainx(argv);
ArrayTest_CustomBuffering_StaticBuffer.mainx(argv);
DataInputByteAtATime.mainx(argv);
DataInputReadFully.mainx(argv);
MemoryMapped.mainx(argv);
FileChannelArrayByteBuffer.mainx(argv);
FileChannelAllocateByteBuffer.mainx(argv);
FileChannelAllocateByteBuffer_StaticBuffer.mainx(argv);
FileChannelAllocateDirectByteBuffer.mainx(argv);
FileChannelAllocateDirectByteBuffer_StaticBuffer.mainx(argv);
}
}
abstract class Test {
static final int BUFF_SIZE = 20971520;
static final byte[] StaticData = new byte[BUFF_SIZE];
static final ByteBuffer StaticBuffer =ByteBuffer.allocate(BUFF_SIZE);
static final ByteBuffer StaticDirectBuffer = ByteBuffer.allocateDirect(BUFF_SIZE);
public final void run(final File root) {
final Set<File> files;
final long size;
final long start;
final long end;
final long total;
files = new HashSet<File>();
getFiles(root, files);
start = System.currentTimeMillis();
size = readFiles(files);
end = System.currentTimeMillis();
total = end - start;
System.out.println(getClass().getName());
System.out.println("time = " + total);
System.out.println("bytes = " + size);
}
private void getFiles(final File dir,final Set<File> files) {
final File[] childeren;
childeren = dir.listFiles();
for(final File child : childeren) {
if(child.isFile()) {
files.add(child);
}
else {
getFiles(child, files);
}
}
}
private long readFiles(final Set<File> files) {
long size;
size = 0;
for(final File file : files) {
size += readFile(file);
}
return (size);
}
protected abstract long readFile(File file);
}
class ArrayTest extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new ArrayTest();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
InputStream stream;
stream = null;
try {
final byte[] data;
int soFar;
int sum;
stream = new BufferedInputStream(new FileInputStream(file));
data = new byte[(int)file.length()];
soFar = 0;
do {
soFar += stream.read(data, soFar, data.length - soFar);
}
while(soFar != data.length);
sum = 0;
for(final byte b : data) {
sum += b;
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class ArrayTest_CustomBuffering extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new ArrayTest_CustomBuffering();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
InputStream stream;
stream = null;
try {
final byte[] data;
int soFar;
int sum;
stream = new FileInputStream(file);
data = new byte[(int)file.length()];
soFar = 0;
do {
soFar += stream.read(data, soFar, data.length - soFar);
}
while(soFar != data.length);
sum = 0;
for(final byte b : data) {
sum += b;
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class ArrayTest_CustomBuffering_StaticBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new ArrayTest_CustomBuffering_StaticBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
InputStream stream;
stream = null;
try {
int soFar;
int sum;
final int fileSize;
stream = new FileInputStream(file);
fileSize = (int)file.length();
soFar = 0;
do {
soFar += stream.read(StaticData, soFar, fileSize - soFar);
}
while(soFar != fileSize);
sum = 0;
for(int i=0;i<fileSize;i++) {
sum += StaticData[i];
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputByteAtATime extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new DataInputByteAtATime();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
DataInputStream stream;
stream = null;
try {
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += stream.readByte();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadFully extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new DataInputReadFully();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
DataInputStream stream;
stream = null;
try {
final byte[] data;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
data = new byte[(int)file.length()];
stream.readFully(data);
sum = 0;
for(final byte b : data) {
sum += b;
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadInChunks extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new DataInputReadInChunks();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
DataInputStream stream;
stream = null;
try {
final byte[] data;
int size;
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
data = new byte[512];
size = 0;
sum = 0;
do {
size += stream.read(data);
sum = 0;
for(int i = 0;
i < size;
i++) {
sum += data[i];
}
}
while(size != fileSize);
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class MemoryMapped extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new MemoryMapped();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final FileChannel channel;
final MappedByteBuffer buffer;
final int fileSize;
int sum;
stream = new FileInputStream(file);
channel = stream.getChannel();
buffer = channel.map(MapMode.READ_ONLY, 0, file.length());
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelArrayByteBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelArrayByteBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
final ByteBuffer buffer;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
data = new byte[(int)file.length()];
buffer = ByteBuffer.wrap(data);
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(buffer);
buffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateByteBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateByteBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
final ByteBuffer buffer;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
buffer = ByteBuffer.allocate((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(buffer);
buffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateDirectByteBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateDirectByteBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
final ByteBuffer buffer;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
buffer = ByteBuffer.allocateDirect((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(buffer);
buffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateByteBuffer_StaticBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateByteBuffer_StaticBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
StaticBuffer.clear();
StaticBuffer.limit((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(StaticBuffer);
StaticBuffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += StaticBuffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateDirectByteBuffer_StaticBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateDirectByteBuffer_StaticBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
StaticDirectBuffer.clear();
StaticDirectBuffer.limit((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(StaticDirectBuffer);
StaticDirectBuffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += StaticDirectBuffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
Qualquer abordagem convencional vai ser limitada em velocidade. Eu não tenho certeza que você vai ver muita diferença a partir de uma abordagem para o próximo.
Gostaria de concentrar-se em truques de negócios que poderiam fazer toda a operação mais rápida.
Por exemplo, se você ler todos os arquivos e armazenados-los em um único arquivo com a data e hora de cada um de seu arquivo original, então você pode verificar para ver se qualquer um dos arquivos mudaram sem realmente abrir-los. (Um cache simples, em outras palavras).
Se o seu problema estava ficando um GUI-se rapidamente, você pode encontrar uma maneira de abrir os arquivos em uma discussão de fundo após a sua primeira tela foi exibida.
O sistema operacional pode ser bom bonita com arquivos, se isso é parte de um processo batch (nenhum usuário I / O), você poderia começar com um arquivo de lote que anexe todos os arquivos em um grande problema antes de lançar java, usando algo assim:
echo "file1" > file.all
type "file1" >> file.all
echo "file2" >> file.all
type "file2" >> file.all
file.All Em seguida, basta aberta (não tenho certeza quanto mais rápido isso vai ser, mas é provavelmente a abordagem mais rápida para as condições Eu apenas indicado)
Eu acho que eu só estou dizendo que mais frequentemente do que não, uma solução para um problema de velocidade, muitas vezes requer expandir o seu ponto de vista um pouco e repensar completamente a solução usando novos parâmetros. As modificações de um algoritmo existente normalmente só dar melhorias de velocidade menores ao custo de legibilidade.
Você deve ser capaz de ler todos os arquivos em menos de um segundo, utilizando ferramentas padrão como Commons IO FileUtils.readFileToString (File)
Você pode usar writeStringToFile (File, String) para salvar o arquivo modificado também.
http: / /commons.apache.org/io/api-release/index.html?org/apache/commons/io/FileUtils.html
BTW: 50 não é um número grande de arquivos. Um PC típico pode ter 100K arquivos ou mais.
