Lew wrote:

Exactly the same, except that Properties assumes everything is a String.

String.toString() tends to be readily invertible.

Since the question was asked of a HashMap, one must account for non-invertible
toString() methods from non-String objects.

I suppose you could argue that that is not a /fundamental/ difference, but I'd
beg to differ.

Given certain conventions, one could come up with some sort of Java API for
XML Binding (JAXB) or similar, and use it to map object graphs to an XML
representation.

Hmm, I wonder if that might solve the OP's problem ...

There are ways to save and restore your entire HashMap that would be
simpler and more general than parsing that toString mess with a regex.

1. Properties (a Lasse suggested).
2. serialisation as I mentioned earlier.
3. saving one string per line
4. saving as a CSV file.  See http://mindprod.com/jgloss/csv.html
5. as  DataOutputStream pairs.

Also, the toString() output was never designed to be reversed.  You can't
parse it correctly if the strings contain comma, equals, spaces, or braces
in the data:

import java.util.*;

class HashMapTest
{
   public static void main(String args[])
   {
       HashMap<String,String> h = new HashMap<String,String>();

       h.put("key1=value1, key2", "value2");
       h.put("key3=value3}\n{key4=value4, key5", "value5");

       System.out.println(h);

       // The hashmap with only two keys in it produces
       // this output:
       //
       // {key1=value1, key2=value2, key3=value3}
       // {key4=value4, key5=value5}
       //
   }
}

Are you thinking of the (rather remarkable) behaviour
of Data::Dumper() ?

  BugBea

 it also can handle keys that are maps itself.

 For example,

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { final RoomSource room = room( "< < a=b c=d >=1 >" );
   System.out.println( room.get( room( "< a=b c=d >" ))); }}

1

 Above, the map "< a=b c=d >" is used as a key and mapped to
 the value "1". "room.get" then retrieves the value "1" given
 the map "< a=b c=d >" as a key.

 The order or details of notation or redundant assertions do
 not matter in this case. Strings can also be written in
 brackets. Therefore, the notation "< c=d a = [b] c=d >" also
 is recognized as the same key, because it is the same map.

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { final RoomSource room = room( "< < a=b c=d >=1 >" );
   System.out.println( room.get( room( "< c=d a = [b] c=d >" ))); }}

 If a string value is to contain an equal sign or a space,
 it needs to be written in brackets. The routines will properly
 escape when serializing again. For example:

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { System.out.println( room( "< [abc=def ghi]=1 >" )); }}

< [abc=def ghi] =1 >

 The serialization routine has decided to use brackets here,
 because they are required. The space in front of the "=1" is a
 minor annoyance (formatting style bug), but it does not change
 the semantics just the style of the notation.

 If brackets are not needed, they will be omitted:

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { System.out.println( room( "< [abcdefghi]=1 >" )); }}

< abcdefghi =1 >

 Here, the serialization routine has detected that no
 bracket escape is needed.

 To see, how any string is escaped, you can insert it,
 and then serialize it. The following program adds the
 following two strings:

     abc[]def[ghi\jkl
     mno\]pqr\

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.Room;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { Room room = new Room();
   room.add( "abc[]def[ghi\\jkl" );
   room.add( "mno\\]pqr\\" );
   System.out.println( room ); }}

< [abc[]def\[ghi\jkl] [mno\\]pqr\|] >

 Somewhat unusual, but this is specified in this way,
 so that brackets and backslashes can be used inside a
 bracketed string without escaping as often as possible.
 Only unpaired brackets and backslashes at the end of a
 string needs special handling.

 This output now will be used as input to check, that it
 will be serialized again to the same output. Of course,
 Java now requires to double backslashes:

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.Room;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { Room room = room( "< [abc[]def\\[ghi\\jkl] [mno\\\\]pqr\\|] >" );
   System.out.println( room ); }}

< [abc[]def\[ghi\jkl] [mno\\]pqr\|] >

Supersedes: <map-keys-20071114231003@ram.dialup.fu-berlin.de>

 it also can handle keys that are maps itself.

 For example,

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { final RoomSource room = room( "< < a=b c=d >=1 >" );
   System.out.println( room.get( room( "< a=b c=d >" ))); }}

1

 Above, the map "< a=b c=d >" is used as a key and mapped to
 the value "1". "room.get" then retrieves the value "1" given
 the map "< a=b c=d >" as a key.

 The order or details of notation or redundant assertions do
 not matter in this case. Strings can also be written in
 brackets. Therefore, the notation "< c=d a = [b] c=d >" also
 is recognized as the same key, because it is the same map.

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { final RoomSource room = room( "< < a=b c=d >=1 >" );
   System.out.println( room.get( room( "< c=d a = [b] c=d >" ))); }}

1

 If a string value is to contain an equal sign or a space,
 it needs to be written in brackets. The routines will properly
 escape when serializing again. For example:

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { System.out.println( room( "< [abc=def ghi]=1 >" )); }}

< [abc=def ghi] =1 >

 The serialization routine has decided to use brackets here,
 because they are required. The space in front of the "=1" is a
 minor annoyance (formatting style bug), but it does not change
 the semantics just the style of the notation.

 If brackets are not needed, they will be omitted:

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.RoomSource;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { System.out.println( room( "< [abcdefghi]=1 >" )); }}

< abcdefghi =1 >

 Here, the serialization routine has detected that no
 bracket escape is needed.

 To see, how any string is escaped, you can insert it,
 and then serialize it. The following program adds the
 following two strings:

     abc[]def[ghi\jkl
     mno\]pqr\

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.Room;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { Room room = new Room();
   room.add( "abc[]def[ghi\\jkl" );
   room.add( "mno\\]pqr\\" );
   System.out.println( room ); }}

< [abc[]def\[ghi\jkl] [mno\\]pqr\|] >

 Somewhat unusual, but this is specified in this way,
 so that brackets and backslashes can be used inside a
 bracketed string without escaping as often as possible.
 Only unpaired brackets and backslashes at the end of a
 string needs special handling.

 This output now will be used as input to check, that it
 will be serialized again to the same output. Of course,
 Java now requires to double backslashes:

import java.lang.String;
import java.lang.System;
import de.dclj.ram.notation.unotal.Room;
import static de.dclj.ram.notation.unotal.RoomFromModule.room;

public final class Main
{ public static void main( final String argv[] )
 { Room room = room( "< [abc[]def\\[ghi\\jkl] [mno\\\\]pqr\\|] >" );
   System.out.println( room ); }}

< [abc[]def\[ghi\jkl] [mno\\]pqr\|] >

Supersedes: <map-keys-20071114231003@ram.dialup.fu-berlin.de>