Confused with String replace in strings

[Rakesh Keerthi]

Hi,

I'm working on a code where I need to find a string from a set of sentences, match if the string is in another keywords list and from there get the appropriate value from map and replace in original list.

Here is my code

import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class SampleCollection {

	public static void main(String[] args) throws Exception {
		Map<String, String> dictMap = new HashMap<String, String>();
		dictMap.put("lmn", "lemon");
		dictMap.put("gngr", "ginger");
		dictMap.put("grn", "green");
		dictMap.put("vegan", "vegetarian");
		dictMap.put("brea", "bread");
		dictMap.put("bre", "bread");

		List<String> dictKeys = new ArrayList<String>();
		dictKeys.add("lmn");
		dictKeys.add("gngr");
		dictKeys.add("grn");
		dictKeys.add("vegan");
		dictKeys.add("bre");
		dictKeys.add("brea");
		String dictArray[] = dictKeys.toArray(new String[0]);
		replaceTextInExcel(dictArray, dictMap);
	}

	private static void replaceTextInExcel(String[] dictArray, Map<String, String> dictMap) throws Exception {

		List<String> rawTitleList = new ArrayList<String>();
		rawTitleList.add("bread gingerbread vegan");
		rawTitleList.add("iced tea lmn gngr grn 32");
		rawTitleList.add("iced tea lmn");
		String[] rawTitlesArray = rawTitleList.toArray(new String[0]);
		replaceTheValuesInArray(rawTitleList, dictArray, dictMap);
	}

	private static void replaceTheValuesInArray(List<String> rawTitleList, String[] dictArray,
			Map<String, String> dictMap) {
		Pattern pattern = Pattern
				.compile(dictMap.keySet().stream().map(Pattern::quote).collect(Collectors.joining("|")));
		Matcher m = pattern.matcher(String.join("~", rawTitleList));
		StringBuffer newText = new StringBuffer();
		while (m.find()) {
			m.appendReplacement(newText, dictMap.get(m.group()));
		}
		m.appendTail(newText);
		List<String> newStrings = Arrays.asList(newText.toString().split("~"));
		System.out.println("Original strings: " + rawTitleList);
		System.out.println("New strings: " + newStrings);
	}

}

When I run this code the output that I get is as below.

Original strings: [bread gingerbread vegan, iced tea lmn gngr grn 32, iced tea lmn]
New strings: [breadd gingerbreadd vegetarian, iced tea lemon ginger green 32, iced tea lemon]

but my expected output is as below

Original strings: [bread gingerbread vegan, iced tea lmn gngr grn 32, iced tea lmn]
New strings: [bread gingerbread vegetarian, iced tea lemon ginger green 32, iced tea lemon]

Here I want to find entire match in rawTitleList from dictKeys and replace the value using the value from dictMap.

please let me know where am I going wrong and how can I fix this.

Thanks,
Sunny

[Rob Spoor]

The problem is that both bread and gingerbread contain brea. What you seem to want is to use either whole words, or words ending with those. That means you need to use the word boundary - \b. Add that after and (if needed) before the current pattern. Note that your existing pattern needs to be enclosed with ( or (?: and ), otherwise the word boundaries will be part of the first and last "word".

[Carey Brown]

		Pattern pattern = Pattern.compile( "(?<=\\b)(" + dictMap.keySet().stream()
				.map( Pattern::quote ).collect( Collectors.joining( "|" ) ) + ")(?=\\b)" );
		System.out.println( pattern );

Produces the pattern

(?<=\b)(\Qgngr\E|\Qgrn\E|\Qbrea\E|\Qbre\E|\Qvegan\E|\Qlmn\E)(?=\b)

Note the map(Pattern::quote) is unnecessary unless there's a small chance that a dictMap key contains special characters.

[Carey Brown]

Your approach is ok for a small dictionary but this would be a more generalized approach that could handle a potentially large dictionary.

	private static String substitute( Map<String,String> dictMap, String key ) {
		String substitution = dictMap.get( key );
		if( substitution == null )
			return key;
		return substitution;
	}
	
	private static void replaceTheValuesInArray( List<String> rawTitleList,
			Map<String,String> dictMap ) {
		Pattern pattern = Pattern.compile( "[a-zA-Z]+" );
		System.out.println( pattern );
		Matcher m = pattern.matcher( String.join( "~", rawTitleList ) );
		StringBuffer newText = new StringBuffer();
		while( m.find() ) {
			m.appendReplacement( newText, substitute( dictMap, m.group() ) );
		}
		m.appendTail( newText );
		List<String> newStrings = Arrays
				.asList( newText.toString().split( "~" ) );
		System.out.println( "Original strings: " + rawTitleList );
		System.out.println( "New strings: " + newStrings );
	}

[Rob Spoor]

Carey Brown wrote:

		Pattern pattern = Pattern.compile( "(?<=\\b)(" + dictMap.keySet().stream()
				.map( Pattern::quote ).collect( Collectors.joining( "|" ) ) + ")(?=\\b)" );
		System.out.println( pattern );

Collectors.joining is overloaded to take a prefix and postfix:

		Pattern pattern = Pattern.compile( dictMap.keySet().stream()
				.map( Pattern::quote ).collect( Collectors.joining( "|", "(?<=\\b)(", ")(?=\\b)" ) ) );