Was ist der schnellste Weg, um eine große Anzahl von kleinen Dateien in dem Speicher zu lesen?
https://stackoverflow.com/questions/625420
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich brauche ~ 50 Dateien auf jedem Server Start zu lesen und platzieren jede Darstellung in den Speicher der Textdatei. Jede Textdatei wird eine eigene Zeichenfolge (was die beste Art ist für den Saitenhalter zu benutzen?).
Was ist der schnellste Weg, um die Dateien in den Speicher zu lesen, und was ist die beste Datenstruktur / den Text in so zu halten, dass ich es in Erinnerung manipulieren kann (Suche und Ersetzen in erster Linie)?
Danke
Lösung
Ein Memory-Mapped-Datei wird am schnellsten ... so etwas wie folgt aus:
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());
und dann gehen Sie aus dem Byte-Puffer zu lesen.
Dies wird deutlich schneller als FileInputStream oder FileReader.
EDIT:
Nach einem bisschen Untersuchung mit dieser es stellt sich heraus, dass, je nach Betriebssystem, können Sie stattdessen ein neues BufferedInputStream(new FileInputStream(file)) mit besser dran. Doch das Ganze auf einmal in ein char Lesung [] die Größe der Datei klingt wie die schlimmste Art und Weise.
So BufferedInputStream sollte in etwa konstante Leistung auf allen Plattformen geben, während die Memory-Mapped-Datei langsam sein kann oder schnell abhängig von dem zugrunde liegenden Betriebssystem. Wie bei allem, was die Leistung entscheidend ist, sollten Sie Ihren Code testen und sehen, was am besten funktioniert.
EDIT:
Ok hier sind einige Tests (die erste wird zweimal getan, um die Dateien in den Disk-Cache zu bekommen).
Ich lief es auf den rt.jar Klassendateien auf die Festplatte extrahiert, ist dies unter Windows 7 Beta x64. Das ist 16.784 Dateien mit insgesamt 94.706.637 Bytes.
Zuerst werden die Ergebnisse ...
(erinnere mich an die erste wiederholt wird, um die Festplatten-Cache-Setup zu bekommen)
-
Klasse Array
- time = 83016
- Bytes = 118641472
-
Klasse Array
- time = 46570
- Bytes = 118641472
-
DataInputByteAtATime
- time = 74735
- Bytes = 118641472
-
DataInputReadFully
- Zeit = 8953
- Bytes = 118641472
-
MemoryMapped
- Zeit = 2320
- Bytes = 118641472
Hier ist der Code ...
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);
}
}
Andere Tipps
Der effizienteste Weg ist:
- Bestimmen Sie die Länge der Datei (
File.length()) - Erstellen Sie eine char buffer mit der gleichen Größe (oder etwas größer)
- Bestimmen Sie die Codierung der Datei
- Verwenden Sie
new InputStreamReader (new FileInputStream(file), encoding)lesen - Lesen Sie die während Datei in den Puffer mit einem einzigen Aufruf zu lesen (). Beachten Sie, dass read () könnte zurückkehren früh (nicht die gesamte Datei gelesen zu haben). In diesem Fall rufen Sie es erneut mit einem Offset, um die nächste Charge zu lesen.
- Erstellen Sie die Zeichenfolge:
new String(buffer)
Wenn Sie einmal beim Start suchen und ersetzen müssen, verwenden String.replaceAll ().
Wenn Sie es immer wieder tun, können Sie mit String betrachten. Es hat keine replaceAll (), aber Sie können es verwenden, um die Zeichengruppe in Position zu manipulieren. (-> keine Zuordnung von Speichern)
Wie gesagt:
- Erstellen Sie Ihren Code so kurz und einfach wie möglich.
- Messen Sie die Leistung
- Es es ist zu langsam, beheben.
Es gibt keinen Grund viel Zeit in die Herstellung diesen Code ausführen schnell zu verschwenden, wenn es 0,1 s dauert nur auszuführen.
Wenn Sie immer noch ein Leistungsproblem haben, sollten Sie alle Textdateien in eine JAR setzen, fügen Sie ihn in die Classpath und verwenden Class.getResourceAsStream (), um die Dateien zu lesen. Laden Dinge aus dem Java-Classpath ist stark optimiert.
Es hängt viel von der inneren Struktur Ihrer Textdateien und was Sie beabsichtigen, mit ihnen zu tun.
Sind die Dateien Schlüssel-Wert-Wörterbücher (das heißt „Eigenschaften“ Dateien)? XML? JSON? Sie haben Standardstrukturen für die.
Wenn sie eine formale Struktur haben, können Sie auch JavaCC verwenden, um eine Objektdarstellung der Dateien zu erstellen.
Ansonsten, wenn sie nur Blobs von Daten, na ja, die Dateien lesen und sie in einem String setzen.
Edit: über die Suche und Wieder- juste Verwendung replaceAll Funktion String.
Nach über Google-Suche für bestehende Tests auf IO Geschwindigkeit in Java, muss ich TofuBear der Testfall sagen vollständig mir die Augen geöffnet. Sie haben seinen Test auf eigene Plattform laufen, um zu sehen, was für Sie am schnellsten ist.
Nach dem Test ausgeführt wird, und das Hinzufügen von ein paar meiner eigenen (Credit TofuBear für seinen ursprünglichen Code veröffentlichen), es scheint, dass Sie noch mehr Geschwindigkeit erhalten können durch Ihre eigenen Puffer gegen die BufferedInputStream verwenden.
Zu meiner Bestürzung der NIO ByteBuffer nicht gut ab.
Hinweis: Die statische byte [] ein paar ms abrasiert Puffer, aber die statischen ByteBuffers erhöht actualy die Zeit zu verarbeiten! Gibt es etwas falsch mit dem Code ??
Ich habe ein paar Tests:
-
ArrayTest_CustomBuffering (Lesen Sie die Daten direkt in meinem eigenen Puffer)
-
ArrayTest_CustomBuffering_StaticBuffer (Lesen von Daten in einen statischen Puffer, der nur einmal am Anfang erstellt wird)
-
FileChannelArrayByteBuffer (verwenden NIO ByteBuffer und Ihr eigenes byte [] Array Einwickeln)
-
FileChannelAllocateByteBuffer (verwenden NIO ByteBuffer mit .allocate)
-
FileChannelAllocateByteBuffer_StaticBuffer (die gleichen wie 4, aber mit einem statischen Puffer)
-
FileChannelAllocateDirectByteBuffer (verwenden NIO ByteBuffer mit .allocateDirect)
-
FileChannelAllocateDirectByteBuffer_StaticBuffer (die gleiche wie 6, jedoch mit einem statischen Puffer)
Hier sind meine Ergebnisse :, Verwendung von Windows Vista und jdk1.6.0_13 auf der extrahierten rt.jar:
Klasse Array
Zeit = 2075
Bytes = 2120336424
Klasse Array
Zeit = 2044
Bytes = 2120336424
ArrayTest_CustomBuffering
Zeit = 1903
Bytes = 2120336424
ArrayTest_CustomBuffering_StaticBuffer
Zeit = 1872
Bytes = 2120336424
DataInputByteAtATime
Zeit = 2668
Bytes = 2120336424
DataInputReadFully
Zeit = 2028
Bytes = 2120336424
MemoryMapped
Zeit = 2901
Bytes = 2120336424
FileChannelArrayByteBuffer
Zeit = 2371
Bytes = 2120336424
FileChannelAllocateByteBuffer
Zeit = 2356
Bytes = 2120336424
FileChannelAllocateByteBuffer_StaticBuffer
Zeit = 2668
Bytes = 2120336424
FileChannelAllocateDirectByteBuffer
Zeit = 2512
Bytes = 2120336424
FileChannelAllocateDirectByteBuffer_StaticBuffer
Zeit = 2590
Bytes = 2120336424
Meine gehackte Version von TofuBear Code:
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);
}
}
Jeder herkömmliche Ansatz wird in der Geschwindigkeit beschränkt werden. Ich bin mir nicht sicher, dass Sie viel von einem Unterschied von einem Ansatz zum nächsten sehen werden.
ich auf Geschäftsreise Tricks konzentrieren würde, die den gesamten Betrieb schneller machen könnte.
Zum Beispiel, wenn Sie alle Dateien lesen und sie in einer einzigen Datei mit dem Zeitstempel von jedem der Originaldatei gespeichert ist, dann können Sie prüfen, ob eine der Dateien geändert hat, ohne sie tatsächlich zu öffnen. (Ein einfacher Cache, mit anderen Worten).
Wenn Ihr Problem wurde eine GUI schnell bekommen, könnte man einen Weg finden, um die Dateien in einem Hintergrund-Thread zu öffnen nach dem ersten Bildschirm angezeigt wurde.
Das Betriebssystem kann mit Dateien ziemlich gut, wenn dieser Teil eines Batch-Prozesses (kein Benutzer I / O) ist, können Sie mit einer Batch-Datei starten konnten, die alle Dateien in einer großen anhängen, bevor Java starten, mit etwas wie folgt aus:
echo "file1" > file.all
type "file1" >> file.all
echo "file2" >> file.all
type "file2" >> file.all
Dann öffnen Sie einfach file.all (Ich bin nicht sicher, wie viel schneller das sein wird, aber es ist wahrscheinlich der schnellste Ansatz für die Bedingungen, die ich gerade erwähnt)
Ich glaube, ich bin einfach nur sagen, dass mehr als oft nicht, erfordert eine Lösung für ein Problem Geschwindigkeit oft Ihrer Sicht ein wenig erweitert und die Lösung vollständig mit neuen Parametern zu überdenken. Änderungen eines bestehenden Algorithmus in der Regel nur geben, kleinere Geschwindigkeit Verbesserungen auf Kosten der Lesbarkeit.
Sie sollten in der Lage sein, alle Dateien in weniger als eine Sekunde unter Verwendung von Standard-Tool wie Commons IO FileUtils.readFileToString (Datei) lesen
Sie können writeStringToFile (Datei, String) verwenden sowie die geänderte Datei zu speichern.
http: / /commons.apache.org/io/api-release/index.html?org/apache/commons/io/FileUtils.html
BTW: 50 ist nicht eine große Anzahl von Dateien. Ein typischer PC kann 100K Dateien oder mehr hat.
