Read the file line by line, doing your check. When you found it, then you can stop and close the file.
If you search "Java read line in file", you should find lot of examples (often with poor management of exceptions / closing!).

Hello,

thanks!

or load the bunch and put it in a HashMap and query the hashmap - could be faster?

Or a sql-solution...?

You know the INI-files in Windows (or registry) how can this be done in processing?

Greetings, Chrisir

Loading it into a HashMap will still require you to iterate over each line.

What have you tried? What benchmarks have you measured?

Indeed, if the file isn't too big (say less than half the memory allocated to sketches), you can just use loadStrings().
A HashMap can save a bit of time, only if you do lot of searches in the file. But it works only if you store the words in it, and you have to keep track of the lines where they appear, etc.

If you just want to read an INI file, or a REG file, these are usually not so big, so it is just simpler and reasonably fast to iterate on the lines and to use String#contains() to search a given string.

You should be a bit more specific if you want better, more precise advices.

Hello!

Thanks!

I now found a solution that is similar to INI-file / Registry:
the property class of Java.

I found a code from CalSign in his cool MP3-Player
http://forum.processing.org/topic/lovely-mp3-player#25080000002011713
and I just took out the lines from his Code relevant for our problem.

The code makes a kind of INI-file and reads it back in.

The reading is similar to working with a HashMap.

Unfortunately it holds the whole thing in the RAM.
But I imagine you can load the whole file in one go (without having to push each line into a hashMap in setup()).

Greetings, Chrisir   

1. 
   
2. import java.util.Properties;
3. import java.io.*;
4. 
   
5. Properties defaultProps;
6. Properties props;
7. //
8. String storagePath;
9. //
10. void setup() {
11.   size(1200, 800);
12.   registerDispose(this);
13.   storagePath = System.getProperty("user.home") + "\\PlayTest\\";
14.   (new File(storagePath)).mkdirs();
15.   println (storagePath);
16.   try {
17.     defaultProps = new Properties();
18.     FileInputStream in = new FileInputStream(storagePath + "defaultProperties.properties");
19.     defaultProps.load(in);
20.     in.close();
21.     props = new Properties(defaultProps);
22.     in = new FileInputStream(storagePath + "properties.properties");
23.     props.load(in);
24.     in.close();
25.     //
26.     // Read
27.     println ("volume " +  props.getProperty("volume") );
28.     //
29.     // Read
30.     for (int i=0; i<100; i++)
31.       println (props.getProperty("volume"+str(i)));
32.     //
33.   }
34.   catch(Exception e) {
35.     println("Could not load the properties files. Attempting to create them now...");
36.     System.err.println("Could not load the properties files. Attempting to create them now...");
37.     e.printStackTrace();
38.     defaultProps = new Properties();
39.     // Write
40.     defaultProps.setProperty("volume", str(50));
41.     // Write
42.     for (int i=0; i<100; i++)
43.       defaultProps.setProperty("volume"+str(i), str(i+50));
44.     props = new Properties(defaultProps);
45.     try {
46.       FileOutputStream out = new FileOutputStream(storagePath + "defaultProperties.properties");
47.       defaultProps.store(out, "---No Comment---");
48.       out.close();
49.       out = new FileOutputStream(storagePath + "properties.properties");
50.       props.store(out, "---No Comment---");
51.       out.close();
52.     }
53.     catch(Exception f) {
54.       System.err.println("Unable to create properties files!");
55.       f.printStackTrace();
56.     }
57.   }
58. }
59. //
60. void draw() {
61.   //
62.   background(0);
63.   text("see direct window", 100, 100);
64.   noLoop();
65. }
66. //

this sketch now uses a classic saveStrings to make a property file (with all entries like v92=12)

and then the Property-class to get info from it.

So it's a mix

1. //
2. import java.util.Properties;
3. import java.io.*;
4. //
5. Properties props;
6. //
7. String storagePath;
8. String storagePathFull;
9. //
10. void setup() {
11.   size(600, 800);
12.   //
13.   registerDispose(this);
14.   storagePath = dataPath("");
15.   println (storagePath);
16.   storagePathFull = storagePath + "\\properties.properties";
17.   println (storagePathFull);
18. }
19. //
20. void draw() {
21.   //
22.   background(0);
23.   text("press 1 to save, 2 to load ", 100, 50);
24.   text("see direct window", 100, 100);
25.   //   noLoop();
26. }
27. //
28. void keyPressed() {
29.   switch(key) {
30.   case '1':
31.     saveSome();
32.     break;
33.   case '2':
34.     loadSome();
35.     break;
36.   default:
37.     break;
38.   } // switch
39. }
40. //
41. void loadSome() {
42.   // loading
43.   try {   
44.     props = new Properties();
45.     FileInputStream in = new FileInputStream(storagePathFull);
46.     props.load(in);
47.     in.close();
48.     //
49.     // Read
50.     for (int i=0; i<100; i++)
51.       println (props.getProperty("v"+str(i)));
52.     //
53.   }
54.   catch(Exception e) {
55.     println ("didn't find any");
56.   }
57. } // func
58. //
59. void saveSome () {
60.   // save
61.   String [] list = new String [100];
62.   for (int i=0; i<100; i++)
63.   {
64.     list[i] = "v"+str(i) + "=" + str(1000+i)  ;
65.   } // for
66.   //
67.   //
68.   // Writes the strings to a file, each on a separate line
69.   saveStrings(storagePathFull, list);
70.   println ("done saving");
71. } // func
72. //

Greetings, Chrisir

If you need an answer, please send me a personal message since this forum doesn't notify.

I see:

1.   registerDispose(this);
2.   storagePath = dataPath("");
3.   println (storagePath);
4.   storagePathFull = storagePath + "\\properties.properties";

You call registerDispose() but I don't see a dispose() method.
You use \\ which is not portable, better use /
Or, better, really use dataPath:
  storagePathFull = dataPath("properties.properties");

Note that properties.store() escapes some characters, that your method doesn't. You might have some trouble to do roundtrip save / load. And it makes you to fill an array with properties already in a Map.

At least, it clarifies your question: the keys of your map are the properties, and these are the "string" you search in the file; the values are the values assigned to these properties.

Thank you, PhiLho

when reading the data in now, I need to get all the data before I can get the values via the key.

Is there a way to get the value from the key directly from the hard drive?



Greetings, Chrisir

Again, why not read all the data at once? Is the file so big?
There is no magic, to read a given key, you have to read all the previous lines, until you find this key. At best, it just prevents from reading the next data, if you don't need it.
Or perhaps that's a database with indexed tables that you need?