Read files and replace Strings

[Adrian Burke]

Hi
Would like some advice on how to do the following:

1. read a list of String values from a file
eg:
HOSTNAME=myDevelopmentServer
IP=10.11.12.13

2. Read in a second file(file2.txt) and replace String
eg:
Name of server is HOSTNAME.

3. Write the result to a file3.txt.
Eg:
Name of sever is myDevelopmentServer.

[fred rosenberger]

you've basically spelled out what you need to do. Where are you stuck?

[Campbell Ritchie]

Start with this section of the Java™ tutorials. Remember for text you will want a FileReader and a BufferedReader, and a FileWriter and a BufferedWriter.

Of course, if you find the Scanner and Formatter classes, you can point them at text files, and they are much easier to use. In the tutorials, look for the contents and use ctrl-f "scanning" or "formatting". It is there (actually in the section I told you about).

[Adrian Burke]

This is where I am at. I am only catering for 1 value to be replaced.

import java.io.*;

public class Replace {
	public static void main(String args[]) throws Exception {

		String str;
		String srcFile = args[0];
		String resultFile = args[1];		
		String s1 = "HOSTNAME";
		String s2 = "myDevelopmentServer";

		try {
			FileInputStream fis = new FileInputStream(srcFile);
			DataInputStream input = new DataInputStream(fis);
			FileOutputStream fos = new FileOutputStream(resultFile);
			DataOutputStream output = new DataOutputStream(fos);

			while (null != ((str = input.readLine()))) {

				int x = 0;
				int y = 0;
				String result = "";
				while ((x = str.indexOf(s1, y)) > -1) {
					result += str.substring(y, x);
					result += s2;
					y = x + s1.length();
				}
				result += str.substring(y);
				str = result;

				if (str.indexOf("'',") != -1) {
					continue;
				} else {
					str = str + "\n";

					output.writeBytes(str);
				}
			}
		} catch (IOException ex) {
			System.err.println("Problem.." + ex);
		}
	}
}

[Rob Spoor]

1 can be done using java.util.Properties in combination with its load methods (use a Reader, not an InputStream; after all, it's text you want to read, not bytes).

Do you want to replace all occurrences of all keys of the mapping with their values? If so, you can use keySet() to access the keys of the Properties object (which is still a Map so it has the keySet() method), or stringPropertyNames(). I'd prefer the former as that doesn't create a new Set.

This simple approach has one possible flaw: what if the value for some key contains some other key? For instance, what if my HOSTNAME=VOIP_Server? The replacing of IP will then turn the HOSTNAME not into VOIP_Server but into VO10.11.12.13_Server. This in turn can be fixed by doing the find-and-replace in one single loop, using a regular expression. Just group them all together using |:

StringBuilder regex = new StringBuilder();
for (Object key: properties.keySet()) // stupid Properties extends Hashtable<Object,Object> instead of Hashtable<String,String>...
{
    if (key instanceof String)
    {
        if (regex.length() > 0)
        {
            regex.append('|');
        }
        regex.append(Pattern.quote((String)key)); // quote so any meta characters inside the key are not used as meta characters
    }
}
// in the example, regex now contains "HOSTNAME|IP"

Now use Pattern and Matcher to find all the occurrences of the keys, replacing each occurrence with the right value.

[Adrian Burke]

Hi & thanks again for the advice and direction.
Below I have a working example whereby:
Load the properties file.
read in all keys from the properties file.
read in a source file
substitute keys with element values
write to a dest file

Problem I am having is that only the first key is being subsituted with the appropriate element. Remaining Keys are not.

import java.io.*;
import java.util.Properties;
import java.util.Set;

public class ReadValues {

	public static void main(String[] args) throws IOException {
		String str;

		// Read properties file.
		Properties properties = new Properties();
		properties.load(new FileReader("file.properties"));

		// reader
		BufferedReader br = new BufferedReader(new FileReader("sourceFile.txt"));
		// writer
		BufferedWriter bw = new BufferedWriter(new FileWriter("resultFile.txt"));


		// for each property key, replace all occurrences with appropriate element.
		Set<Object> keys = properties.keySet();
		for (Object key : keys) {
			String keyName = (String) key;
			System.out.println("keyName = " + keyName);
			String value = (String) properties.get(key);
			System.out.println("value = " + value);

			while ((str = br.readLine()) != null) {
				System.out.println("reading....");
				int x = 0;
				int y = 0;
				String result = "";
				while ((x = str.indexOf(keyName, y)) > -1) {
					result += str.substring(y, x);
					result += value;
					y = x + keyName.length();
				}

				result += str.substring(y);
				str = result;

				if (str.indexOf("'',") != -1) {
					continue;
				} else {
					str = str + "\n";
					// write result to destination file.
					bw.write(str);
				}
			}
		} 

		// must close file when done.
		bw.close();

	}
}

Any further suggestions are most welcome.

Adrian.

[Rob Spoor]

Well, it's pretty obvious. For the first key you read the entire file. The BufferedReader is then at its end. For the next key, it isn't reset, so it's still at its end, and the readLine() method immediately returns null. I suggest you store the contents of the file into a String, or perhaps a List<String>. If you use a single String I suggest you use a StringBuilder for creating it. It's more efficient than using += on Strings multiple times. Likewise for your String result. I'd change that into a StringBuilder as well. Modifying your code to use a StringBuilder:

            while ((str = br.readLine()) != null) {   
                System.out.println("reading....");   
                int x = 0;   
                int y = 0;   
                //String result = "";   
                StringBuilder result = new StringBuilder();
                while ((x = str.indexOf(keyName, y)) > -1) {   
                    //result += str.substring(y, x);   
                    //result += value;   
                    result.append(str, y, x);
                    result.append(value);
                    y = x + keyName.length();   
                }   
   
                //result += str.substring(y);   
                //str = result;   
                result.append(str, y, str.length());
                str = result.toString();
   
                if (str.indexOf("'',") != -1) {   
                    continue;   
                } else {   
                    // single, non-looped concatenation doesn't matter much
                    str = str + "\n";   
                    // write result to destination file.   
                    bw.write(str);   
                }   
            }   

[Adrian Burke]

Thank you for the suggestion for using StringBuilder.
Even with storing the contents of the file in a String - I don't see how I get round the problem of "For the next key, it isn't reset, so it's still at its end, and the readLine() method immediately returns null"

Adrian.

[Adrian Burke]

Hi,
Have updated so that the contents of the file is stored in a String.

import java.io.*;
import java.util.Properties;
import java.util.Set;

public class ReadValues {

	public static void main(String[] args) throws IOException {
		String str;

		// Read properties file.
		Properties properties = new Properties();
		properties.load(new FileReader("file.properties"));

		// reader
		String strTest = readFile("sourceFile.txt");

		// writer
		BufferedWriter bw = new BufferedWriter(new FileWriter("resultFile.txt"));

		// for each property key, replace all occurrences with appropriate
		// element.
		Set<Object> keys = properties.keySet();
		for (Object key : keys) {
			String keyName = (String) key;
			System.out.println("keyName = " + keyName);
			String value = (String) properties.get(key);
			System.out.println("value = " + value);

			System.out.println("reading....\n" + strTest + "\n");
			int x = 0;
			int y = 0;
			StringBuilder result = new StringBuilder();
			while ((x = strTest.indexOf(keyName, y)) > -1) {
				result.append(strTest, y, x);
				result.append(value);
				y = x + keyName.length();
			}

			result.append(strTest, y, strTest.length());
			str = result.toString();

			if (str.indexOf("'',") != -1) {
				continue;
			} else {
				str = str + "\n";
				// write result to destination file.
				bw.write(str);
			}

		}
		bw.write(strTest);
		// must close file when done.
		bw.close();

	} // end of main.

	public static String readFile(String file) throws IOException {
		BufferedReader reader = new BufferedReader(new FileReader(file));
		String line = null;
		StringBuilder stringBuilder = new StringBuilder();
		String ls = System.getProperty("line.separator");
		while ((line = reader.readLine()) != null) {
			stringBuilder.append(line);
			stringBuilder.append(ls);
		}
		return stringBuilder.toString();
	}
}

Thanks

[Rob Spoor]

That's exactly what I meant with storing the contents. Because now the entire String is stored in memory you can use it over and over again.