Quel est le moyen le plus rapide de lire un grand nombre de petits fichiers en mémoire?
https://stackoverflow.com/questions/625420
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je dois lire environ 50 fichiers à chaque démarrage du serveur et placer en mémoire la représentation de chaque fichier texte. Chaque fichier texte aura sa propre chaîne (quel est le meilleur type pour le titulaire de la chaîne?).
Quel est le moyen le plus rapide de lire les fichiers en mémoire et quel est le meilleur type de structure / type de données pour contenir le texte afin que je puisse le manipuler en mémoire (recherche et remplacement principalement)?
Merci
La solution
Un fichier mappé en mémoire sera le plus rapide ... à peu près comme ceci:
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());
puis continuez à lire à partir du tampon d'octets.
Cela sera nettement plus rapide que FileInputStream ou FileReader .
EDIT:
Après un peu d'investigation avec cela, il s'avère que, selon votre système d'exploitation, il pourrait être préférable d'utiliser un nouveau BufferedInputStream (nouveau FileInputStream (fichier)) . Cependant, en lisant tout cela en un seul caractère [], la taille du fichier sonne comme la pire des choses.
Ainsi, BufferedInputStream devrait donner des performances globalement cohérentes sur toutes les plates-formes, tandis que le fichier mappé en mémoire peut être lent ou rapide en fonction du système d'exploitation sous-jacent. Comme pour tout ce qui est essentiel à la performance, vous devez tester votre code et voir ce qui fonctionne le mieux.
EDIT:
Ok, voici quelques tests (le premier est fait deux fois pour obtenir les fichiers dans le cache du disque).
Je l'ai exécuté sur les fichiers de classe rt.jar, extraits sur le disque dur, sous Windows 7 bêta x64. C’est 16784 fichiers avec un total de 94 706 637 octets.
D'abord les résultats ...
(rappelez-vous que le premier est répété pour obtenir la configuration du cache disque)
-
ArrayTest
- time = 83016
- octets = 118641472
-
ArrayTest
- time = 46570
- octets = 118641472
-
DataInputByteAtATime
- time = 74735
- octets = 118641472
-
DataInputReadFully
- time = 8953
- octets = 118641472
-
MemoryMapped
- time = 2320
- octets = 118641472
Voici le 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);
}
}
Autres conseils
Le moyen le plus efficace est:
- Déterminez la longueur du fichier (
File.length ()) - Créer un tampon de caractères de même taille (ou légèrement plus grand)
- Déterminez le codage du fichier
- Utilisez
new InputStreamReader (nouveau FileInputStream (fichier), codage)pour lire - Lit le fichier while dans la mémoire tampon avec un seul appel à read (). Notez que read () peut retourner plus tôt (ne pas avoir lu le fichier entier). Dans ce cas, rappelez-le avec un décalage pour lire le prochain lot.
- Créez la chaîne:
new String (tampon)
Si vous devez rechercher et remplacer une fois au démarrage, utilisez String.replaceAll ().
Si vous devez le faire de manière répétée, vous pouvez envisager d'utiliser StringBuilder. Il n’a pas de replaceAll () mais vous pouvez l’utiliser pour manipuler le tableau de caractères à la place (- > aucune allocation de mémoire).
Cela dit:
- Faites en sorte que votre code soit aussi court et simple que possible.
- Mesurer la performance
- Si c'est trop lent, corrigez-le.
Il n'y a aucune raison de perdre beaucoup de temps à faire fonctionner ce code rapidement s'il ne faut que 0,1 s pour être exécuté.
Si vous rencontrez toujours un problème de performances, envisagez de placer tous les fichiers texte dans un fichier JAR, ajoutez-le au chemin de classe et utilisez Class.getResourceAsStream () pour lire les fichiers. Le chargement d'objets depuis le classpath Java est hautement optimisé.
Cela dépend beaucoup de la structure interne de vos fichiers texte et de ce que vous comptez en faire.
Les fichiers sont-ils des dictionnaires valeur-clé (c'est-à-dire des fichiers "propriétés")? XML? JSON? Vous avez des structures standard pour ceux-là.
S'ils ont une structure formelle, vous pouvez également utiliser JavaCC pour créer une représentation objet des fichiers.
Sinon, s'il ne s'agit que de blobs de données, lisez les fichiers et mettez-les dans une chaîne.
Modifier: sur la recherche et le remplacement - utilisez simplement Fonction replaceAll de la chaîne .
Après avoir recherché sur Google des tests existants sur la vitesse des E / S en Java, je dois dire que le scénario de test de TofuBear m'a complètement ouvert les yeux. Vous devez exécuter son test sur votre propre plate-forme pour voir ce qui est le plus rapide pour vous.
Après avoir exécuté son test et ajouté quelques-uns de mes propres (crédit à TofuBear pour avoir publié son code d'origine), il semble que vous puissiez gagner encore plus de temps en utilisant votre propre tampon personnalisé par rapport à BufferedInputStream.
À mon grand désarroi, le NIO ByteBuffer ne fonctionnait pas bien.
REMARQUE: la mémoire tampon byte [] statique a été réduite de quelques ms, mais les ByteBuffers statiques ont augmenté le temps de traitement! Le code contient-il un problème?
J'ai ajouté quelques tests:
-
ArrayTest_CustomBuffering (Lire des données directement dans mon propre tampon)
-
ArrayTest_CustomBuffering_StaticBuffer (Lire des données dans un tampon statique créé une seule fois au début)
-
FileChannelArrayByteBuffer (utilisez NIO ByteBuffer et encapsulez votre propre tableau d'octets [])
-
FileChannelAllocateByteBuffer (utilisez NIO ByteBuffer avec .allocate)
-
FileChannelAllocateByteBuffer_StaticBuffer (identique à 4 mais avec un tampon statique)
-
FileChannelAllocateDirectByteBuffer (utilisez NIO ByteBuffer avec .allocateDirect)
-
FileChannelAllocateDirectByteBuffer_StaticBuffer (identique à 6 mais avec un tampon statique)
Voici mes résultats :, en utilisant Windows Vista et jdk1.6.0_13 sur le fichier rt.jar extrait:
ArrayTest
temps = 2075
octets = 2120336424
ArrayTest
heure = 2044
octets = 2120336424
ArrayTest_CustomBuffering
heure = 1903
octets = 2120336424
ArrayTest_CustomBuffering_StaticBuffer
heure = 1872
octets = 2120336424
DataInputByteAtATime
heure = 2668
octets = 2120336424
DataInputReadFully
heure = 2028
octets = 2120336424
MemoryMapped
heure = 2901
octets = 2120336424
FileChannelArrayByteBuffer
heure = 2371
octets = 2120336424
FileChannelAllocateByteBuffer
temps = 2356
octets = 2120336424
FileChannelAllocateByteBuffer_StaticBuffer
heure = 2668
octets = 2120336424
FileChannelAllocateDirectByteBuffer
temps = 2512
octets = 2120336424
FileChannelAllocateDirectByteBuffer_StaticBuffer
temps = 2590
octets = 2120336424
Ma version piratée du code de TofuBear:
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);
}
}
Toute approche conventionnelle sera limitée en vitesse. Je ne suis pas sûr que vous constaterez une grande différence d'une approche à l'autre.
Je me concentrerais sur des astuces commerciales susceptibles d'accélérer l'ensemble de l'opération.
Par exemple, si vous lisez tous les fichiers et les stockez dans un seul fichier avec les horodatages de chacun de vos fichiers d'origine, vous pourrez alors vérifier si l'un des fichiers a été modifié sans l'avoir réellement ouvert. (un cache simple, en d’autres termes).
Si votre problème posait une interface graphique rapidement, vous pourriez trouver un moyen d’ouvrir les fichiers dans un fil d’arrière-plan après l’affichage de votre premier écran.
Le système d’exploitation peut être assez bon avec les fichiers. Si cela fait partie d’un processus batch (pas d’E / S utilisateur), vous pouvez commencer avec un fichier batch qui ajoute tous les fichiers en un seul avant de lancer java, en utilisant quelque chose comme ceci:
echo "file1" > file.all
type "file1" >> file.all
echo "file2" >> file.all
type "file2" >> file.all
Ensuite, ouvrez simplement fichier.all (je ne sais pas à quel point cela sera plus rapide, mais c’est probablement l’approche la plus rapide pour les conditions que je viens d’énoncer)
Je suppose que je dis simplement que le plus souvent, une solution à un problème de rapidité nécessite souvent d’élargir un peu votre point de vue et de repenser complètement la solution en utilisant de nouveaux paramètres. Les modifications d'un algorithme existant n'apportent généralement qu'une amélioration mineure de la vitesse au détriment de la lisibilité.
Vous devriez pouvoir lire tous les fichiers en moins d'une seconde à l'aide d'outils standard tels que Commons IO FileUtils.readFileToString (File)
.Vous pouvez également utiliser writeStringToFile (File, String) pour enregistrer le fichier modifié.
http: / /commons.apache.org/io/api-release/index.html?org/apache/commons/io/FileUtils.html
BTW: 50 ne représente pas un grand nombre de fichiers. Un PC typique peut avoir 100 000 fichiers ou plus.
