<<COMPANY_NAME>>:Great Lakes,<<USER_NAME>>:superCoder
<<ID>>:738390,<<CONTACT_NAME>>:Frank Phillips

\<([^<>]+) breaks up like: <COMPANY_NAME
\>([^<>]+) breaks up like: >:Great Lakes,

([^<>:,]+)

Match 1
1. COMPANY_NAME
Match 2
1. Great Lakes
Match 3
1. USER_NAME
Match 4
1. superCoder
Match 5
1. ID
Match 6
1. 738390
Match 7
1. CONTACT_NAME
Match 8
1. Frank Phillips

<<COMPANY_NAME>>:Great Lakes,<<USER_NAME>>:superCoder
<<ID>>:738390,<<CONTACT_NAME>>:Frank Phillips

This is a file to use to test out the find and replace application

The next two lines should have values swapped in:
<<COMPANY_NAME>><<USER_NAME>><<ID>><<CONTACT_NAME>>
<<COMPANY_NAME>><<USER_NAME>><<ID>><<CONTACT_NAME>>

No find and replace should happen on the next line
COMPANY_NAME USER_NAME ID CONTACT_NAME

More testing with the same field listed multiple times on a single line <<USER_NAME>> <<USER_NAME>>

Add more of your own "tests" here...

package com.company;

import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {

public static void main(String[] args) throws Exception {
Scanner originalTxtFile = new Scanner(new File(args[0]));
Scanner lookupTxtFile = new Scanner(new File(args[1]));

FileWriter replacementFile = new FileWriter(createReplacedFile());

Map<String,String>lookupKeyValuesMap = createLookupKeyValues(lookupTxtFile);// passes scanner object.

StringBuilder builder = new StringBuilder();

while (originalTxtFile.hasNext()) {
String currentLine = originalTxtFile.nextLine();
String[] currentWordsInLine = currentLine.split("([<>:,]+)");

for(String word : currentWordsInLine) {
if(lookupKeyValuesMap.containsKey(word)) {
word = lookupKeyValuesMap.get(word)+ " ";
}
builder.append(word);
}

builder.append("\n");
}

replacementFile.write(builder.toString());
replacementFile.close();
}

private static File createReplacedFile() throws Exception {
File replacedFile = new File("replaced.txt");
replacedFile.createNewFile();
return replacedFile;
}

private static Map<String,String> createLookupKeyValues(Scanner lookupScanner) throws Exception {
Map<String,String> lookupKeyValuesMap = new HashMap<String, String>();

ArrayList<String> keys = new ArrayList<String>();
ArrayList<String> values = new ArrayList<String>();

while(lookupScanner.hasNext()) {
String[] currentWordsInLine = lookupScanner.nextLine().split("([<>:,]+)");

for (int i=0; i<currentWordsInLine.length; i++) {
if (i%2 == 0) {
if (currentWordsInLine[i].length() != 0) {
values.add(currentWordsInLine[i]);
}
} else {
keys.add(currentWordsInLine[i]);
}
}
}

for (int i=0; i<keys.size(); i++) {
lookupKeyValuesMap.put(keys.get(i),values.get(i));
}

return lookupKeyValuesMap;
}
}

public class ContentReplacerDriver
{
public static void main (String[] args) throws java.lang.Exception
{
if(args.length != 2)
throw new IllegalArgumentException("args must contain replacements file and content file");

String replacementFileName = args[0];
String contentFileName = args[1];

ContentReplacer cr = new ContentReplacer(replacementFileName);

String replaced = cr.replace(contentFileName);

System.out.println(replaced);
}
}

import java.util.*;
import java.io.*;

public class ContentReplacer
{
private ContentReplaceFile contentReplaceFile;

public ContentReplacer(String fileName) throws FileNotFoundException, IOException
{
this(fileName, new DefaultContentReplaceFileFactory());
}

public ContentReplacer(String fileName, ContentReplaceFileFactory contentReplaceFileFactory)
throws FileNotFoundException, IOException
{
if(fileName == null || fileName.isEmpty())
throw new IllegalArgumentException("fileName is null or empty");
if(contentReplaceFileFactory == null)
throw new IllegalArgumentException("contentReplaceFileFactory is null");

this.contentReplaceFile = contentReplaceFileFactory.createContentReplaceFile(fileName);
}

public String replace(String fileName) throws FileNotFoundException
{
Map<String, String> replacements = contentReplaceFile.getReplacements();

Scanner in = new Scanner(new File(fileName));

String contentToReplace = new String();

while(in.hasNextLine())
{
contentToReplace += in.nextLine() + "\n";
}

for(Map.Entry<String, String> kvp : replacements.entrySet())
{
String key = kvp.getKey();
String value = kvp.getValue();

contentToReplace = contentToReplace.replace(key, value);
}

return contentToReplace;
}
}

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Map;
import java.util.Scanner;



public class ContentReplaceFile
{
private Map<String, String> replacements;
private String kvDelimiter, kvpDelimiter;

private static final String DEFAULT_KVP_DELIMITER = ",";
private static final String DEFAULT_KV_DELIMITER = ":";

public ContentReplaceFile(String fileName)
throws FileNotFoundException, IOException
{
this(fileName, DEFAULT_KVP_DELIMITER, DEFAULT_KV_DELIMITER);
}

public ContentReplaceFile(String fileName, String kvpDelimiter, String kvDelimiter)
throws FileNotFoundException, IOException
{
if(kvpDelimiter == null || kvpDelimiter.isEmpty())
throw new IllegalArgumentException("kvpDelimiter is null or empty");
if(kvDelimiter == null || kvDelimiter.isEmpty())
throw new IllegalArgumentException("kvDelimiter is null or empty");

this.kvpDelimiter = kvpDelimiter;
this.kvDelimiter = kvDelimiter;

loadFile(fileName);
}

private void loadFile(String fileName) throws FileNotFoundException, IOException
{
Scanner in = new Scanner(new File(fileName));

replacements = new Hashtable<String, String>();

in.useDelimiter(kvpDelimiter);

while(in.hasNext())
{
String kvp = in.next();
String[] kv = kvp.split(kvDelimiter);

if(kv.length != 2)
throw new IOException(String.format("format should be key%svalue", kvDelimiter));

replacements.put(kv[0], kv[1]);
}
}

public Map<String, String> getReplacements()
{
return new Hashtable<String, String>(replacements);
}
}

import java.io.FileNotFoundException;
import java.io.IOException;


public interface ContentReplaceFileFactory
{
ContentReplaceFile createContentReplaceFile(String fileName) throws FileNotFoundException, IOException;
}

import java.io.FileNotFoundException;
import java.io.IOException;

public class DefaultContentReplaceFileFactory implements ContentReplaceFileFactory
{
public ContentReplaceFile createContentReplaceFile(String fileName) throws FileNotFoundException, IOException
{
return new ContentReplaceFile(fileName);
}
}